procproxy 0.1.0__py3-none-any.whl

proxycore/log.py

@@ -0,0 +1,298 @@
+"""结构化日志 + 脱敏（日志字段与脱敏）。
+
+红线：
+* 口令、`Proxy-Authorization`/`Authorization` 头内容、Cookie 一律不落盘；
+* URL 的 query 参数截断；
+* 报文级内容只在 TRACE 且显式开启。
+
+本模块只依赖标准库，`decide()` 热路径不得调用其中的格式化函数（用惰性参数）。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import sys
+from datetime import datetime
+from typing import Any
+
+# ------------------------------------------------------------------ 级别 ----
+TRACE = 5
+logging.addLevelName(TRACE, "TRACE")
+
+LEVELS: dict[str, int] = {
+    "TRACE": TRACE,
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARN": logging.WARNING,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRITICAL": logging.CRITICAL,
+}
+
+DEFAULT_LEVEL = "INFO"
+
+# 报文级内容是否允许出现（默认关闭）
+TRACE_PAYLOAD_ENABLED = False
+_REDACTED = "***REDACTED***"
+_USER = "user"
+
+# ------------------------------------------------ 敏感字段名 / 正则 --------
+_SENSITIVE_KEYS = {
+    "password",
+    "passwd",
+    "pass",
+    "pwd",
+    "secret",
+    "token",
+    "authorization",
+    "proxy-authorization",
+    "cookie",
+    "set-cookie",
+    "password_ref",
+    "api_key",
+    "apikey",
+    "credential",
+    "credentials",
+    # 代理"别名/用户名"统一替换成 user
+    "user",
+    "username",
+    "proxy_user",
+}
+
+# 值里出现 "key: value" / "key=value" 形态的敏感赋值，一律替换。
+# 值允许带引号、也允许是 "Basic xxx" / "NTLM xxx" 这种两段式认证头。
+_KV_PATTERN = re.compile(
+    r"""(?ix)
+    (?P<q>["']?)                                       # 可选的键引号（JSON 形态）
+    (?P<key>password|passwd|pass|pwd|secret|token|api[_-]?key|authorization|proxy-authorization|cookie)
+    (?P=q)                                             # 引号必须闭合
+    \s*(?P<sep>[:=]\s*)
+    (?P<val>"[^"]*"|'[^']*'|(?:Basic|NTLM|Bearer)\s+[A-Za-z0-9+/=._~-]+|[^\s,;"'&]+)
+    """
+)
+
+# 必须先处理的两类：① 整行认证头；② URL；③ 键值对
+_AUTH_LINE_PATTERN = re.compile(
+    r"(?im)^(?P<indent>\s*)(?P<key>proxy-authorization|authorization|cookie|set-cookie)\s*:\s*(?P<val>.*)$"
+)
+_JS_AUTH_PATTERN = re.compile(
+    r"(?i)(?P<key>proxy-authorization|authorization|cookie)(?P<sep>['\"]?\s*:\s*['\"])(?P<val>[^'\"]*)"
+)
+
+# URL query：只保留 path，query 一律截断（保留键名便于排错，值替换）
+_URL_QUERY_PATTERN = re.compile(r"(?P<url>[a-zA-Z][a-zA-Z0-9+.-]*://[^\s?#]*)\?(?P<query>[^\s#]*)(?P<frag>#[^\s]*)?")
+
+# user:pass@host 形态
+_USERINFO_PATTERN = re.compile(r"(?P<scheme>[a-zA-Z][a-zA-Z0-9+.-]*://)(?P<user>[^:/@\s]+):(?P<pw>[^@/\s]+)@")
+
+
+def _redact_query(query: str) -> str:
+    if not query:
+        return ""
+    out: list[str] = []
+    for pair in query.split("&"):
+        if not pair:
+            continue
+        key, sep, _value = pair.partition("=")
+        out.append(f"{key}{sep}{_REDACTED}" if sep else key)
+    return "&".join(out)
+
+
+def redact(value: Any) -> Any:
+    """对任意值做脱敏；递归处理 dict/list/str。
+
+    * dict 里敏感键名 → `user`（代理别名/用户名/口令统一替换）
+    * 字符串里的 `password=xxx`、`Proxy-Authorization: xxx`、URL query → 替换
+    """
+    if isinstance(value, dict):
+        return {k: (_USER if str(k).lower() in _SENSITIVE_KEYS else redact(v)) for k, v in value.items()}
+    if isinstance(value, tuple):
+        return tuple(redact(v) for v in value)
+    if isinstance(value, list):
+        return [redact(v) for v in value]
+    if isinstance(value, str):
+        return redact_text(value)
+    return value
+
+
+def redact_text(text: str) -> str:
+    """字符串级脱敏（可单独单测）。
+
+    顺序很重要：
+    1. URL 里的 `user:pass@host`；
+    2. URL 的 query（保留键名，值替换）；
+    3. 整行认证头（`Authorization:` / `Cookie:` 等，整值替换）；
+    4. 行内 `"Proxy-Authorization": "xxx"` 形态（JSON/JS）；
+    5. `key=value` / `key: value` 形态（含 JSON 的 `"key":"value"`）。
+    """
+    out = _USERINFO_PATTERN.sub(lambda m: f"{m.group('scheme')}{_USER}:{_REDACTED}@", text)
+    out = _URL_QUERY_PATTERN.sub(
+        lambda m: f"{m.group('url')}?{_redact_query(m.group('query') or '')}{m.group('frag') or ''}", out
+    )
+    out = _AUTH_LINE_PATTERN.sub(lambda m: f"{m.group('indent')}{m.group('key')}: {_REDACTED}", out)
+    out = _JS_AUTH_PATTERN.sub(lambda m: f"{m.group('key')}{m.group('sep')}{_REDACTED}", out)
+    out = _KV_PATTERN.sub(lambda m: f"{m.group('q')}{m.group('key')}{m.group('q')}{m.group('sep')}{_REDACTED}", out)
+    return out
+
+
+# ------------------------------------------------------------- JSONL ------
+def _now_iso() -> str:
+    return datetime.now().astimezone().isoformat(timespec="milliseconds")
+
+
+class JsonlFormatter(logging.Formatter):
+    """固定字段的 JSONL 输出。"""
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, Any] = {
+            "ts": _now_iso(),
+            "level": record.levelname,
+            "event": getattr(record, "event", record.name),
+            "msg": redact_text(record.getMessage()) if record.getMessage() else "",
+        }
+        extra = getattr(record, "fields", None)
+        if isinstance(extra, dict):
+            payload.update(redact(extra))
+        if record.exc_info:
+            payload["exc"] = redact_text(self.formatException(record.exc_info))
+        return json.dumps(payload, ensure_ascii=False)
+
+
+class ConsoleFormatter(logging.Formatter):
+    """人读格式（Windows 控制台友好）。"""
+
+    def format(self, record: logging.LogRecord) -> str:
+        ts = datetime.now().astimezone().strftime("%H:%M:%S.%f")[:-3]
+        event = getattr(record, "event", "")
+        fields = getattr(record, "fields", None)
+        tail = ""
+        if isinstance(fields, dict) and fields:
+            safe = redact(fields)
+            tail = " " + " ".join(f"{k}={_flat(v)}" for k, v in safe.items())
+        base = f"{ts} {record.levelname:<5} {redact_text(record.getMessage())}"
+        if event:
+            base += f" [{event}]"
+        return base + tail + ("\n" + redact_text(self.formatException(record.exc_info)) if record.exc_info else "")
+
+
+def _flat(value: Any) -> str:
+    if isinstance(value, str):
+        return value if " " not in value else json.dumps(value, ensure_ascii=False)
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, ensure_ascii=False)
+    return str(value)
+
+
+def build_logger(
+    name: str = "proxycore",
+    level: str | int = DEFAULT_LEVEL,
+    jsonl_path: str | None = None,
+    console: bool = True,
+    *,
+    propagate: bool = True,
+) -> logging.Logger:
+    """构造日志器：默认 INFO + 人读控制台；给 `jsonl_path` 时额外输出 JSONL。
+
+    注意：模块内用的是 `proxycore.*` 子日志器（如 `proxycore.runtime`）。
+    为了让它们的记录汇到同一处，本函数会把父日志器设为负责输出的那一层，
+    并让子日志器只用 `propagate` 把记录传上去（不再各自建 handler）。
+    """
+    logger = logging.getLogger(name)
+    logger.handlers.clear()
+    logger.setLevel(_coerce_level(level))
+    # 子日志器交给父层处理（否则 proxycore.runtime 等会各自输出一份/或什么都不输出）
+    logger.propagate = propagate
+
+    if console:
+        handler = logging.StreamHandler(sys.stderr)
+        handler.setFormatter(ConsoleFormatter())
+        logger.addHandler(handler)
+
+    if jsonl_path:
+        os.makedirs(os.path.dirname(os.path.abspath(jsonl_path)), exist_ok=True)
+        file_handler = logging.FileHandler(jsonl_path, encoding="utf-8")
+        file_handler.setFormatter(JsonlFormatter())
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def _coerce_level(level: str | int) -> int:
+    if isinstance(level, int):
+        return level
+    return LEVELS.get(level.upper(), logging.INFO)
+
+
+def enable_trace_payload(enabled: bool = True) -> None:
+    """报文级内容开关（默认关闭，必须显式开启）。"""
+    global TRACE_PAYLOAD_ENABLED
+    TRACE_PAYLOAD_ENABLED = enabled
+
+
+class EventLogger:
+    """薄封装：`log.event("session_end", session_id=1, ...)`。"""
+
+    def __init__(self, logger: logging.Logger) -> None:
+        self._logger = logger
+        self._extra_enabled = True
+
+    @property
+    def logger(self) -> logging.Logger:
+        return self._logger
+
+    def _emit(self, level: int, event: str, msg: str = "", **fields: Any) -> None:
+        self._logger.log(level, msg or event, extra={"event": event, "fields": fields}, stacklevel=3)
+
+    def trace(self, event: str, msg: str = "", **fields: Any) -> None:
+        if self._logger.isEnabledFor(TRACE):
+            self._emit(TRACE, event, msg, **fields)
+
+    def debug(self, event: str, msg: str = "", **fields: Any) -> None:
+        if self._logger.isEnabledFor(logging.DEBUG):
+            self._emit(logging.DEBUG, event, msg, **fields)
+
+    def info(self, event: str, msg: str = "", **fields: Any) -> None:
+        if self._logger.isEnabledFor(logging.INFO):
+            self._emit(logging.INFO, event, msg, **fields)
+
+    def warn(self, event: str, msg: str = "", **fields: Any) -> None:
+        self._emit(logging.WARNING, event, msg, **fields)
+
+    def error(self, event: str, msg: str = "", **fields: Any) -> None:
+        self._emit(logging.ERROR, event, msg, **fields)
+
+    def session_end(self, session: Any, reason: str = "ok") -> None:
+        """每条会话结束必须输出固定字段的一行。"""
+        self.info(
+            "session_end",
+            session_id=session.id,
+            pid=session.proc.pid,
+            proc=session.proc.name,
+            rule=session.rule_id,
+            proto=session.proto.value,
+            dst=str(session.original),
+            upstream=session.upstream,
+            state=session.state,
+            bytes_up=session.bytes_up,
+            bytes_down=session.bytes_down,
+            duration_ms=round(session.duration_ms, 3),
+            reason=reason,
+        )
+
+
+def get_logger(name: str = "proxycore") -> logging.Logger:
+    """取日志器。未配置时用默认配置初始化父层（`proxycore`），子日志器只负责传递。"""
+    root_name = name.split(".", 1)[0] if "." in name else name
+    root = logging.getLogger(root_name)
+    if not root.handlers and root_name == "proxycore":
+        build_logger(root_name)
+    logger = logging.getLogger(name)
+    if name != root_name:
+        # 子日志器不自己建 handler：交给 `proxycore` 层统一输出
+        logger.handlers.clear()
+        logger.propagate = True
+        logger.setLevel(logging.NOTSET)
+    return logger

proxycore/pathsetup.py

@@ -0,0 +1,112 @@
+"""让 `python -m proxycore ...` 在任意目录可用（零依赖，可撤销）。
+
+问题：`python -m proxycore` 需要 `src/` 在 `sys.path` 上。常规做法是
+`pip install -e .`，但它需要 setuptools/网络；本机没有 setuptools。
+
+本工具用的是同一套机制（`site-packages` 下的 `.pth` 文件会被解释器自动执行），
+但不依赖 setuptools，也不需要网络：
+
+    python -m proxycore install-path     # 写入 <site-packages>/proxycore-dev.pth
+    python -m proxycore install-path status      # 查看当前状态
+    python -m proxycore install-path uninstall   # 删除该 .pth
+
+写入的内容是 `src/` 的绝对路径。所以：
+* 之后在任何目录都能 `python -m proxycore ...`；
+* 仓库移动位置后要重新 `install`；
+* 卸载就是删掉那个文件（`uninstall` 或手动删）。
+"""
+
+from __future__ import annotations
+
+import argparse
+import pathlib
+import site
+import sys
+
+# 本模块现在住在 `src/proxycore/` 里，所以"要写进 .pth 的目录"就是它的上上级（即 `src/`）。
+SRC_DIR = pathlib.Path(__file__).resolve().parent.parent
+REPO_ROOT = SRC_DIR.parent
+PTH_NAME = "proxycore-dev.pth"
+
+
+def site_packages_dirs() -> list[pathlib.Path]:
+    out: list[pathlib.Path] = []
+    for candidate in [*site.getsitepackages(), site.getusersitepackages()]:
+        path = pathlib.Path(candidate)
+        if path.is_dir():
+            out.append(path)
+    return out
+
+
+def primary_site_packages() -> pathlib.Path:
+    """优先用户级 site-packages（不需要管理员）。"""
+    user = pathlib.Path(site.getusersitepackages())
+    user.mkdir(parents=True, exist_ok=True)
+    return user
+
+
+def installed_paths() -> list[pathlib.Path]:
+    return [d / PTH_NAME for d in site_packages_dirs() if (d / PTH_NAME).exists()]
+
+
+def cmd_install() -> int:
+    target = primary_site_packages() / PTH_NAME
+    if not SRC_DIR.is_dir():
+        print(f"找不到源码目录：{SRC_DIR}", file=sys.stderr)
+        return 2
+    target.write_text(str(SRC_DIR) + "\n", encoding="utf-8")
+    print(f"已写入：{target}")
+    print(f"内容：{SRC_DIR}")
+    print()
+    print("验证（在任意目录执行）：")
+    print("  python -m proxycore rules --config <仓库>/samples/profiles/dev.yaml")
+    print("  python -m proxycore --version")
+    print()
+    print("注意：把仓库挪走/改名后要重新执行 install。")
+    return 0
+
+
+def cmd_uninstall() -> int:
+    removed = 0
+    for path in installed_paths():
+        path.unlink()
+        print(f"已删除：{path}")
+        removed += 1
+    if not removed:
+        print("没有找到已注册的 .pth（无需卸载）")
+    return 0
+
+
+def cmd_status() -> int:
+    print(f"仓库根：{REPO_ROOT}")
+    print(f"源码目录：{SRC_DIR}  ({'存在' if SRC_DIR.is_dir() else '不存在！'})")
+    print()
+    print("site-packages 搜索路径：")
+    for directory in site_packages_dirs():
+        marker = "  <-- 本工具使用" if directory == primary_site_packages() else ""
+        pth = directory / PTH_NAME
+        state = "已注册" if pth.exists() else "未注册"
+        print(f"  {directory}  [{state}]{marker}")
+    print()
+    try:
+        import proxycore
+
+        print(f"import proxycore: OK（{proxycore.__file__}）")
+    except ImportError as exc:
+        print(f"import proxycore: 失败（{exc}）")
+        print("→ 执行 `python -m proxycore install-path` 或设置 PYTHONPATH 指向 src")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="procproxy install-path", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("action", choices=["install", "uninstall", "status"], nargs="?", default="status")
+    args = ap.parse_args(argv)
+    if args.action == "install":
+        return cmd_install()
+    if args.action == "uninstall":
+        return cmd_uninstall()
+    return cmd_status()
+
+if __name__ == "__main__":  # pragma: no cover - 也支持以模块方式直接运行
+    raise SystemExit(main())

proxycore/probe.py

@@ -0,0 +1,168 @@
+"""确认一个本地端口是不是"能当上游的代理监听口"（例如 Yakit MITM）。
+
+为什么需要它：
+    ProcProxy 的上游是代理协议客户端（SOCKS5 / HTTP CONNECT），不是裸端口转发。
+    所以对端必须真的在"代理监听"模式；如果它只是个普通 HTTP 服务器或别的什么，
+    配置看起来没错但每个连接都会握手失败。与其在几百行日志里找原因，不如先探一下。
+
+它做三件事：
+    1. 谁在监听这个端口（用 GetExtendedTcpTable 反查 PID + 进程名）
+    2. 用 HTTP 代理协议说一句 CONNECT，看对端是不是按代理语义应答
+    3. 打印可以直接复制的 ProcProxy 启动命令
+
+用法：
+    python procproxy.py probe-upstream                     # 默认探 127.0.0.1:8899
+    python procproxy.py probe-upstream --port 8083          # Yakit MITM 的常见默认端口
+    python procproxy.py probe-upstream --test-host www.baidu.com --test-port 443
+
+退出码：0 = 对端能以 HTTP 代理语义应答；1 = 不是代理监听口 / 连不上。
+"""
+
+from __future__ import annotations
+
+import argparse
+import socket
+
+from proxycore.proc import IS_WINDOWS, get_proc_info
+
+
+def describe_listener(host: str, port: int) -> str:
+    """反查监听该端口的进程（Windows 用 TCP 表；其他平台跳过）。"""
+    if not IS_WINDOWS:
+        return "（非 Windows，跳过进程反查）"
+    try:
+        from proxycore.backend.windivert.pidmap import PortPidTable
+    except Exception as exc:  # noqa: BLE001
+        return f"（反查不可用：{exc}）"
+
+    table = PortPidTable()
+    table.refresh(force=True)
+    if table.last_error:
+        return f"（反查失败：{table.last_error}；管理员权限下更准）"
+
+    hits = []
+    for row in table.all_rows():
+        if row.local_port != port:
+            continue
+        # state 2 = LISTEN
+        if row.state != 2:
+            continue
+        try:
+            info = get_proc_info(row.pid)
+            name = info.name or "?"
+            path = info.path or ""
+        except Exception:  # noqa: BLE001
+            name, path = "?", ""
+        hits.append(f"pid={row.pid} name={name} path={path}")
+    if not hits:
+        return "（没找到 LISTEN 记录：可能没在监听，或需要管理员才能看到别人的套接字）"
+    return "；".join(hits)
+
+
+def probe_http_proxy(host: str, port: int, test_host: str, test_port: int, timeout: float) -> tuple[bool, str]:
+    """说一句 HTTP 代理的 CONNECT，看应答是不是代理语义。"""
+    target = f"{test_host}:{test_port}"
+    request = (
+        f"CONNECT {target} HTTP/1.1\r\n"
+        f"Host: {target}\r\n"
+        "Proxy-Connection: keep-alive\r\n"
+        "\r\n"
+    ).encode()
+    try:
+        with socket.create_connection((host, port), timeout=timeout) as sock:
+            sock.sendall(request)
+            sock.settimeout(timeout)
+            data = sock.recv(1024)
+    except OSError as exc:
+        return False, f"连不上 / 读不到应答：{exc}"
+
+    if not data:
+        return False, "对端直接关连接（不是代理监听口的典型表现）"
+
+    first = data.split(b"\r\n", 1)[0].decode("latin-1", "replace")
+    status = first.split(" ", 2)
+    code = int(status[1]) if len(status) > 1 and status[1].isdigit() else 0
+    detail = f"对端应答：{first!r}"
+    if code == 200:
+        return True, detail + "  → 是代理监听口（CONNECT 已建立隧道）"
+    if code == 407:
+        return True, detail + "  → 是代理监听口，但要求代理认证（在配置里补 auth/user/password_ref）"
+    if code in {502, 503, 504}:
+        return True, detail + "  → 是代理监听口（它自己没能连上目标，但代理语义正确）"
+    if code in {400, 405, 501} or first.upper().startswith("HTTP/1."):
+        return False, detail + "  → 有 HTTP 服务，但不是代理语义（多半是普通 Web 服务/管理端口）"
+    return False, detail + "  → 不是 HTTP 代理"
+
+
+def probe_socks5(host: str, port: int, timeout: float) -> tuple[bool, str]:
+    """顺手试一下 SOCKS5 无认证握手（有些工具默认起的是 socks5 而不是 http）。"""
+    try:
+        with socket.create_connection((host, port), timeout=timeout) as sock:
+            sock.sendall(b"\x05\x01\x00")
+            sock.settimeout(timeout)
+            data = sock.recv(2)
+    except OSError as exc:
+        return False, f"socks5 探测失败：{exc}"
+    if len(data) == 2 and data[0] == 0x05:
+        methods = {0x00: "无需认证", 0x02: "需要用户名口令"}.get(data[1], f"方法 0x{data[1]:02x}")
+        return True, f"对端像 SOCKS5 代理（协商结果：{methods}）"
+    return False, f"不是 SOCKS5（应答 {data!r}）"
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="procproxy probe-upstream", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--port", type=int, default=8899, help="要探测的本地端口（Yakit MITM 常见 8083）")
+    ap.add_argument("--test-host", default="www.baidu.com", help="CONNECT 的目标（只用于握手，不下载内容）")
+    ap.add_argument("--test-port", type=int, default=80)
+    ap.add_argument("--timeout", type=float, default=5.0)
+    args = ap.parse_args(argv)
+
+    print()
+    print("=" * 72)
+    print(f" 端口自检：{args.host}:{args.port} 能不能当 ProcProxy 的上游")
+    print("=" * 72)
+
+    print()
+    print("[1/3] 谁在监听？")
+    print(f"  {describe_listener(args.host, args.port)}")
+
+    print()
+    print("[2/3] 它是 HTTP 代理吗？（ProcProxy 的 kind: http）")
+    http_ok, http_detail = probe_http_proxy(
+        args.host, args.port, args.test_host, args.test_port, args.timeout
+    )
+    print(f"  [{'OK  ' if http_ok else 'FAIL'}] {http_detail}")
+
+    socks_ok, socks_detail = probe_socks5(args.host, args.port, args.timeout)
+    print(f"  [{'OK  ' if socks_ok else '--  '}] {socks_detail}（仅参考：socks5 上游用 kind: socks5）")
+
+    print()
+    print("[3/3] 结论与下一步")
+    if http_ok:
+        kind = "http"
+        print(f"  ✅ 这个端口可以当上游，配置里写 kind: {kind}")
+        print()
+        print("  1) 复制一份带你自己端口/进程名的 profile：")
+        print("       samples\\profiles\\yakit.yaml   ← 改 upstreams[0].port 与 rules[0].targets")
+        print("  2) 以管理员身份启动（真后端需要管理员）：")
+        print("       python -m proxycore run --config samples\\profiles\\yakit.yaml --backend windivert --log-level DEBUG")
+        print("  3) 让被观察的进程发一次请求，然后看两边：")
+        print("       Yakit 的 MITM 历史里应出现该请求；")
+        print("       控制台里应出现 session_end 且 upstream=yakit")
+    elif socks_ok:
+        print("  ⚠️ 它不是 HTTP 代理，但像 SOCKS5 代理 —— 上游改 kind: socks5")
+    else:
+        print("  ❌ 这个端口不是一个代理监听口。常见原因：")
+        print("     * 端口填错了（Yakit MITM 默认监听 8083；确认 GUI 里'劫持'页面显示的端口）")
+        print("     * Yakit 的 MITM 没启动（GUI 里需要点开劫持/开启监听）")
+        print("     * 你看的是另一个服务：8899 上跑的可能不是 Yakit 的代理监听")
+
+    print()
+    print("  说明：ProcProxy 不自己解 TLS，也不做 MITM —— 它把原始字节交给上游。")
+    print("        想看 HTTPS 明文，靠的是 Yakit 的 MITM（别忘了让目标程序信任 Yakit 的 CA）。")
+    print()
+    return 0 if (http_ok or socks_ok) else 1
+
+if __name__ == "__main__":  # pragma: no cover - 也支持以模块方式直接运行
+    raise SystemExit(main())