clash-controller 0.2.2__tar.gz → 0.2.4__tar.gz

{clash_controller-0.2.2 → clash_controller-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clash_controller
-Version: 0.2.2
+Version: 0.2.4
 Summary: A Textual TUI for managing Clash proxy instances
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/__init__.py

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

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/api.py

@@ -320,6 +320,81 @@ class ClashAPI:
         """Update a rule provider."""
         return self._request('PUT', f'/providers/rules/{quote(name)}')
 
+    def update_all_providers(self):
+        """更新所有代理合集 (proxy-providers) 与规则合集 (rule-providers)。
+
+        由于部分内核（如 Clash 原版）可能不支持 rule-provider 或不完全支持 PUT 批量，
+        此处通过遍历获取到的 provider 列表进行逐一更新。
+        """
+        # 1. 获取所有 Proxy Provider
+        proxy_res, err = self.get_proxy_providers()
+        if err:
+            return None, err
+        if isinstance(proxy_res, dict) and proxy_res.get("status_code") in (401, 403):
+            return None, f"鉴权失败 (HTTP {proxy_res.get('status_code')})"
+
+        # 2. 获取所有 Rule Provider
+        rule_res, err = self.get_rule_providers()
+        if err:
+            return None, err
+        if isinstance(rule_res, dict) and rule_res.get("status_code") in (401, 403):
+            return None, f"鉴权失败 (HTTP {rule_res.get('status_code')})"
+
+        # 解析名称列表
+        proxy_names = []
+        if isinstance(proxy_res, dict):
+            providers = proxy_res.get("providers")
+            if isinstance(providers, dict):
+                proxy_names = list(providers.keys())
+
+        rule_names = []
+        if isinstance(rule_res, dict):
+            providers = rule_res.get("providers")
+            if isinstance(providers, dict):
+                rule_names = list(providers.keys())
+
+        total = len(proxy_names) + len(rule_names)
+        if total == 0:
+            return {"status": "success", "message": "未检测到任何 Proxy Provider 或 Rule Provider"}, None
+
+        errors = []
+        success_count = 0
+
+        # 3. 逐一更新
+        for name in proxy_names:
+            res, err = self.update_proxy_provider(name)
+            if err:
+                errors.append(f"代理合集[{name}]: {err}")
+            elif isinstance(res, dict) and res.get("status_code") not in (200, 204) and res.get("status") != "success":
+                msg = res.get("message") or res.get("body") or f"HTTP {res.get('status_code')}"
+                errors.append(f"代理合集[{name}]: {msg}")
+            else:
+                success_count += 1
+
+        for name in rule_names:
+            res, err = self.update_rule_provider(name)
+            if err:
+                errors.append(f"规则合集[{name}]: {err}")
+            elif isinstance(res, dict) and res.get("status_code") not in (200, 204) and res.get("status") != "success":
+                msg = res.get("message") or res.get("body") or f"HTTP {res.get('status_code')}"
+                errors.append(f"规则合集[{name}]: {msg}")
+            else:
+                success_count += 1
+
+        if not errors:
+            return {
+                "status": "success",
+                "message": f"共更新 {len(proxy_names)} 个代理合集、{len(rule_names)} 个规则合集",
+            }, None
+
+        if success_count == 0:
+            return None, f"全部 Provider 更新失败: {'; '.join(errors)}"
+
+        return {
+            "status": "warn",
+            "message": f"成功更新 {success_count}/{total} 个 Provider，失败：{'; '.join(errors)}",
+        }, None
+
     # === Rules ===
     def get_rules(self):
         """Get all rules."""
@@ -400,3 +475,57 @@ def interpret_api_result(action_desc: str, result, error) -> tuple[str, str]:
 
     return (f"{action_desc}失败：{error}", "err")
 
+
+def _brief(raw, limit: int = 120) -> str:
+    """把任意响应体压成一行短文本，供提示栏/通知展示。"""
+    if raw is None:
+        return "无内容"
+    text = " ".join(str(raw).split())
+    if not text:
+        return "无内容"
+    return text[:limit] + "…" if len(text) > limit else text
+
+
+def _transport_hint(error: str) -> str:
+    """把 requests 的传输层错误翻译成人话，认不出来就截断原文。"""
+    low = error.lower()
+    if "connection refused" in low or "connection aborted" in low:
+        return "拒绝连接，请确认 Clash 已启动且控制端口正确"
+    if "max retries exceeded" in low:
+        return "无法连接到端点，请确认 Clash 已启动且地址端口正确"
+    if "timed out" in low:
+        return "连接超时，端点可能未响应"
+    if "name resolution" in low or "failed to resolve" in low or "nodename" in low:
+        return "无法解析主机地址"
+    if "ssl" in low or "certificate" in low:
+        return "TLS 握手失败"
+    if "authorization" in low or "unauthorized" in low:
+        return "鉴权失败，请检查 API 密钥"
+    return _brief(error)
+
+
+def interpret_connect_result(result, error) -> tuple[bool, str]:
+    """解释连接预检查（GET /version）：返回 ``(能否使用, 版本号或失败原因)``。
+
+    只读探测不存在「写操作已发送但断连」的歧义，所以 ``SENT_BUT_DISCONNECTED``
+    在此按连不上处理（写操作仍由 ``interpret_api_result`` 保留原语义）。
+    Clash 对密钥错误返回 401 且带响应体，ClashAPI 会把它当正常结果返回，
+    因此这里必须校验状态码与版本字段，否则会把鉴权失败误判为连接成功。
+    """
+    if error == ClashAPI.SENT_BUT_DISCONNECTED:
+        return False, "未能读回响应，端点可能未启动或未开放控制接口"
+    if error:
+        return False, _transport_hint(str(error))
+    if not isinstance(result, dict):
+        return False, f"端点返回了无法识别的内容：{_brief(result)}"
+
+    status_code = result.get("status_code")
+    if isinstance(status_code, int) and not 200 <= status_code < 300:
+        if status_code in (401, 403):
+            return False, f"鉴权失败（HTTP {status_code}），请检查端点 API 密钥"
+        return False, f"HTTP {status_code}：{_brief(result.get('body') or result.get('message'))}"
+
+    version = result.get("version")
+    if not version:
+        return False, f"响应中没有版本信息，可能不是 Clash 控制接口：{_brief(result)}"
+    return True, str(version)

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/app.py

@@ -2,16 +2,63 @@
 from datetime import datetime
 from pathlib import Path
 
+from rich.spinner import SPINNERS
+from rich.text import Text
 from textual import work
 from textual.app import App, ComposeResult
 from textual.binding import Binding
+from textual.widget import Widget
 from textual.widgets import Static
 
 from .api import ClashAPI
+from .widgets import ProgressCover
+
+_DOTS = SPINNERS["dots"]
 
 
 class StatusBar(Static):
-    """底部状态栏：展示最近一次操作结果 / 进行中提示。"""
+    """底部状态栏：展示最近一次操作结果 / 进行中提示；spinner=True 时显示点阵转圈。"""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._text = ""
+        self._busy = False
+        self._frame = 0
+        self._timer = None
+
+    def render(self) -> Text:
+        if self._busy:
+            glyph = _DOTS["frames"][self._frame % len(_DOTS["frames"])]
+            return Text.assemble((glyph, "bold"), " ", self._text)
+        return Text(self._text)
+
+    def set_status(self, text: str) -> None:
+        self._busy = False
+        self._text = text
+        self._stop_timer()
+        self.refresh()
+
+    def set_spinner(self, text: str) -> None:
+        self._busy = True
+        self._text = text
+        self._ensure_timer()
+        self.refresh()
+
+    def _ensure_timer(self) -> None:
+        if self._timer is None and self.is_mounted:
+            self._timer = self.set_interval(_DOTS["interval"] / 1000, self._tick)
+
+    def _stop_timer(self) -> None:
+        if self._timer is not None:
+            self._timer.stop()
+            self._timer = None
+
+    def _tick(self) -> None:
+        self._frame += 1
+        self.refresh()
+
+    def on_mount(self) -> None:
+        self._ensure_timer()
 
 
 class ClashControllerApp(App):
@@ -67,13 +114,29 @@ class ClashControllerApp(App):
     def compose(self) -> ComposeResult:
         yield StatusBar("", id="status")
 
+    def get_loading_widget(self) -> Widget:
+        """全局默认：任意控件 .loading=True 时用 indeterminate 进度条覆盖其区域。"""
+        return ProgressCover()
+
     def status(self, message: str, kind: str = "") -> None:
         try:
             bar = self.query_one("#status", StatusBar)
-        except Exception:
+        except Exception:  # noqa: BLE001
             return
         bar.update_classes({"ok": kind == "ok", "warn": kind == "warn", "err": kind == "err"})
-        bar.update(message)
+        bar.set_status(message)
+
+    def spinner(self, on: bool, message: str = "加载中…") -> None:
+        """状态栏点阵 spinner（无遮罩、不阻断输入）：适合轻量、即时的后台动作。"""
+        try:
+            bar = self.query_one("#status", StatusBar)
+        except Exception:  # noqa: BLE001
+            return
+        bar.update_classes({})
+        if on:
+            bar.set_spinner(message)
+        else:
+            bar.set_status("")
 
     def notify_ok(self, message: str) -> None:
         self.status(message, "ok")

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/screens/config.py

@@ -1,5 +1,6 @@
 """配置管理屏：配置提供方的增删改，以及拉取 / 比对 / 部署 / 重载流程。"""
 import asyncio
+import time
 
 from rich.text import Text
 from textual import on, work
@@ -11,7 +12,18 @@ from ..config import load_config_providers, save_config_providers
 from ..deploy import compute_sha256, evaluate_update, fetch_remote_config, read_current_config
 from ..ssh import apply_local_config_file, apply_remote_config_via_ssh
 from ..ui import PageScreen
-from ..widgets import ConfirmModal, FormField, FormModal, fit_table_columns, load_rows, make_table, shorten
+from ..widgets import (
+    ConfirmModal,
+    ControlBusy,
+    FormField,
+    FormModal,
+    busy,
+    fit_table_columns,
+    hold_busy,
+    load_rows,
+    make_table,
+    shorten,
+)
 
 COLUMN_WEIGHTS = [2, 7]
 
@@ -30,6 +42,7 @@ class ConfigScreen(PageScreen):
         super().__init__()
         self._providers: list = []
         self._display: list = []
+        self._busy = ControlBusy(self)
 
     def compose_page(self):
         with Vertical(classes="panel"):
@@ -39,6 +52,7 @@ class ConfigScreen(PageScreen):
                 yield Button("编辑", id="edit")
                 yield Button("删除", id="delete", variant="error")
                 yield Button("重载配置", id="reload-api")
+                yield Button("更新Provider", id="update-providers")
                 yield Static("", classes="fill")
                 yield Static("单击行 = 部署该提供方", classes="fl-label")
         yield make_table("名称", "地址", id="cf-table")
@@ -176,61 +190,62 @@ class ConfigScreen(PageScreen):
         debug = self.app.debug_mode or bool(profile.get("debug_ssh"))
         url = provider.get("url", "")
 
-        self.app.status(f"正在从 {url} 拉取配置…")
-        self.app.add_log(f"Fetching config from {url}...")
-        try:
-            remote_payload, remote_hash, remote_mod_time = await asyncio.to_thread(fetch_remote_config, url)
-            local_mtime, local_bytes = await asyncio.to_thread(
-                read_current_config, profile, self.app.add_log, debug
-            )
-        except Exception as e:  # noqa: BLE001
-            self.app.notify_err(f"拉取或读取配置失败: {type(e).__name__}: {e}")
-            return
+        async with busy(self.app, "正在拉取远程配置…", mode="bar") as ov:
+            self.app.add_log(f"Fetching config from {url}...")
+            try:
+                remote_payload, remote_hash, remote_mod_time = await asyncio.to_thread(fetch_remote_config, url)
+                ov.set_message("正在读取目标配置…")
+                local_mtime, local_bytes = await asyncio.to_thread(
+                    read_current_config, profile, self.app.add_log, debug
+                )
+            except Exception as e:  # noqa: BLE001
+                self.app.notify_err(f"拉取或读取配置失败: {type(e).__name__}: {e}")
+                return
 
-        local_hash = compute_sha256(local_bytes)
-        decision = evaluate_update(remote_hash, remote_mod_time, local_hash, local_mtime)
-
-        proceed = True
-        if decision == "auto":
-            self.app.add_log("Remote config newer with different hash. Proceeding without prompt.")
-        elif decision == "confirm_older":
-            proceed = await self.app.push_screen_wait(
-                ConfirmModal("远程配置可能比本地更旧，仍要覆盖目标配置吗？", default_yes=False)
-            )
-        elif decision == "confirm_unknown":
-            proceed = await self.app.push_screen_wait(
-                ConfirmModal("远程配置内容不同，但无法获取更新时间。是否继续覆盖目标配置？", default_yes=True)
-            )
-        else:  # confirm_same
-            proceed = await self.app.push_screen_wait(
-                ConfirmModal("远程配置与目标配置内容相同，仍要覆盖吗？", default_yes=False)
-            )
-
-        if not proceed:
-            self.app.status("已取消更新", "warn")
-            self.app.add_log("Config update cancelled by user after comparison.")
-            return
+            local_hash = compute_sha256(local_bytes)
+            decision = evaluate_update(remote_hash, remote_mod_time, local_hash, local_mtime)
 
-        self.app.status("正在部署配置…")
-        try:
-            if profile.get("endpoint_type") == "remote":
-                self.app.add_log("Deploying config to remote endpoint via SSH.")
-                await asyncio.to_thread(
-                    apply_remote_config_via_ssh, profile, remote_payload, self.app.add_log, debug
+            proceed = True
+            if decision == "auto":
+                self.app.add_log("Remote config newer with different hash. Proceeding without prompt.")
+            elif decision == "confirm_older":
+                proceed = await self.app.push_screen_wait(
+                    ConfirmModal("远程配置可能比本地更旧，仍要覆盖目标配置吗？", default_yes=False)
+                )
+            elif decision == "confirm_unknown":
+                proceed = await self.app.push_screen_wait(
+                    ConfirmModal("远程配置内容不同，但无法获取更新时间。是否继续覆盖目标配置？", default_yes=True)
+                )
+            else:  # confirm_same
+                proceed = await self.app.push_screen_wait(
+                    ConfirmModal("远程配置与目标配置内容相同，仍要覆盖吗？", default_yes=False)
                 )
-            else:
-                self.app.add_log("Deploying config to local endpoint file.")
-                await asyncio.to_thread(apply_local_config_file, profile, remote_payload)
-        except Exception as e:  # noqa: BLE001
-            self.app.notify_err(f"部署配置失败: {type(e).__name__}: {e}")
-            return
 
-        self.app.status("正在通过 Clash API 重载配置…")
-        try:
-            result, error = await asyncio.to_thread(self.app.get_api().reload_configs)
-        except Exception as e:  # noqa: BLE001
-            self.app.notify_err(f"重载配置失败: {type(e).__name__}: {e}")
-            return
+            if not proceed:
+                self.app.status("已取消更新", "warn")
+                self.app.add_log("Config update cancelled by user after comparison.")
+                return
+
+            ov.set_message("正在部署配置…")
+            try:
+                if profile.get("endpoint_type") == "remote":
+                    self.app.add_log("Deploying config to remote endpoint via SSH.")
+                    await asyncio.to_thread(
+                        apply_remote_config_via_ssh, profile, remote_payload, self.app.add_log, debug
+                    )
+                else:
+                    self.app.add_log("Deploying config to local endpoint file.")
+                    await asyncio.to_thread(apply_local_config_file, profile, remote_payload)
+            except Exception as e:  # noqa: BLE001
+                self.app.notify_err(f"部署配置失败: {type(e).__name__}: {e}")
+                return
+
+            ov.set_message("正在通过 Clash API 重载配置…")
+            try:
+                result, error = await asyncio.to_thread(self.app.get_api().reload_configs)
+            except Exception as e:  # noqa: BLE001
+                self.app.notify_err(f"重载配置失败: {type(e).__name__}: {e}")
+                return
         self.app.report("重载配置", result, error)
 
     @on(Button.Pressed, "#reload-api")
@@ -239,10 +254,41 @@ class ConfigScreen(PageScreen):
 
     @work(exclusive=True)
     async def _reload_api(self) -> None:
-        self.app.status("正在重载配置…")
+        """就地忙碌态反馈（与设置页一致）：禁用按钮 + 文本换成点阵 spinner。"""
+        api = self.app.get_api()
+        button = self.query_one("#reload-api", Button)
+        started = time.monotonic()
+        self._busy.start(button)
         try:
-            result, error = await asyncio.to_thread(self.app.get_api().reload_configs)
+            result, error = await asyncio.to_thread(api.reload_configs)
+            await hold_busy(started)
         except Exception as e:  # noqa: BLE001
+            await hold_busy(started)
             self.app.notify_err(f"重载配置失败: {type(e).__name__}: {e}")
             return
+        finally:
+            self._busy.stop()
         self.app.report("重载配置", result, error)
+
+    @on(Button.Pressed, "#update-providers")
+    def _on_update_providers(self) -> None:
+        self._update_providers()
+
+    @work(exclusive=True)
+    async def _update_providers(self) -> None:
+        """就地忙碌态反馈：禁用按钮 + 文本换成点阵 spinner。"""
+        api = self.app.get_api()
+        button = self.query_one("#update-providers", Button)
+        started = time.monotonic()
+        self._busy.start(button)
+        try:
+            result, error = await asyncio.to_thread(api.update_all_providers)
+            await hold_busy(started)
+        except Exception as e:  # noqa: BLE001
+            await hold_busy(started)
+            self.app.notify_err(f"更新Provider失败: {type(e).__name__}: {e}")
+            return
+        finally:
+            self._busy.stop()
+        self.app.report("更新Provider", result, error)
+

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/screens/overview.py

@@ -1,20 +1,34 @@
 """概览屏：版本 + 实时流量 / 内存（流式接口）+ 当前活动连接表（每秒轮询）。"""
 import asyncio
 import json
+import time
 from collections.abc import Callable
 from datetime import datetime
 
 from rich.text import Text
 from textual import work
 from textual.containers import Horizontal, Vertical
+from textual.dom import NoScreen
 from textual.widgets import DataTable, Static
 
 from ..ui import PageScreen
-from ..widgets import fit_table_columns, load_rows, make_table, shorten
+from ..widgets import fit_table_columns, hold_busy, load_rows, make_table, shorten
 
 COLUMN_WEIGHTS = [4, 1.5, 1.5, 3, 3]
 
 
+def _attached(widget) -> bool:
+    """控件链是否仍连着屏幕。
+
+    页面退出时 worker 会被取消，而父链可能先于 `is_mounted` 复位被摘掉，
+    这时写 `table.loading` 会抛 NoScreen（覆盖层本来也随页面一起消失了）。
+    """
+    try:
+        return widget.screen is not None
+    except NoScreen:
+        return False
+
+
 class OverviewScreen(PageScreen):
     TITLE = "概览"
     HINT = "↑↓ / PgUp / PgDn 滚动连接表 · Ctrl+R 刷新 · Esc/Ctrl+C 返回"
@@ -55,7 +69,7 @@ class OverviewScreen(PageScreen):
         self._consume("内存", api.get_memory_stream, self._on_memory)
         self.query_one(DataTable).focus()
         self._timer = self.set_interval(1.0, self._refresh_connections)
-        self._refresh_connections()
+        self._refresh_connections(show_overlay=True)
 
     def on_unmount(self) -> None:
         self._stop = True
@@ -72,7 +86,7 @@ class OverviewScreen(PageScreen):
 
     def reload_page(self) -> None:
         self._fetch_version()
-        self._refresh_connections()
+        self._refresh_connections(show_overlay=True)
 
     # ------------------------------------------------------------ 后台线程
 
@@ -130,50 +144,65 @@ class OverviewScreen(PageScreen):
         fit_table_columns(self.query_one("#cn-table", DataTable), COLUMN_WEIGHTS, rows=self._count)
 
     @work(exclusive=False)
-    async def _refresh_connections(self) -> None:
-        if self._busy or not self.is_mounted:
+    async def _refresh_connections(self, show_overlay: bool = False) -> None:
+        if self._busy:
             return
         self._busy = True
+        started = time.monotonic()
+        table = self.query_one("#cn-table", DataTable)
+        if show_overlay:
+            table.loading = True
         try:
-            data, error = await asyncio.to_thread(self.app.get_api().get_connections)
-        except Exception as e:  # noqa: BLE001
-            self._busy = False
-            self.app.notify_err(f"获取连接失败: {type(e).__name__}: {e}")
-            return
-        self._busy = False
-        if not self.is_mounted:
-            return
-
-        if error:
-            self.app.notify_err(f"获取连接失败: {error}")
-            return
-
-        data = data if isinstance(data, dict) else {}
-        connections = data.get("connections", []) or []
-        total_dl = data.get("downloadTotal", 0) / (1024 * 1024)
-        total_ul = data.get("uploadTotal", 0) / (1024 * 1024)
-
-        rows = []
-        for conn in connections:
-            metadata = conn.get("metadata", {}) or {}
-            host = metadata.get("host") or metadata.get("destinationIP", "未知")
-            rows.append([
-                Text(shorten(str(host), 40)),
-                Text(str(metadata.get("network", "?"))),
-                Text(str(metadata.get("type", "?"))),
-                Text(shorten(str(conn.get("rule", "?")), 30)),
-                Text(shorten(" -> ".join(conn.get("chains", []) or []), 30)),
-            ])
-        self._count = len(rows)
-        load_rows(self.query_one("#cn-table", DataTable), rows)
-        self._refit()
-        self.query_one("#cn-summary", Static).update(
-            Text(
-                f"{len(connections)} 条 · 上传 {total_ul:.2f} MB / 下载 {total_dl:.2f} MB"
-                f" · 更新于 {datetime.now():%H:%M:%S}"
+            try:
+                data, error = await asyncio.to_thread(self.app.get_api().get_connections)
+            except Exception as e:  # noqa: BLE001
+                self.app.notify_err(f"获取连接失败: {type(e).__name__}: {e}")
+                return
+            if not self.is_mounted:
+                return
+            if error:
+                self.app.notify_err(f"获取连接失败: {error}")
+                return
+
+            data = data if isinstance(data, dict) else {}
+            connections = data.get("connections", []) or []
+            total_dl = data.get("downloadTotal", 0) / (1024 * 1024)
+            total_ul = data.get("uploadTotal", 0) / (1024 * 1024)
+
+            rows = []
+            for conn in connections:
+                metadata = conn.get("metadata", {}) or {}
+                host = metadata.get("host") or metadata.get("destinationIP", "未知")
+                rows.append([
+                    Text(shorten(str(host), 40)),
+                    Text(str(metadata.get("network", "?"))),
+                    Text(str(metadata.get("type", "?"))),
+                    Text(shorten(str(conn.get("rule", "?")), 30)),
+                    Text(shorten(" -> ".join(conn.get("chains", []) or []), 30)),
+                ])
+            self._count = len(rows)
+            load_rows(table, rows)
+            self._refit()
+            self.query_one("#cn-summary", Static).update(
+                Text(
+                    f"{len(connections)} 条 · 上传 {total_ul:.2f} MB / 下载 {total_dl:.2f} MB"
+                    f" · 更新于 {datetime.now():%H:%M:%S}"
+                )
             )
-        )
-        self.app.status(f"连接总数 {len(connections)}")
+            self.app.status(f"连接总数 {len(connections)}")
+        finally:
+            self._busy = False
+            if show_overlay:
+                # 无论正常/异常/取消，覆盖层都必须撤下
+                try:
+                    if self.is_mounted:
+                        await hold_busy(started)
+                finally:
+                    if _attached(table):
+                        table.loading = False
+                if _attached(table):
+                    self.call_after_refresh(self._refit)  # 覆盖层撤下后区域宽可能变化，按最终宽度重排
+                    table.focus()
 
     # ------------------------------------------------------------ UI 更新
 

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/screens/profiles.py

@@ -1,5 +1,6 @@
 """端点档案屏（根屏）：居中 LOGO 版式，选择 / 连接 / 新增 / 编辑 / 删除（含 SSH 子表单）。"""
 import asyncio
+import time
 
 from rich.text import Text
 from textual import on, work
@@ -9,10 +10,11 @@ from textual.screen import Screen
 from textual.widgets import Button, OptionList, Static
 
 from .. import __version__
+from ..api import interpret_connect_result
 from ..config import load_profiles, save_profiles
 from ..deploy import default_endpoint_type
 from ..ui import LOGO_WIDTH, home_col_width, logo_text
-from ..widgets import ConfirmModal, FormField, FormModal, HintBar, MenuMarquee
+from ..widgets import ConfirmModal, FormField, FormModal, HintBar, MenuMarquee, busy, hold_busy
 
 try:  # textual 各版本 Option 导出位置不同
     from textual.widgets.option_list import Option
@@ -308,24 +310,46 @@ class ProfileListScreen(Screen):
         if error:
             self.app.notify_err(f"{profile.get('name', '?')}: {error}")
             return
+        name = str(profile.get("name", "?") or "?")
+        url = str(profile.get("url", "") or "")
         self.app.set_profile(profile)
-        self.app.add_log(f"Selected profile '{profile.get('name')}'.")
-        self.app.status(f"正在连接 {profile.get('url')} …")
-        try:
-            version_info, error = await asyncio.to_thread(self.app.get_api().get_version)
-        except Exception as e:  # noqa: BLE001
-            self.app.notify_err(f"连接失败: {type(e).__name__}: {e}")
+        self.app.add_log(f"Selected profile '{name}'.")
+        self.app.status(f"正在连接 {url} …")
+        started = time.monotonic()
+        version_info = None
+        api_error = None
+        conn_exc: Exception | None = None
+        async with busy(self.app, f"正在连接 {url} …", mode="bar"):
+            try:
+                version_info, api_error = await asyncio.to_thread(self.app.get_api().get_version)
+            except Exception as e:  # noqa: BLE001
+                conn_exc = e
+            # 本地 API 常在 1 帧内返回，补足最短可见时长，避免进度条「看不见」
+            await hold_busy(started)
+
+        if conn_exc is not None:
+            ok, detail = False, f"{type(conn_exc).__name__}: {conn_exc}"
+        else:
+            ok, detail = interpret_connect_result(version_info, api_error)
+
+        if not ok:
+            # 预检查不通过：留在端点选择界面，清掉档案，避免后续页面拿到坏客户端
+            message = f"无法连接端点 {name}（{url}）：{detail}"
+            self.app.add_log(message)
+            self.app.notify_err(message)
             self.app.clear_profile()
+            self.call_after_refresh(self._focus_list)
             return
-        if version_info:
-            version = version_info.get("version", "unknown")
-            self.app.add_log(f"Successfully connected to Clash (version: {version}).")
-            from .home import HomeScreen
 
-            self.app.push_screen(HomeScreen())
-        else:
-            self.app.notify_err(f"连接失败，请检查端点配置并确认 Clash 正在运行。错误：{error}")
-            self.app.clear_profile()
+        self.app.add_log(f"Successfully connected to Clash (version: {detail}).")
+        self.app.status(f"已连接 {name} · {detail}", "ok")
+        from .home import HomeScreen
+
+        self.app.push_screen(HomeScreen())
+
+    def _focus_list(self) -> None:
+        if self.is_mounted:
+            self.query_one("#pf-list", OptionList).focus()
 
     # ------------------------------------------------------------ 增删改
 

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/screens/settings.py

@@ -1,12 +1,13 @@
 """设置屏：TUN / 模式即时生效控件（无保存动作）、重载与升级操作；日志入口在顶栏折叠菜单。"""
 import asyncio
+import time
 
 from textual import on, work
 from textual.containers import Horizontal, Vertical
 from textual.widgets import Button, Select, Static, Switch
 
 from ..ui import PageScreen
-from ..widgets import ConfirmModal
+from ..widgets import ConfirmModal, ControlBusy, hold_busy
 
 MODES = [("规则", "rule"), ("全局", "global"), ("直连", "direct")]
 
@@ -19,6 +20,7 @@ class SettingsScreen(PageScreen):
         super().__init__()
         self._tun = False
         self._mode = "rule"
+        self._busy = ControlBusy(self)
         self.menu = [("查看应用日志", self._open_logs, False)]
 
     def compose_page(self):
@@ -32,6 +34,8 @@ class SettingsScreen(PageScreen):
         with Vertical(classes="panel"):
             with Horizontal(classes="filter-row"):
                 yield Static("核心操作", classes="fl-label")
+                yield Button("重载配置", id="reload-conf")
+                yield Button("更新Provider", id="update-providers")
                 yield Button("重载 GEO", id="reload-geo")
             with Horizontal(classes="filter-row gap-top"):
                 yield Static("重启升级", classes="fl-label")
@@ -83,7 +87,7 @@ class SettingsScreen(PageScreen):
         if bool(event.value) == self._tun:
             return
         self._tun = bool(event.value)
-        self._call("toggle_tun", f"{'启用' if self._tun else '禁用'} TUN", self._tun)
+        self._call("toggle_tun", f"{'启用' if self._tun else '禁用'} TUN", self._tun, control_id="st-tun")
 
     @on(Select.Changed, "#st-mode")
     def _on_mode_changed(self, event: Select.Changed) -> None:
@@ -94,45 +98,68 @@ class SettingsScreen(PageScreen):
             return
         self._mode = mode
         labels = dict(MODES)
-        self._call("set_mode", f"切换模式为 {labels.get(mode, mode)}", mode)
+        self._call(
+            "set_mode", f"切换模式为 {labels.get(mode, mode)}", mode, control_id="st-mode"
+        )
+
+    @on(Button.Pressed, "#reload-conf")
+    def _on_reload_conf(self) -> None:
+        self._call("reload_configs", "重载配置", control_id="reload-conf")
+
+    @on(Button.Pressed, "#update-providers")
+    def _on_update_providers(self) -> None:
+        self._call("update_all_providers", "更新Provider", control_id="update-providers")
 
     @on(Button.Pressed, "#reload-geo")
     def _on_reload_geo(self) -> None:
-        self._call("reload_geo_databases", "重载 GEO 数据库")
+        self._call("reload_geo_databases", "重载 GEO 数据库", control_id="reload-geo")
 
     @on(Button.Pressed, "#restart")
     def _on_restart(self) -> None:
-        self._confirm_then("确定要重启 Clash Core 吗？", "restart", "重启 Clash Core")
+        self._confirm_then("确定要重启 Clash Core 吗？", "restart", "重启 Clash Core", "restart")
 
     @on(Button.Pressed, "#up-kernel")
     def _on_up_kernel(self) -> None:
-        self._confirm_then("确定要请求升级内核吗？", "upgrade_kernel", "升级内核")
+        self._confirm_then("确定要请求升级内核吗？", "upgrade_kernel", "升级内核", "up-kernel")
 
     @on(Button.Pressed, "#up-ui")
     def _on_up_ui(self) -> None:
-        self._confirm_then("确定要请求升级 UI 吗？", "upgrade_ui", "升级 UI")
+        self._confirm_then("确定要请求升级 UI 吗？", "upgrade_ui", "升级 UI", "up-ui")
 
     @on(Button.Pressed, "#up-geo")
     def _on_up_geo(self) -> None:
-        self._confirm_then("确定要请求升级 GEO 数据库吗？", "upgrade_geo_databases", "升级 GEO 数据库")
+        self._confirm_then("确定要请求升级 GEO 数据库吗？", "upgrade_geo_databases", "升级 GEO 数据库", "up-geo")
 
-    def _confirm_then(self, message: str, method_name: str, desc: str) -> None:
+    def _confirm_then(self, message: str, method_name: str, desc: str, control_id: str) -> None:
         def confirm(ok: bool) -> None:
             if ok:
-                self._call(method_name, desc)
+                self._call(method_name, desc, control_id=control_id)
 
         self.app.push_screen(ConfirmModal(message, default_yes=False), confirm)
 
     @work(exclusive=True)
-    async def _call(self, method_name: str, desc: str, *args) -> None:
+    async def _call(self, method_name: str, desc: str, *args, control_id: str | None = None) -> None:
         api = self.app.get_api()
         method = getattr(api, method_name)
-        self.app.status(f"正在{desc}…")
+        started = time.monotonic()
+        control = self.query_one(f"#{control_id}") if control_id else None
+        if control is not None:
+            # 就地反馈：禁用触发控件并把文本换成点阵 spinner（比顶栏更直观）
+            self._busy.start(control)
+        else:
+            self.app.spinner(True, f"正在{desc}…")
         try:
             result, error = await asyncio.to_thread(method, *args)
+            await hold_busy(started)
         except Exception as e:  # noqa: BLE001
+            await hold_busy(started)
             self.app.notify_err(f"{desc}失败: {type(e).__name__}: {e}")
             self._load_configs()  # 失败回滚控件到服务端真实状态
             return
+        finally:
+            if control is not None:
+                self._busy.stop()
+            else:
+                self.app.spinner(False)
         self.app.report(desc, result, error)
         self._load_configs()  # 以服务端状态为准回写控件（失败时即回滚）

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/ui.py

@@ -12,6 +12,7 @@ from rich.text import Text
 from textual import on
 from textual.binding import Binding
 from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.css.query import NoMatches
 from textual.screen import Screen
 from textual.widgets import Button, Input, OptionList, Static, TextArea
 
@@ -176,14 +177,25 @@ class PageScreen(Screen):
     # ------------------------------------------------------------ 标题 / 副标题
 
     def set_subtitle(self, text: str) -> None:
+        """更新顶栏副标题。
+
+        判定不能用 ``is_mounted``：`on_mount` 里它仍是 `False`（Textual 派发完
+        Mount 事件之后才置位），首屏副标题会永远停在空串。改为按顶栏控件是否
+        已组合判断：未组合时仅保存文本，交由 compose 使用。
+        """
         self.subtitle = text
-        if self.is_mounted:
+        try:
             self.query_one("#tb-sub", Static).update(text)
+        except NoMatches:
+            pass
 
     def set_title(self, text: str) -> None:
+        """更新顶栏标题；判定口径同 set_subtitle。"""
         self.TITLE = text
-        if self.is_mounted:
+        try:
             self.query_one(".tb-title", Static).update(Text(text, style="bold"))
+        except NoMatches:
+            pass
 
     # ------------------------------------------------------------ 折叠菜单
 

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller/widgets.py

@@ -3,18 +3,40 @@
 所有模态均为 ModalScreen 泛型返回值，配合 push_screen_wait / 回调消费；
 数据展示统一使用 DataTable（ClickTable 单击执行），不构造字符串伪表格。
 """
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any
 
 from rich.cells import cell_len
+from rich.spinner import SPINNERS
+from rich.style import Style
 from rich.text import Text
 from textual import events
 from textual.binding import Binding
+from textual.clock import Clock
 from textual.containers import Horizontal, ScrollableContainer, Vertical, VerticalScroll
 from textual.coordinate import Coordinate
+from textual.css.query import NoMatches
 from textual.screen import ModalScreen
-from textual.widgets import Button, DataTable, Input, Label, OptionList, Select, Static, Switch, TextArea
+from textual.widget import Widget
+from textual.widgets import (
+    Button,
+    DataTable,
+    Input,
+    Label,
+    LoadingIndicator,
+    OptionList,
+    ProgressBar,
+    Select,
+    Static,
+    Switch,
+    TextArea,
+)
 
 try:  # textual 各版本 Option 导出位置不同
     from textual.widgets.option_list import Option
@@ -340,7 +362,7 @@ class FormModal(ModalScreen["dict | None"]):
             text = HINT_FORM
         self.query_one("#frm-hint", HintBar).update(text)
 
-    def _collect(self) -> "dict | None":
+    def _collect(self) -> dict | None:
         """收集表单值；校验失败时写入错误信息并返回 None。可在子类扩展。"""
         err_box = self.query_one("#frm-error", Static)
         err_box.update(Text(""))
@@ -699,10 +721,268 @@ def fit_table_columns(table: DataTable, weights: list[float], rows: int | None =
     return visible
 
 
+# ---------------------------------------------------------------- 加载指示器
+
+class _IndeterminateBar:
+    """自渲染不定进度条：按**绘制时**的区域宽度取景并居中。
+
+    不依赖 ``Widget.size``：覆盖层是交给合成器临时绘制的，首帧 ``_size`` 可能
+    尚未由 ``_size_updated`` 写入，若在 ``render()`` 里读 ``self.size`` 会拿到 0
+    而画出一格宽的「隐形条」。改用 Rich 渲染协议，``options.max_width`` 即为本次
+    真正要绘制的区域宽度，保证任何一帧都居中可见。
+    """
+
+    def __init__(
+        self, clock: Clock, animation_level: str, highlight: Style, track: Style, cap: int
+    ) -> None:
+        self._clock = clock
+        self._animation_level = animation_level
+        self._highlight = highlight
+        self._track = track
+        self._cap = cap
+
+    def __rich_console__(self, console, options):  # noqa: ANN001, ANN201
+        total = max(1, options.max_width)
+        width = min(total, self._cap)
+        bar = max(2, int(width * 0.25))
+        span = width + bar
+        if self._animation_level == "none":
+            start = 0
+        else:
+            speed = 30  # cells/s，与 Textual ProgressBar 的 indeterminate 一致
+            pos = int((speed * self._clock.time) % (2 * span))
+            if pos > span:
+                pos = 2 * span - pos
+            start = pos - bar
+        text = Text()
+        for i in range(width):
+            text.append("━", style=self._highlight if start <= i < start + bar else self._track)
+        yield text
+
+
+class ProgressCover(Widget):
+    """控件 loading=True 时覆盖其区域的不定进度条（方框 + 居中往复高亮条）。
+
+    必须是**单个自渲染 widget**：Textual 的 ``Widget._cover()`` 只把它交给合成器
+    替换原控件区域，并不挂进 DOM 参与布局；若用容器 + 子件，子件 region 恒为 0
+    而完全不可见（``ProgressBar`` 自身 compose 出 ``Bar`` 子件，因此同样不可用）。
+    """
+
+    COMPONENT_CLASSES = {"pc--bar", "pc--highlight"}
+
+    DEFAULT_CSS = """
+    ProgressCover {
+        width: 100%;
+        height: 100%;
+        background: $surface;
+        border: round $secondary;
+        margin: 1 1 0 1;
+        content-align: center middle;
+        &> .pc--bar { color: $panel-lighten-1; background: $surface; }
+        &> .pc--highlight { color: $primary; background: $surface; }
+    }
+    """
+
+    BAR_WIDTH = 40
+    """进度条固定宽（与全屏 BusyOverlay `.busy-box` 的内容宽一致），由 content-align 居中。"""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._clock = Clock()
+
+    def on_mount(self) -> None:
+        self._clock.reset()
+        self.auto_refresh = 1 / 15
+
+    def render(self) -> _IndeterminateBar:
+        highlight = Style.from_color(self.get_component_rich_style("pc--highlight").color)
+        track = Style.from_color(self.get_component_rich_style("pc--bar").color)
+        return _IndeterminateBar(
+            self._clock, self.app.animation_level, highlight, track, self.BAR_WIDTH
+        )
+
+
+class BusyOverlay(ModalScreen[None]):
+    """全屏忙碌遮罩：阻断一切输入直到被 pop。
+
+    使用固定宽度（46）与分行结构防止文案变化引起容器抖动或 Emoji 换行。
+    """
+
+    DEFAULT_CSS = """
+    BusyOverlay {
+        align: center middle;
+        background: $boost;
+    }
+    BusyOverlay .busy-box {
+        width: 46;
+        height: auto;
+        min-height: 5;
+        padding: 1 2;
+        border: round $primary;
+        background: $surface;
+        align: center middle;
+    }
+    BusyOverlay #busy-title {
+        width: 100%;
+        content-align: center middle;
+        text-style: bold;
+        text-wrap: nowrap;
+        text-overflow: ellipsis;
+        overflow: hidden;
+        margin-bottom: 1;
+    }
+    BusyOverlay LoadingIndicator { width: 100%; height: 1; }
+    BusyOverlay ProgressBar { width: 100%; }
+    BusyOverlay #busy-counter {
+        width: 100%;
+        content-align: center middle;
+        color: $text-muted;
+        margin-top: 1;
+    }
+    """
+
+    def __init__(self, message: str = "正在处理…", *, mode: str = "dots", total: float | None = None) -> None:
+        super().__init__()
+        self._message = message
+        self._mode = mode
+        self._total = total
+        self._done = 0.0
+
+    def compose(self):
+        with Vertical(classes="busy-box"):
+            yield Static(self._message, id="busy-title")
+            if self._mode == "bar":
+                yield ProgressBar(total=None, show_bar=True, show_percentage=False, show_eta=False)
+            elif self._mode == "percent":
+                yield ProgressBar(total=self._total, show_percentage=True, show_eta=False)
+                yield Static(f"0/{int(self._total or 0)} (0%)", id="busy-counter")
+            else:
+                yield LoadingIndicator()
+
+    def set_message(self, message: str) -> None:
+        self._message = message
+        if self.is_mounted:
+            with contextlib.suppress(NoMatches):
+                self.query_one("#busy-title", Static).update(message)
+
+    def advance(self, amount: float = 1) -> None:
+        """percent 模式：推进进度条并刷新计数文案。"""
+        self._done += amount
+        if self.is_mounted:
+            with contextlib.suppress(NoMatches):
+                bar = self.query_one(ProgressBar)
+                bar.progress += amount
+                if self._mode == "percent":
+                    pct = int(round((self._done / (self._total or 1)) * 100))
+                    self.query_one("#busy-counter", Static).update(
+                        f"{int(self._done)}/{int(self._total or 0)} ({pct}%)"
+                    )
+
+
+@contextlib.asynccontextmanager
+async def busy(app, message: str = "正在处理…", *, mode: str = "dots", total: float | None = None):
+    """异步 worker 内包裹耗时操作，全程显示全屏忙碌遮罩（异常/取消亦收起）。
+
+    用法：async with busy(self.app, "正在保存…", mode="bar"): await asyncio.to_thread(...)
+    需要进度回调时接住返回的遮罩对象：async with busy(app, "拉取中", mode="percent", total=n) as ov: ...
+    """
+    overlay = BusyOverlay(message, mode=mode, total=total)
+    app.push_screen(overlay)
+    try:
+        yield overlay
+    finally:
+        # 确保遮罩被收起：可能仍是栈顶，也可能已被其它层覆盖
+        for _ in range(len(app.screen_stack)):
+            if isinstance(app.screen, BusyOverlay) or app.screen is overlay:
+                app.pop_screen()
+            else:
+                break
+        if overlay.is_mounted:
+            overlay.remove()
+
+
+# ---------------------------------------------------------------- 控件就地忙碌态
+
+BUSY_MIN_SECONDS = 0.3
+"""忙碌态最短可见时长（秒）：本地 API 常在 1 帧内返回，过短的反馈肉眼看不见。"""
+
+
+async def hold_busy(started: float) -> None:
+    """把忙碌反馈补足到 BUSY_MIN_SECONDS，避免快速操作只闪一帧。"""
+    remaining = BUSY_MIN_SECONDS - (time.monotonic() - started)
+    if remaining > 0:
+        await asyncio.sleep(remaining)
+
+
+class ControlBusy:
+    """异步操作期间在触发控件上就地反馈：禁用控件 + 文本换成点阵 spinner。
+
+    - `Button`：改写自身 `label`（如 `⠋ 重启 Clash`），结束后复原。
+    - `Select` / `Switch`：禁用控件，并在同行左侧标签（`.kv-label` / `.fl-label`）前插 spinner。
+    """
+
+    def __init__(self, screen) -> None:
+        self.screen = screen
+        self._control = None
+        self._targets: list[tuple[object, str]] = []
+        self._frame = 0
+        self._timer = None
+
+    @staticmethod
+    def _row_label(control):
+        parent = control.parent
+        if parent is not None:
+            for child in parent.children:
+                if isinstance(child, Static):
+                    return child
+        return None
+
+    def start(self, control) -> None:
+        self.stop()
+        self._control = control
+        control.disabled = True
+        if isinstance(control, Button):
+            self._targets.append((control, control.label.plain))
+        else:
+            label = self._row_label(control)
+            if label is not None:
+                self._targets.append((label, str(label.content)))
+        self._apply()
+        self._timer = self.screen.set_interval(SPINNERS["dots"]["interval"] / 1000, self._tick)
+
+    def _apply(self) -> None:
+        frames = SPINNERS["dots"]["frames"]
+        glyph = frames[self._frame % len(frames)]
+        for widget, original in self._targets:
+            if isinstance(widget, Button):
+                widget.label = f"{glyph} {original}"
+            else:
+                widget.update(f"{glyph} {original}")
+
+    def _tick(self) -> None:
+        self._frame += 1
+        self._apply()
+
+    def stop(self) -> None:
+        if self._timer is not None:
+            self._timer.stop()
+            self._timer = None
+        for widget, original in self._targets:
+            if isinstance(widget, Button):
+                widget.label = original
+            else:
+                widget.update(original)
+        self._targets = []
+        if self._control is not None:
+            self._control.disabled = False
+            self._control = None
+
+
 __all__ = [
     "ConfirmModal", "InputModal", "FormField", "FormModal", "OutputModal",
     "ClickTable", "make_table", "load_rows", "filter_fuzzy", "fuzzy_score",
     "shorten", "rcell", "fit_table_columns",
+    "ProgressCover", "BusyOverlay", "busy", "ControlBusy", "hold_busy", "BUSY_MIN_SECONDS",
     "tint", "colored_text",
     "STYLE_OK", "STYLE_ERR", "STYLE_WARN", "STYLE_INFO", "STYLE_DIM",
     "HINT_PICK", "HINT_MENU", "HINT_FORM", "EDIT_HINT", "HINT_FORM_EDIT", "HINT_FORM_TA",

{clash_controller-0.2.2 → clash_controller-0.2.4}/clash_controller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clash_controller
-Version: 0.2.2
+Version: 0.2.4
 Summary: A Textual TUI for managing Clash proxy instances
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT

{clash_controller-0.2.2 → clash_controller-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clash_controller"
-version = "0.2.2"
+version = "0.2.4"
 description = "A Textual TUI for managing Clash proxy instances"
 readme = "README.md"
 requires-python = ">=3.10"