procproxy 0.1.0__py3-none-any.whl

proxycore/cli.py

@@ -0,0 +1,605 @@
+"""ProcProxy CLI：`run | status | rules | sessions | config | doctor | stop`。
+
+职责边界：CLI 只做配置与展示，数据面永远在服务里。
+`--backend null` 允许在前台直接跑数据面，便于联调。
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import importlib
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from proxycore import __version__
+from proxycore.config import Config, ConfigError, ConfigManager, port_in_use
+from proxycore.log import LEVELS, build_logger, enable_trace_payload, get_logger, redact
+from proxycore.rules import GuardSet, stats_snapshot
+from proxycore.types import ConnRequest, Endpoint, ProcInfo, Proto
+
+DEFAULT_CONFIG = "samples/profiles/dev.yaml"
+RUNTIME_DIR_ENV = "PROCPROXY_RUNTIME_DIR"
+
+
+# ============================================================ 运行时目录 ====
+def runtime_dir() -> Path:
+    """配置/状态/日志目录（Windows 用 `%ProgramData%\\ProcProxy`，其余用 `~/.procproxy`）。"""
+    override = os.environ.get(RUNTIME_DIR_ENV)
+    if override:
+        return Path(override)
+    if os.name == "nt":
+        base = os.environ.get("PROGRAMDATA", r"C:\ProgramData")
+        return Path(base) / "ProcProxy"
+    return Path.home() / ".procproxy"
+
+
+def state_path() -> Path:
+    return runtime_dir() / "state.json"
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+# ============================================================ 输出辅助 ====
+def _row_text(cells: list[str], widths: list[int], align: list[str]) -> str:
+    parts: list[str] = []
+    for index, cell in enumerate(cells):
+        text = str(cell)
+        pad = max(0, widths[index] - _display_width(text))
+        parts.append(text + " " * pad if align[index] == "<" else " " * pad + text)
+    return "  ".join(parts)
+
+
+def _print_table(headers: list[str], rows: list[list[str]], align: list[str] | None = None) -> None:
+    if not rows:
+        print("(空)")
+        return
+    widths = [len(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            # 中文按 2 列宽计算，保证表格对齐
+            widths[i] = max(widths[i], _display_width(cell))
+    align = align or ["<"] * len(headers)
+    out = [_row_text(headers, widths, align)]
+    out.append("  ".join("-" * w for w in widths))
+    out.extend(_row_text(row, widths, align) for row in rows)
+    print("\n".join(out))
+
+
+def _display_width(text: str) -> int:
+    return sum(2 if ord(ch) > 0x2E80 else 1 for ch in str(text))
+
+
+def repo_root() -> Path | None:
+    """若当前包来自源码树（`<repo>/src/proxycore/`），返回 `<repo>`；否则 None（已安装场景）。"""
+    package_dir = Path(__file__).resolve().parent
+    candidate = package_dir.parent.parent
+    if (candidate / "samples").is_dir() and (candidate / "pyproject.toml").is_file():
+        return candidate
+    return None
+
+
+def resolve_config_path(raw: str) -> Path:
+    """解析配置路径。相对路径找不到时，回退到仓库根下的同名路径。
+
+    这样 `cd src` 之后仍然可以 `--config samples/profiles/dev.yaml`（CLI 不强制
+    "必须在仓库根执行"）。若两种情况都不存在，返回原路径，让报错信息保持直白。
+    """
+    path = Path(raw)
+    if path.is_absolute() or path.exists():
+        return path
+    root = repo_root()
+    if root is not None:
+        candidate = root / path
+        if candidate.exists():
+            return candidate
+    return path
+
+
+def _load_config(args: argparse.Namespace) -> Config:
+    raw = getattr(args, "config", DEFAULT_CONFIG) or DEFAULT_CONFIG
+    path = resolve_config_path(raw)
+    if not path.exists():
+        hint = ""
+        root = repo_root()
+        if root is not None:
+            hint = f"\n提示：仓库根是 {root}，可用 --config {root / 'samples' / 'profiles' / 'dev.yaml'}"
+        raise SystemExit(f"配置文件不存在: {path}{hint}")
+    try:
+        return Config.load(path, check_sink=bool(getattr(args, "check_sink", False)))
+    except ConfigError as exc:
+        raise SystemExit(f"配置无效：{exc.code} — {exc.message}") from exc
+
+
+def _print_warnings(config: Config, verbose: bool = False) -> None:
+    if not config.warnings:
+        return
+    shown = config.warnings if verbose else config.warnings[:5]
+    for warning in shown:
+        print(f"[WARN] {warning}", file=sys.stderr)
+    if not verbose and len(config.warnings) > len(shown):
+        print(f"[WARN] ... 另有 {len(config.warnings) - len(shown)} 条未知字段警告（--verbose 查看）", file=sys.stderr)
+
+
+# ============================================================ 子命令 ====
+def cmd_rules(args: argparse.Namespace) -> int:
+    config = _load_config(args)
+    _print_warnings(config, args.verbose)
+    profile = config.profile
+
+    if args.trace:
+        return _cmd_rules_trace(config, args)
+
+    print(f"Profile: {profile.name}   default_action={profile.default_action.value}   "
+          f"sticky_per_pid={profile.sticky_per_pid}   dns_mode={profile.dns_mode}")
+    print(f"Backend: {config.service.backend}   Sink: {config.service.sink.host}:{config.service.sink.port}   "
+          f"on_unknown_pid={config.service.on_unknown_pid}   "
+          f"on_decide_error={config.service.on_decide_error}")
+    print()
+
+    rows: list[list[str]] = []
+    for index, rule in enumerate(profile.rules, start=1):
+        up = rule.upstream or "-"
+        rows.append(
+            [
+                str(index),
+                rule.id,
+                "on" if rule.enabled else "off",
+                rule.action.value,
+                up,
+                rule.targets,
+                rule.dst_ip,
+                rule.dst_port,
+                rule.proto,
+                rule.dst_name,
+                "yes" if rule.keep_private_proxied else "",
+            ]
+        )
+    _print_table(
+        ["#", "id", "en", "action", "upstream", "targets", "dst_ip", "dst_port", "proto", "dst_name", "priv"],
+        rows,
+    )
+
+    print()
+    ups = profile.upstreams
+    if ups:
+        up_rows = [
+            [u.alias, u.kind, f"{u.host}:{u.port}", u.user or "-", u.auth, "yes" if u.udp else "no",
+             ",".join(u.chain) or "-"]
+            for u in ups.values()
+        ]
+        _print_table(["alias", "kind", "endpoint", "user", "auth", "udp", "chain"], up_rows)
+    else:
+        print("(未配置上游 —— 任何 action=proxy 的规则都无法工作)")
+    return 0
+
+
+def _cmd_rules_trace(config: Config, args: argparse.Namespace) -> int:
+    from proxycore.rules import explain
+
+    conn = ConnRequest(
+        proc=ProcInfo(pid=args.pid, name=args.proc, path=args.proc_path),
+        proto=Proto.UDP if args.proto == "udp" else Proto.TCP,
+        src=Endpoint("127.0.0.1", 50000),
+        dst=Endpoint(args.dst, args.port, is_v6=":" in args.dst),
+    )
+    guards = GuardSet(self_pids={os.getpid()}, upstream_endpoints=config.profile.upstream_endpoints())
+    print(f"# trace: pid={args.pid} proc={args.proc} -> {args.dst}:{args.port}/{args.proto}")
+    for step in explain(conn, config.profile, guards):
+        print(json.dumps(redact(step), ensure_ascii=False))
+    print()
+    print("(trace 仅用于排错，热路径不产生这些输出)")
+    return 0
+
+
+def cmd_config(args: argparse.Namespace) -> int:
+    config = _load_config(args)
+    _print_warnings(config, args.verbose)
+    if args.json:
+        print(json.dumps(config.to_dict(), ensure_ascii=False, indent=2))
+    else:
+        print(config.dump_yaml())
+    return 0
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    state = _read_json(state_path())
+    config: Config | None = None
+    try:
+        config = _load_config(args)
+    except SystemExit:
+        config = None
+
+    if not state:
+        print(f"运行时状态：未找到 {state_path()}（服务可能未启动或未使用默认运行时目录）")
+    else:
+        _print_table(
+            ["field", "value"],
+            [[k, _fmt(v)] for k, v in sorted(state.items()) if not isinstance(v, (dict, list))],
+        )
+
+    if config is not None:
+        print()
+        print("生效配置摘要：")
+        snapshot = stats_snapshot(config.profile)
+        for key, value in snapshot.items():
+            print(f"  {key} = {_fmt(value)}")
+    if args.follow:
+        print("\n--follow：每 2s 刷新（Ctrl+C 退出）")
+        try:
+            while True:
+                time.sleep(2)
+                state = _read_json(state_path())
+                ts = time.strftime("%H:%M:%S")
+                print(f"[{ts}] captured={state.get('captured', '?')} redirected={state.get('redirected', '?')} "
+                      f"sessions={state.get('active_sessions', '?')} unknown_pid={state.get('unknown_pid', '?')}")
+        except KeyboardInterrupt:
+            return 0
+    return 0
+
+
+def _fmt(value: Any) -> str:
+    if isinstance(value, list):
+        return ", ".join(str(v) for v in value) or "-"
+    if isinstance(value, dict):
+        return json.dumps(redact(value), ensure_ascii=False)
+    return str(value)
+
+
+def cmd_sessions(args: argparse.Namespace) -> int:
+    """从 JSONL 日志里读会话（`--follow` 实时跟随）。"""
+    config: Config | None = None
+    try:
+        config = _load_config(args)
+    except SystemExit:
+        config = None
+    log_path = args.log or (config.service.log_jsonl if config else "") or str(runtime_dir() / "sessions.jsonl")
+    path = Path(log_path)
+    if not path.exists():
+        print(f"未找到会话日志: {path}")
+        print("提示：用 `--log-jsonl <path>` 启动服务后才会产生会话日志。")
+        return 0
+
+    if args.follow:
+        return _follow_jsonl(path, args)
+    return _print_sessions_from_file(path, args)
+
+
+def _print_sessions_from_file(path: Path, args: argparse.Namespace) -> int:
+    rows: list[list[str]] = []
+    for payload in _iter_jsonl(path):
+        if payload.get("event") != "session_end":
+            continue
+        rows.append(
+            [
+                str(payload.get("session_id", "")),
+                str(payload.get("pid", "")),
+                str(payload.get("proc", "")),
+                str(payload.get("proto", "")),
+                str(payload.get("dst", "")),
+                str(payload.get("upstream", "") or "-"),
+                str(payload.get("rule", "") or "-"),
+                str(payload.get("state", "")),
+                f"{payload.get('bytes_up', 0)}/{payload.get('bytes_down', 0)}",
+                str(payload.get("reason", "")),
+            ]
+        )
+    if args.limit:
+        rows = rows[-args.limit :]
+    _print_table(
+        ["sid", "pid", "proc", "proto", "dst", "upstream", "rule", "state", "up/down", "reason"], rows
+    )
+    return 0
+
+
+def _follow_jsonl(path: Path, args: argparse.Namespace) -> int:
+    print(f"following {path}（Ctrl+C 退出）")
+    with path.open("r", encoding="utf-8") as handle:
+        handle.seek(0, os.SEEK_END)
+        try:
+            while True:
+                line = handle.readline()
+                if not line:
+                    time.sleep(0.2)
+                    continue
+                try:
+                    payload = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if args.json:
+                    print(json.dumps(payload, ensure_ascii=False))
+                    continue
+                if payload.get("event") == "session_end":
+                    print(
+                        f"{payload.get('ts', '')} pid={payload.get('pid')} {payload.get('proc')} "
+                        f"{payload.get('proto')} -> {payload.get('dst')} via {payload.get('upstream') or '-'} "
+                        f"[{payload.get('rule') or '-'}] {payload.get('state')} "
+                        f"up={payload.get('bytes_up')} down={payload.get('bytes_down')} "
+                        f"{payload.get('reason')}"
+                    )
+                else:
+                    print(json.dumps(payload, ensure_ascii=False))
+        except KeyboardInterrupt:
+            return 0
+
+
+def _iter_jsonl(path: Path):
+    try:
+        with path.open("r", encoding="utf-8") as handle:
+            for line in handle:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    payload = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if isinstance(payload, dict):
+                    yield payload
+    except OSError as exc:
+        print(f"读取日志失败: {exc}", file=sys.stderr)
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    """数据面入口。`--backend null` 只联调不抓包；默认用配置里的后端。"""
+    config = _load_config(args)
+    _print_warnings(config)
+    if args.backend:
+        config.service.backend = args.backend
+    if args.log_level:
+        config.service.log_level = args.log_level
+    if args.log_jsonl:
+        config.service.log_jsonl = args.log_jsonl
+
+    build_logger(
+        "proxycore",
+        level=config.service.log_level,
+        jsonl_path=config.service.log_jsonl or str(runtime_dir() / "sessions.jsonl"),
+        console=True,
+    )
+    if config.service.enable_trace_payload:
+        enable_trace_payload(True)
+    # 子日志器（proxycore.runtime / proxycore.config / ...）共用这一份输出配置
+    for child in ("runtime", "config", "sink", "upstream", "dns", "backend"):
+        get_logger(f"proxycore.{child}")
+
+    from proxycore.backend import BackendUnavailable, make_backend
+    from proxycore.runtime import Runtime
+
+    manager = ConfigManager(config)
+    # `make_backend()` 只是构造，真正打开句柄/加载驱动发生在 `backend.start()`
+    # （由 `runtime.start()` 调用）。所以两处都要包在同一个处理里
+    # route A 的主要失败模式（非管理员）正是在 start() 里才暴露。
+    try:
+        backend = make_backend(config.service.backend, config=config)
+        runtime = Runtime(manager=manager, backend=backend)
+        runtime.start(sink_test_target=args.sink_test_target, upstream_alias=args.upstream)
+    except BackendUnavailable as exc:
+        # 绝不静默直连，后端不可用就明确失败
+        print(f"[E_BACKEND_UNAVAILABLE] {exc}", file=sys.stderr)
+        print(
+            "提示：WinDivert 需要管理员权限（右键 → 以管理员身份运行）。",
+            file=sys.stderr,
+        )
+        print("      也可以显式用 backend=null —— 但它只做联调，不代理任何流量。", file=sys.stderr)
+        return 2
+
+    try:
+        runtime.serve_forever(reload_watch=not args.no_watch)
+    except KeyboardInterrupt:
+        print("\n收到 Ctrl+C，正在停止…")
+    finally:
+        runtime.stop()
+    return 0
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    config = _load_config(args)
+    _print_warnings(config)
+    backend = args.backend or config.service.backend
+    checks: list[tuple[str, str, str]] = []
+
+    checks.append(("python", sys.version.split()[0], "ok" if sys.version_info >= (3, 10) else "需要 3.10+"))
+    checks.append(("platform", sys.platform, "ok"))
+    checks.append(("admin", "yes" if _is_admin() else "no",
+                   "ok" if _is_admin() else "拦截/驱动/服务需要管理员权限"))
+    checks.append(("config", config.path or DEFAULT_CONFIG, "ok"))
+    checks.append(("backend", backend, _backend_probe(backend)))
+    checks.append(("sink_port", f"{config.service.sink.host}:{config.service.sink.port}",
+                   "free" if not _port_busy(config.service.sink.port, config.service.sink.host) else "occupied"))
+    checks.append(("upstreams", str(len(config.profile.upstreams)), "ok"))
+    checks.append(("rules", str(len(config.profile.rules)), "ok"))
+
+    _print_table(["check", "value", "detail"], [[a, b, c] for a, b, c in checks])
+    if backend == "null":
+        print("\n注意：backend=null 只做本地联调，不会代理任何流量。")
+    return 0
+
+
+def _is_admin() -> bool:
+    if os.name != "nt":
+        return os.geteuid() == 0 if hasattr(os, "geteuid") else False
+    import ctypes
+
+    try:
+        return bool(ctypes.windll.shell32.IsUserAnAdmin())
+    except Exception:  # noqa: BLE001 - 探测失败按非管理员处理
+        return False
+
+
+def _port_busy(port: int, host: str) -> bool:
+    # 统一用 config.port_in_use：Windows 上必须 SO_EXCLUSIVEADDRUSE，
+    # SO_REUSEADDR 对同样设置过它的监听者会把"已占用"误判成空闲。
+    return port_in_use(port, host)
+
+
+def _backend_probe(name: str) -> str:
+    if name == "null":
+        return "available (联调用)"
+    if name == "windivert":
+        # 复用后端的探测实现，不在这里再写一份等价逻辑
+        from .backend.windivert import probe_availability
+
+        _ok, detail = probe_availability()
+        return detail
+    return f"未知后端 {name}"
+
+
+def cmd_stop(args: argparse.Namespace) -> int:
+    """紧急停止：优先恢复业务。"""
+    control = runtime_dir() / "control.json"
+    payload = {"action": "panic" if args.panic else "stop", "ts": time.time()}
+    _write_json(control, payload)
+    print(f"已写入控制指令 {payload['action']} → {control}")
+    print("提示：`stop` 靠控制文件通知正在跑的数据面自行退出（前台模式直接 Ctrl+C）。")
+    print("      数据面进程退出后 WinDivert 句柄自动释放，不会留下「流量被拦着」的状态。")
+    return 0
+
+
+# ============================================================ 参数解析 ====
+
+# ====================================================== 外包子命令（透传）====
+#: 这几个子命令的实现在各自模块里（自带完整 argparse）。在 argparse 之前拦下，
+#: 把剩下的参数原样交给它们：这样参数定义只写一份；`<cmd> --help` 显示的是
+#: 那个模块自己的帮助，不会被外层解析器截断。
+_PASSTHROUGH: dict[str, tuple[str, str]] = {
+    "forward": ("forward", "把指定进程的 TCP 流量转发给上游代理/抓包工具"),
+    "can-proxy": ("canproxy", "一句话回答：现在能不能转发进程流量"),
+    "check-route": ("checkroute", "核对某进程的连接走了哪条路"),
+    "probe-upstream": ("probe", "探测某个端口是不是可用的上游代理监听口"),
+    "install-path": ("pathsetup", "让 `python -m proxycore` 在任何目录可用（写 .pth，可撤销）"),
+}
+
+
+def _passthrough_help() -> str:
+    width = max(len(k) for k in _PASSTHROUGH)
+    head = "另外这些子命令（各自带完整参数，可用 `<命令> --help` 查看）："
+    return head + chr(10) + chr(10).join(f"    {k:<{width}}  {v[1]}" for k, v in _PASSTHROUGH.items())
+
+
+def _dispatch_passthrough(argv: list[str]) -> int | None:
+    """首参数是外包子命令就交给对应模块；否则返回 None（走 argparse）。
+
+    模块名来自 `_PASSTHROUGH` 的字符串，所以 IDE 里点不进去 ——
+    例如 `forward` 的实现就在 `proxycore/forward.py`。
+    """
+    if not argv:
+        return None
+    entry = _PASSTHROUGH.get(argv[0])
+    if entry is None:
+        return None
+    module = importlib.import_module(f"{__package__}.{entry[0]}")
+    return int(module.main(list(argv[1:])))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="procproxy",
+        description="ProcProxy —— 进程级代理（按进程决定哪条连接走哪个上游）",
+        epilog=_passthrough_help(),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=f"ProcProxy {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    def add_common(p: argparse.ArgumentParser) -> None:
+        p.add_argument("--config", default=DEFAULT_CONFIG, help=f"配置文件路径（默认 {DEFAULT_CONFIG}）")
+        p.add_argument("--verbose", action="store_true", help="打印所有配置警告")
+
+    p_rules = sub.add_parser("rules", help="打印规则表（--trace 打印命中链路）")
+    add_common(p_rules)
+    p_rules.add_argument("--trace", action="store_true", help="对一条模拟连接打印逐条规则判定链路")
+    p_rules.add_argument("--pid", type=int, default=os.getpid())
+    p_rules.add_argument("--proc", default="curl.exe")
+    p_rules.add_argument("--proc-path", default="")
+    p_rules.add_argument("--dst", default="1.1.1.1")
+    p_rules.add_argument("--port", type=int, default=443)
+    p_rules.add_argument("--proto", choices=["tcp", "udp"], default="tcp")
+    p_rules.set_defaults(func=cmd_rules)
+
+    p_config = sub.add_parser("config", help="打印生效配置（--json 输出原始结构）")
+    add_common(p_config)
+    p_config.add_argument("--json", action="store_true")
+    p_config.set_defaults(func=cmd_config)
+
+    p_status = sub.add_parser("status", help="打印运行时状态与生效配置摘要")
+    add_common(p_status)
+    p_status.add_argument("--follow", action="store_true", help="每 2s 刷新")
+    p_status.set_defaults(func=cmd_status)
+
+    p_sessions = sub.add_parser("sessions", help="列出/跟随会话（contract 第 7 节的 JSONL）")
+    add_common(p_sessions)
+    p_sessions.add_argument("--log", default="", help="JSONL 日志路径")
+    p_sessions.add_argument("--follow", action="store_true")
+    p_sessions.add_argument("--json", action="store_true")
+    p_sessions.add_argument("--limit", type=int, default=50)
+    p_sessions.set_defaults(func=cmd_sessions)
+
+    p_run = sub.add_parser("run", help="前台运行数据面（--backend null 只联调不抓包）")
+    add_common(p_run)
+    p_run.add_argument("--backend", choices=["null", "windivert"], default="")
+    p_run.add_argument("--log-level", choices=sorted(LEVELS), default="")
+    p_run.add_argument("--log-jsonl", default="")
+    p_run.add_argument("--sink-test-target", default="", help="测试模式：sink 把所有连接转发到该 host:port")
+    p_run.add_argument("--upstream", default="", help="测试模式：强制使用该上游别名")
+    p_run.add_argument("--no-watch", action="store_true", help="不监视配置热重载")
+    p_run.add_argument("--check-sink", action="store_true")
+    p_run.set_defaults(func=cmd_run)
+
+    p_doctor = sub.add_parser("doctor", help="环境自检（后端/端口/权限）")
+    add_common(p_doctor)
+    p_doctor.add_argument("--backend", choices=["null", "windivert"], default="")
+    p_doctor.set_defaults(func=cmd_doctor)
+
+    p_stop = sub.add_parser("stop", help="停止服务（--panic 为紧急全量放行）")
+    add_common(p_stop)
+    p_stop.add_argument("--panic", action="store_true", help="紧急停止：尽快停掉数据面并退出")
+    p_stop.set_defaults(func=cmd_stop)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    _force_utf8_console()
+    argv = list(sys.argv[1:] if argv is None else argv)
+    handled = _dispatch_passthrough(argv)
+    if handled is not None:
+        return handled
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    func = getattr(args, "func", None)
+    if func is None:  # pragma: no cover - argparse 已保证
+        parser.print_help()
+        return 1
+    return int(func(args))
+
+
+def _force_utf8_console() -> None:
+    """Windows 控制台默认不是 UTF-8，中文输出会乱码；这里显式纠正。"""
+    for stream_name in ("stdout", "stderr"):
+        stream = getattr(sys, stream_name, None)
+        reconfigure = getattr(stream, "reconfigure", None)
+        if callable(reconfigure):
+            with contextlib.suppress(ValueError, OSError):
+                reconfigure(encoding="utf-8", errors="replace")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())