proxyctl 0.5.8__tar.gz → 0.5.10__tar.gz

{proxyctl-0.5.8 → proxyctl-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proxyctl
-Version: 0.5.8
+Version: 0.5.10
 Summary: Proxy configuration lifecycle management for macOS and Linux
 Project-URL: Homepage, https://github.com/crhan/proxyctl
 Project-URL: Issues, https://github.com/crhan/proxyctl/issues

{proxyctl-0.5.8 → proxyctl-0.5.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "proxyctl"
-version = "0.5.8"
+version = "0.5.10"
 description = "Proxy configuration lifecycle management for macOS and Linux"
 readme = "README.md"
 requires-python = ">=3.10"

{proxyctl-0.5.8 → proxyctl-0.5.10}/src/proxyctl/audit.py

@@ -180,8 +180,18 @@ def _is_covered(host: str, suffix_set: set) -> bool:
     return any(".".join(parts[i:]) in suffix_set for i in range(len(parts)))
 
 
+_AUDIT_DENY_OUTBOUNDS = {"block", "reject"}
+
+
 def _load_rules() -> tuple:
-    """从双 config 读取 direct/proxy 域名后缀规则集。"""
+    """从双 config 读取 direct/proxy 域名后缀规则集。
+
+    分类策略：``direct`` outbound 归 direct；``block`` / ``reject`` 忽略；
+    其它任意 outbound 名（用户的命名组如 ``proxy`` / ``residential-tw`` /
+    个人命名组等）一律视为"代理类"，归入 ``proxy_suffixes``。
+    这里**不 hardcode 任何具体的代理组名**——通用基线插件和 audit 都不
+    应假设用户配置里有某个特定名字的组。
+    """
     direct_suffixes: set = set()
     proxy_suffixes: set = set()
 
@@ -189,12 +199,15 @@ def _load_rules() -> tuple:
     try:
         cfg = json.load(open(SB_CONFIG))
         for rule in cfg.get("route", {}).get("rules", []):
-            ob = rule.get("outbound", "")
+            ob = (rule.get("outbound") or "").strip()
+            if not ob:
+                continue
+            ob_lc = ob.lower()
             for s in rule.get("domain_suffix", []):
                 s = s.lstrip(".")
-                if ob == "direct":
+                if ob_lc == "direct":
                     direct_suffixes.add(s)
-                elif ob in ("proxy", "claude"):
+                elif ob_lc not in _AUDIT_DENY_OUTBOUNDS:
                     proxy_suffixes.add(s)
     except Exception:
         pass
@@ -202,13 +215,17 @@ def _load_rules() -> tuple:
     # mihomo YAML (文本扫描，无需解析完整 YAML)
     try:
         for line in open(MH_CONFIG):
-            m = re.match(r'\s*-\s+DOMAIN-SUFFIX,([^,]+),(DIRECT|proxy|claude)', line, re.I)
-            if m:
-                dom, target = m.group(1), m.group(2)
-                if target.upper() == "DIRECT":
-                    direct_suffixes.add(dom)
-                else:
-                    proxy_suffixes.add(dom)
+            # group(2) 取第一个 outbound 段（到下一个逗号或空白），
+            # 避免把 "proxy,no-resolve" 整体当作 outbound 名。
+            m = re.match(r'\s*-\s+DOMAIN-SUFFIX,([^,]+),([^,\s]+)', line, re.I)
+            if not m:
+                continue
+            dom, target = m.group(1), m.group(2)
+            target_lc = target.lower()
+            if target_lc == "direct":
+                direct_suffixes.add(dom)
+            elif target_lc not in _AUDIT_DENY_OUTBOUNDS:
+                proxy_suffixes.add(dom)
     except Exception:
         pass
 

{proxyctl-0.5.8 → proxyctl-0.5.10}/src/proxyctl/builtin_plugins/connectivity_basic.py

@@ -3,12 +3,17 @@
 提供一组跨所有用户都通用的连通性测试点：
 - 海外（走代理）：google / github
 - 国内（直连）：baidu
-- AI 线路：anthropic（走 claude 规则组）
+- AI 线路：openai / anthropic
 
 本机特例（discord/telegram、企业内网等）请走用户插件。
 
 代理组：默认提供 "proxy"（绝大多数 mihomo/sing-box 配置都有这个组）。
-其他组（claude / residential-* 等）由用户插件提供。
+命名组（如 claude / residential-* 等）和针对它们的 expected_proxy 校验、
+出口探测都属本机特例，请放到 ~/.config/proxyctl/plugins/ 的用户插件里，
+不要 hardcode 进这个通用基线插件。
+
+出口探测：默认只提供 proxy（走主代理）/ direct（绕代理）两路对照，
+足够做分流校验；其它命名出口由用户插件按 name 追加或覆盖。
 """
 
 from proxyctl.core.plugin import CheckTarget, OutboundProbe, Plugin
@@ -24,17 +29,18 @@ class ConnectivityBasic(Plugin):
         return [
             CheckTarget(name="google", url="https://www.google.com", mode="proxy"),
             CheckTarget(name="github", url="https://github.com",     mode="proxy"),
+            CheckTarget(name="openai",
+                        url="https://api.openai.com/v1/models",
+                        mode="proxy"),
             CheckTarget(name="baidu",  url="https://www.baidu.com",  mode="direct"),
             CheckTarget(name="anthropic",
-                        url="https://api.anthropic.com",
-                        mode="proxy",
-                        expected_proxy="claude"),
+                        url="https://api.anthropic.com/v1/models",
+                        mode="proxy"),
         ]
 
     def check_outbound_probes(self, ctx: dict) -> list[OutboundProbe]:
         return [
             OutboundProbe(name="proxy", mode="proxy", url="https://api.ipify.org"),
-            OutboundProbe(name="claude", mode="proxy", url="https://ipinfo.io/ip"),
             OutboundProbe(name="direct",
                           mode="direct",
                           url="https://myip.ipip.net",

{proxyctl-0.5.8 → proxyctl-0.5.10}/src/proxyctl/check.py

@@ -35,6 +35,11 @@ def _strip_ansi(s: str) -> str:
     return _ANSI_RE.sub("", s).strip()
 
 
+def _visible_len(s: str) -> int:
+    """Return printable width for simple check output alignment."""
+    return len(_ANSI_RE.sub("", s))
+
+
 def _port_listening(port: int) -> bool:
     try:
         with socket.create_connection(("127.0.0.1", port), timeout=0.5):
@@ -54,7 +59,7 @@ def _test_url(url: str, desc: str, mode: str = "proxy", timeout: int = 8,
     env = {k: v for k, v in os.environ.items()
            if k not in ("http_proxy", "https_proxy", "all_proxy",
                         "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY")}
-    cmd = ["curl", "-s", "-o", "/dev/null", "-w", "%{http_code}",
+    cmd = ["curl", "--http1.1", "-s", "-o", "/dev/null", "-w", "%{http_code}",
            "--max-time", str(timeout)]
     if mode == "proxy":
         cmd += ["--proxy", f"socks5h://127.0.0.1:{proxy_port}"]
@@ -66,7 +71,8 @@ def _test_url(url: str, desc: str, mode: str = "proxy", timeout: int = 8,
     code = r.stdout.strip()
 
     if code == "000" or not code:
-        return False, f"  {RED}✗{NC} {desc:<18s} {url:<44s} {RED}timeout{NC}"
+        reason = _curl_failure_reason(r.stderr)
+        return False, f"  {RED}✗{NC} {desc:<18s} {url:<44s} {RED}{reason}{NC}"
     elif code.startswith(("2", "3", "4")):
         return True,  f"  {GREEN}✓{NC} {desc:<18s} {url:<44s} {GREEN}{code}{NC}"
     elif code.startswith("5"):
@@ -76,6 +82,16 @@ def _test_url(url: str, desc: str, mode: str = "proxy", timeout: int = 8,
         return False, f"  {YELLOW}?{NC} {desc:<18s} {url:<44s} {YELLOW}{code}{NC}"
 
 
+def _curl_failure_reason(stderr: str) -> str:
+    """Return a concise curl failure reason for HTTP code 000."""
+    text = (stderr or "").strip()
+    if not text:
+        return "timeout"
+    first = text.splitlines()[0].strip()
+    first = first.removeprefix("curl: ").strip()
+    return first[:120] if first else "timeout"
+
+
 def _api_connections(api_base: str, api_secret: str) -> list[dict]:
     r = subprocess.run(
         ["curl", "-s", "--noproxy", "*",
@@ -91,26 +107,130 @@ def _api_connections(api_base: str, api_secret: str) -> list[dict]:
     return conns if isinstance(conns, list) else []
 
 
-def _target_uses_expected_proxy(api_base: str, api_secret: str, url: str,
-                                expected_proxy: str) -> tuple[bool, str]:
+def _route_from_connections(conns: list[dict], host: str) -> dict:
+    """Find one Mihomo route for host and expose leaf line + policy group.
+
+    Mihomo reports chains from leaf node to policy group, for example
+    ``["TW-Residential-01", "residential-tw", "claude"]``. The human
+    "line" is the leaf node, not the policy group.
+    """
+    for conn in conns:
+        meta = conn.get("metadata") or {}
+        conn_host = meta.get("host") or ""
+        if conn_host != host and not conn_host.endswith("." + host):
+            continue
+        chains = [str(c) for c in (conn.get("chains") or []) if c]
+        return {
+            "found": True,
+            "line": chains[0] if chains else "?",
+            "group": chains[-1] if chains else "",
+            "chain": " → ".join(reversed(chains)) if chains else "?",
+        }
+    return {"found": False, "line": "?", "group": "", "chain": ""}
+
+
+def _target_route(api_base: str, api_secret: str, url: str) -> dict:
+    """Return the observed route for a URL from local Mihomo connections."""
     host = urllib.parse.urlparse(url).hostname or ""
-    if not host or not expected_proxy:
-        return True, ""
+    if not host:
+        return {"found": False, "line": "?", "group": "", "chain": ""}
 
     for _ in range(3):
-        for conn in _api_connections(api_base, api_secret):
-            meta = conn.get("metadata") or {}
-            conn_host = meta.get("host") or ""
-            if conn_host != host and not conn_host.endswith("." + host):
-                continue
-            chains = conn.get("chains") or []
-            actual = chains[-1] if chains else ""
-            chain_str = " → ".join(reversed(chains)) if chains else "?"
-            if actual.lower() == expected_proxy.lower():
-                return True, f" via {chain_str}"
-            return False, f" expected {expected_proxy}, got {actual or '?'}"
+        route = _route_from_connections(_api_connections(api_base, api_secret),
+                                        host)
+        if route.get("found"):
+            return route
         time.sleep(0.2)
-    return False, f" expected {expected_proxy}, no active connection found"
+    return {"found": False, "line": "?", "group": "", "chain": ""}
+
+
+def _route_matches_expected_proxy(route: dict,
+                                  expected_proxy: str) -> tuple[bool, str]:
+    """Validate an observed route's terminal policy group."""
+    if not expected_proxy:
+        return True, ""
+    if not route.get("found"):
+        return False, f" expected {expected_proxy}, no active connection found"
+
+    actual = str(route.get("group") or "")
+    if actual.lower() == expected_proxy.lower():
+        return True, ""
+    return False, f" expected {expected_proxy}, got {actual or '?'}"
+
+
+def _target_uses_expected_proxy(api_base: str, api_secret: str, url: str,
+                                expected_proxy: str) -> tuple[bool, str]:
+    if not urllib.parse.urlparse(url).hostname or not expected_proxy:
+        return True, ""
+    return _route_matches_expected_proxy(
+        _target_route(api_base, api_secret, url), expected_proxy)
+
+
+def _connectivity_line_value(mode: str) -> str:
+    """Return the default route-line label for one check target mode.
+
+    proxy 模式默认值是 em dash ("—") 而非问号——含义是"反查不到活动连接"，
+    比裸 "?" 信息密度更高、视觉更安静。真实反查命中时会被实际链路覆盖。
+    """
+    if mode == "direct":
+        return "direct"
+    if mode == "proxy":
+        return "—"
+    return "-"
+
+
+def _append_route_column(line: str, route_line: str,
+                         route_chain: str = "") -> str:
+    """Append the observed route in the same style as Mihomo chains."""
+    value = route_chain or route_line or "-"
+    pad = max(2, 74 - _visible_len(line))
+    return f"{line}{' ' * pad}{DIM}via{NC} {value:<32s}"
+
+
+def _dedupe_check_targets(targets: list) -> list:
+    """Drop exact duplicate connectivity targets from multiple plugins.
+
+    Builtin plugins load before user plugins. Keep the first target's display
+    order, but merge an expected_proxy from a duplicate if the first one lacks
+    it, so a stale user plugin cannot remove route validation by accident.
+    """
+    out = []
+    seen = {}
+    for target in targets:
+        key = (getattr(target, "name", ""),
+               getattr(target, "url", ""),
+               getattr(target, "mode", ""))
+        if key in seen:
+            kept = seen[key]
+            expected = getattr(target, "expected_proxy", "")
+            if expected and not getattr(kept, "expected_proxy", ""):
+                kept.expected_proxy = expected
+            continue
+        seen[key] = target
+        out.append(target)
+    return out
+
+
+def _dedupe_outbound_probes(probes: list) -> list:
+    """Collapse outbound probes that share a (name, mode) identity.
+
+    A probe answers one question — "what IP does this egress show?" — so two
+    probes with the same ``name`` and ``mode`` are the same egress row even if
+    they hit different URLs (e.g. a builtin ``https://myip.ipip.net`` vs a user
+    plugin's ``http://`` variant). User plugins load after builtins, so the
+    later probe wins on conflict (本机特例覆盖通用基线), while the original
+    display position is preserved so row order stays stable across runs.
+    """
+    out: list = []
+    index: dict = {}  # (name, mode) -> position in out
+    for probe in probes:
+        key = (getattr(probe, "name", ""), getattr(probe, "mode", ""))
+        if key in index:
+            out[index[key]] = probe  # later (user) probe overrides earlier
+            continue
+        index[key] = len(out)
+        out.append(probe)
+    return out
 
 
 def _test_dns(desc: str, server: str, domain: str) -> tuple:
@@ -716,7 +836,7 @@ def _collect_fail_hints(collector: dict, *, dns_bad: bool, failed: bool) -> list
     if basic.get("daemon_up") is False:
         hints.append("engine not running")
 
-    # connectivity: 列表形式，每项 {name, url, ok, message}
+    # connectivity: 列表形式，每项 {name, url, mode, line, route_chain, ok, message}
     conn = stages.get("connectivity") or []
     failed_conns = [c.get("name", "?") for c in conn
                     if isinstance(c, dict) and not c.get("ok")]
@@ -794,7 +914,8 @@ def cmd_check(engine, api: str, api_secret: str,
     # [4/4] 出口 IP 探测：从插件收集到的 probes 决定有哪些出口
     probes = []
     if registry is not None:
-        probes = registry.collect("check_outbound_probes", ctx={})
+        probes = _dedupe_outbound_probes(
+            registry.collect("check_outbound_probes", ctx={}))
     probe_ips: dict[str, str] = {p.name: "" for p in probes}
 
     # 临时常量：probes 在端口解析之前启动，所以这里用 config 直接拿
@@ -1051,7 +1172,8 @@ def cmd_check(engine, api: str, api_secret: str,
     ctx = {"corp_net": corp_net, "mode": mode, "engine": engine.name}
     targets = []
     if registry is not None:
-        targets = registry.collect("check_targets", ctx=ctx)
+        targets = _dedupe_check_targets(
+            registry.collect("check_targets", ctx=ctx))
 
     # 应用 only_when 过滤
     def _target_enabled(t):
@@ -1074,6 +1196,9 @@ def cmd_check(engine, api: str, api_secret: str,
     ready    = [threading.Event() for _ in targets]
 
     def _run_test(idx, target):
+        route_line = _connectivity_line_value(target.mode)
+        route_chain = ""
+        route_note = ""
         try:
             if target.mode == "dns":
                 # url 格式: dns:<server>:<domain>
@@ -1083,21 +1208,63 @@ def cmd_check(engine, api: str, api_secret: str,
                 parts = target.url.removeprefix("tcp:").rsplit(":", 1)
                 ok, line = _test_tcp(parts[0], int(parts[1]), target.name)
             else:
+                # proxy 模式：在 curl 测试**进行中**并发轮询 mihomo 的
+                # /connections，趁连接还活着抓到自己请求走的链路。
+                # curl 短连接测完即从 mihomo 连接表移除，如果等 curl 结束
+                # 后再查（旧实现），几乎抓不到自己刚发的请求 —— 这是
+                # google/github/openai 的 via 列长期显示 "?" 的根因。
+                host = urllib.parse.urlparse(target.url).hostname or ""
+                captured: dict = {}
+                stop_evt = threading.Event()
+                poller = None
+                if target.mode == "proxy" and host:
+                    def _poll():
+                        # Event.wait(timeout) 在 set 时立即返回 True，
+                        # 不会被 sleep 拖住停止响应。
+                        while not stop_evt.is_set():
+                            r = _route_from_connections(
+                                _api_connections(api, api_secret), host)
+                            if r.get("found"):
+                                captured.update(r)
+                                return
+                            stop_evt.wait(0.08)
+                    poller = threading.Thread(target=_poll, daemon=True)
+                    poller.start()
+
                 ok, line = _test_url(target.url, target.name,
                                      target.mode, target.timeout,
                                      proxy_port=proxy_port)
+
+                if poller is not None:
+                    stop_evt.set()
+                    poller.join(timeout=0.5)
+
                 expected = getattr(target, "expected_proxy", "")
-                if ok and expected:
-                    route_ok, route_msg = _target_uses_expected_proxy(
-                        api, api_secret, target.url, expected)
-                    ok = route_ok
-                    if route_ok:
-                        line += f"  {GREEN}{route_msg}{NC}"
-                    else:
-                        line += f"  {RED}{route_msg}{NC}"
+                if target.mode == "proxy" and ok:
+                    # 优先取 curl 期间并发抓到的；抓不到时回退 _target_route，
+                    # 它可能从外部进程的活动长连接里命中（如用户的浏览器/
+                    # Claude Code 正在访问同一 host）。两者都没找到时
+                    # route_line 保留默认的 "—" 占位（_connectivity_line_value
+                    # 提供的友好兜底），而不是裸 "?"。
+                    route = (captured if captured.get("found")
+                             else _target_route(api, api_secret, target.url))
+                    if route.get("found"):
+                        route_line = str(route.get("line") or route_line)
+                        route_chain = str(route.get("chain") or "")
+                    if expected:
+                        route_ok, route_msg = _route_matches_expected_proxy(
+                            route, expected)
+                        ok = route_ok
+                        if route_ok:
+                            route_note = f"  {GREEN}{route_msg}{NC}"
+                        else:
+                            route_note = f"  {RED}{route_msg}{NC}"
+            line = _append_route_column(line, route_line, route_chain)
+            line += route_note
         except Exception as e:
             ok, line = False, f"  {RED}✗{NC} {target.name}  error: {e}"
-        results[idx] = (line, ok)
+            line = _append_route_column(line, route_line, route_chain)
+        results[idx] = (line, ok, route_line, route_chain)
         ready[idx].set()
 
     if targets:
@@ -1106,7 +1273,7 @@ def cmd_check(engine, api: str, api_secret: str,
                 pool.submit(_run_test, idx, target)
             for idx in range(len(targets)):
                 ready[idx].wait()
-                line, ok = results[idx]
+                line, ok, route_line, route_chain = results[idx]
                 print(line)
                 if not ok:
                     fail = True
@@ -1114,6 +1281,8 @@ def cmd_check(engine, api: str, api_secret: str,
                     "name": targets[idx].name,
                     "url": targets[idx].url,
                     "mode": targets[idx].mode,
+                    "line": route_line,
+                    "route_chain": route_chain,
                     "ok": bool(ok),
                     "message": _strip_ansi(line),
                 })