proxyctl 0.5.11__tar.gz → 0.5.13__tar.gz

{proxyctl-0.5.11 → proxyctl-0.5.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proxyctl
-Version: 0.5.11
+Version: 0.5.13
 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.11 → proxyctl-0.5.13}/pyproject.toml

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

{proxyctl-0.5.11 → proxyctl-0.5.13}/src/proxyctl/check.py

@@ -113,13 +113,19 @@ def _route_from_connections(conns: list[dict], host: str) -> dict:
     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.
+
+    /connections 的顺序是任意的，且热 reload 不会掐断旧 keep-alive 连接——
+    规则改过之后旧连接的 chains 还是旧路由。取 start 最新的一条匹配连接
+    （check 刚发完探测请求，最新的最接近当前规则的真实路由）。
     """
-    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]
+    matched = [
+        conn for conn in conns
+        if (h := (conn.get("metadata") or {}).get("host") or "") == host
+        or h.endswith("." + host)
+    ]
+    if matched:
+        newest = max(matched, key=lambda c: str(c.get("start") or ""))
+        chains = [str(c) for c in (newest.get("chains") or []) if c]
         return {
             "found": True,
             "line": chains[0] if chains else "?",

{proxyctl-0.5.11 → proxyctl-0.5.13}/src/proxyctl/cli.py

@@ -7,6 +7,7 @@
 """
 
 import functools
+import ipaddress
 import json
 import os
 import platform
@@ -1327,6 +1328,30 @@ def cmd_dns_unlock(config: dict):
 
 # ── 命令：env ────────────────────────────────────────────────────────────────
 
+def _normalize_no_proxy_extra(extra) -> list[str]:
+    """Return NO_PROXY extras compatible with Python/httpx environment parsing."""
+    if not extra:
+        return []
+    if isinstance(extra, str):
+        items = [s.strip() for s in extra.split(",")]
+    else:
+        items = [str(s).strip() for s in extra]
+
+    out: list[str] = []
+    for item in items:
+        if not item:
+            continue
+        try:
+            network = ipaddress.ip_network(item, strict=False)
+        except ValueError:
+            out.append(item)
+            continue
+        if network.version == 6 and "/" in item:
+            continue
+        out.append(item)
+    return out
+
+
 def cmd_env(config: dict, unset: bool = False):
     """输出设置/清除代理环境变量的 shell 语句。
 
@@ -1350,9 +1375,7 @@ def cmd_env(config: dict, unset: bool = False):
     proxy_socks = f"socks5://127.0.0.1:{port}"
     no_proxy = "localhost,127.0.0.1,::1,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
     # 用户附加的 NO_PROXY 项（个人域名等）；接受 list[str] 或逗号分隔 str
-    extra = config.get("no_proxy_extra") or []
-    if isinstance(extra, str):
-        extra = [s.strip() for s in extra.split(",") if s.strip()]
+    extra = _normalize_no_proxy_extra(config.get("no_proxy_extra"))
     if extra:
         no_proxy = no_proxy + "," + ",".join(extra)
 

{proxyctl-0.5.11 → proxyctl-0.5.13}/src/proxyctl/explain.py

@@ -217,7 +217,10 @@ def _t_env(backend, config) -> TopicCard:
             f"`proxyctl env` 输出 export 行，可 eval 进当前 shell（端口 {port}）。"
         ),
         "file": _io_proxyctl_config_path() + "  [no_proxy_extra: 字段]",
-        "edit": "  # no_proxy_extra: 追加内网域名 / Tailscale 段 / 企业 host",
+        "edit": (
+            "  # no_proxy_extra: 追加内网域名 / IPv4 CIDR / 企业 host\n"
+            "  # 裸 IPv6 CIDR 会被跳过，避免 Python/httpx 误解析 NO_PROXY"
+        ),
         "verify": "eval \"$(proxyctl env)\" && env | grep -i proxy",
         "next_commands": ["env", "env --unset"],
     }

{proxyctl-0.5.11 → proxyctl-0.5.13}/src/proxyctl/trace.py

@@ -506,20 +506,30 @@ def _section_connections(domain: str, resolved_ips: list,
     """[4/4] 实际连接验证 — 从 Clash API 活跃连接 + 日志历史中取路由信息。"""
     print(f"\n{BOLD}[4/4] 实际连接{NC}")
 
-    domain_conns = []
+    host_conns = []
+    ip_conns = []
     for _ in range(3):
         data = _api_get(api, "/connections", secret)
         if data and isinstance(data, dict):
             for c in (data.get("connections") or []):
                 m  = c.get("metadata", {})
-                h  = m.get("host", "")
                 di = m.get("destinationIP", "")
-                if (h == domain or h.endswith("." + domain)
-                        or (di and di in resolved_ips)):
-                    domain_conns.append(c)
-        if domain_conns:
+                # sniffer/TUN 模式下 host 可能是目的 IP 或为空，真实域名落在
+                # sniffHost（嗅探到的 SNI / HTTP Host）。两字段独立判断、不互相
+                # 遮蔽：任一匹配即纳入；只有两者都缺失（纯 IP）才按目的 IP 回退
+                hosts = [x for x in (m.get("host", ""), m.get("sniffHost", "")) if x]
+                if any(x == domain or x.endswith("." + domain) for x in hosts):
+                    host_conns.append(c)
+                elif not hosts and di and di in resolved_ips:
+                    # host/sniffHost 都没有的纯 IP 连接才回退；任一字段非空但
+                    # 指向别的域名的连接，即使同 IP 也不算进来——否则共享 IP 下
+                    # 会把同 IP 别站的活跃连接误算成本域名
+                    ip_conns.append(c)
+        if host_conns or ip_conns:
             break
         time.sleep(0.3)
+    # host 精确匹配优先；只有全是无 host 的连接时才回退到按 IP 匹配的那批
+    domain_conns = host_conns if host_conns else ip_conns
 
     if not domain_conns:
         # 没有活跃连接，从引擎日志中捞历史记录
@@ -536,54 +546,64 @@ def _section_connections(domain: str, resolved_ips: list,
                 print(f"  {DIM}基于规则预测，该域名应走: {BOLD}{predicted_proxy}{NC}")
         return
 
-    # 去重：按 rule+chains
-    seen: set = set()
-    deduped = []
+    def fmt_bytes(b: int) -> str:
+        if b < 1024:        return f"{b}B"
+        if b < 1024 * 1024: return f"{b/1024:.1f}K"
+        return f"{b/1024/1024:.1f}M"
+
+    # 按完整链路聚合：相同链路的连接合并计数、流量累加，不再逐条平铺
+    groups: dict = {}
     for c in domain_conns:
-        rule   = c.get("rule", "?")
-        rp     = c.get("rulePayload", "")
         chains = c.get("chains", [])
-        key    = f"{rule}|{rp}|{','.join(chains)}"
-        if key not in seen:
-            seen.add(key)
-            deduped.append(c)
-
-    for c in deduped:
-        rule       = c.get("rule", "?")
-        rp         = c.get("rulePayload", "")
-        chains     = c.get("chains", [])
-        chain_str  = " → ".join(reversed(chains)) if chains else "?"
-        rp_str     = f"({rp})" if rp else ""
-        print(f"  规则: {CYAN}{rule}{rp_str}{NC}")
-        print(f"  链路: {chain_str}")
-
-    # 与预测对比
+        chain_str = " → ".join(reversed(chains)) if chains else "?"
+        g = groups.setdefault(chain_str, {"chains": chains, "count": 0,
+                                          "up": 0, "down": 0})
+        g["count"] += 1
+        g["up"]   += c.get("upload", 0)
+        g["down"] += c.get("download", 0)
+
+    # 是否符合预测：预测的组名出现在链路任意一跳即算命中。
+    #   proxy 链 chains=[节点, proxy-tuic, proxy] → 含 'proxy' → 符合
+    #   DIRECT 链 chains=['DIRECT']              → 不含       → 不符合
+    # （不再纠结 chains[0] 是末端节点还是 chains[-1] 是入口组——用集合判定消除歧义）
+    def _matches(chains: list):
+        if not predicted_proxy:
+            return None
+        return any(ch.lower() == predicted_proxy.lower() for ch in chains)
+
+    total = len(domain_conns)
+    print(f"  {DIM}(mihomo 当前活跃连接 {total} 条){NC}")
     if predicted_proxy:
-        actual_chains  = domain_conns[0].get("chains", [])
-        actual_outbound = actual_chains[-1] if actual_chains else "?"
-        if actual_outbound.lower() != predicted_proxy.lower():
-            print(f"  {YELLOW}⚠ 预测出口 {predicted_proxy}，实际出口 {actual_outbound}{NC}")
+        print(f"  应走(规则预测): {BOLD}{predicted_proxy}{NC}")
+    print("  实走:")
+
+    items = [(_matches(g["chains"]), s, g) for s, g in groups.items()]
+    items.sort(key=lambda x: (x[0] is not True, -x[2]["count"]))  # 符合在前，多的在前
+
+    match_n = mismatch_n = 0
+    for ok, chain_str, g in items:
+        if ok is True:
+            mark = f"{GREEN}✓{NC}"; match_n += g["count"]
+        elif ok is False:
+            mark = f"{YELLOW}✗{NC}"; mismatch_n += g["count"]
         else:
-            print(f"  {GREEN}✓ 与规则预测一致{NC}")
-
-    # 连接详情
-    print(f"  {DIM}---{NC}")
-    domain_conns.sort(key=lambda x: x.get("start", ""), reverse=True)
-    for c in domain_conns[:5]:
-        m      = c.get("metadata", {})
-        host   = m.get("host", "?")
-        dport  = m.get("destinationPort", "?")
-        up     = c.get("upload", 0)
-        down   = c.get("download", 0)
-        chains = c.get("chains", [])
-        outbound = chains[0] if chains else "?"
-
-        def fmt_bytes(b: int) -> str:
-            if b < 1024:         return f"{b}B"
-            if b < 1024 * 1024:  return f"{b/1024:.1f}K"
-            return f"{b/1024/1024:.1f}M"
+            mark = " "
+        flow = f"↑{fmt_bytes(g['up'])} ↓{fmt_bytes(g['down'])}"
+        print(f"    {mark} {chain_str}  {DIM}·{NC}  {g['count']} 条  {DIM}{flow}{NC}")
 
-        print(f"  {host}:{dport}  {outbound}  ↑{fmt_bytes(up)} ↓{fmt_bytes(down)}")
+    if not predicted_proxy:
+        return
+    if mismatch_n == 0:
+        print(f"  {GREEN}✓ 结论: 全部 {total} 条都走 {predicted_proxy}，与规则一致{NC}")
+    elif match_n == 0:
+        print(f"  {YELLOW}✗ 结论: {total} 条都没走 {predicted_proxy}；"
+              f"规则可能未生效，或被前置规则截胡{NC}")
+    else:
+        print(f"  {YELLOW}⚠ 结论: {match_n} 条新连接已走 {predicted_proxy}，"
+              f"另 {mismatch_n} 条仍走旧链路{NC}")
+        print(f"  {DIM}     旧链路是改规则前建立的连接（建连时已定死，不随规则切换），"
+              f"会随超时自然断开；{NC}")
+        print(f"  {DIM}     刷新页面后即全部走 {predicted_proxy}。{NC}")
 
 
 def cmd_trace(raw_input: str, api: str, secret: str, config: dict = None):