sdev 0.5.2__tar.gz → 0.5.4__tar.gz

{sdev-0.5.2/sdev.egg-info → sdev-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdev
-Version: 0.5.2
+Version: 0.5.4
 Summary: 串口控制器工具包
 Home-page: https://github.com/klrc/sdev
 Author: klrc
@@ -27,6 +27,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyserial>=3.5
 Requires-Dist: loguru>=0.6.0
+Requires-Dist: zeroconf>=0.39.0
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file

{sdev-0.5.2 → sdev-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdev"
-version = "0.5.2"
+version = "0.5.4"
 description = "串口控制器工具包"
 readme = "README.md"
 license = {text = "MIT"}
@@ -30,6 +30,7 @@ requires-python = ">=3.7"
 dependencies = [
     "pyserial>=3.5",
     "loguru>=0.6.0",
+    "zeroconf>=0.39.0",
 ]
 
 [project.scripts]

{sdev-0.5.2 → sdev-0.5.4}/sdev/__init__.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from .models import Demoboard
 
-__version__ = "0.5.2"
+__version__ = "0.5.4"
 __author__ = "klrc"
 __email__ = "1440698245@qq.com"
 

{sdev-0.5.2 → sdev-0.5.4}/sdev/cli/cli_wrapper.py

@@ -148,9 +148,10 @@ def _get_default_baudrate() -> int:
 
 def _run_with_spinner(label: str, fn, *args, **kwargs):
     """
-    在控制台上为一个阻塞操作显示简易旋转动画。
-    label: 文本前缀，如 "[remote] probing 192.168.1.10:7000"
-    fn:    实际执行的函数，返回结果会被原样返回。
+    在控制台上为一个阻塞操作显示简易旋转动画：
+    - 进行中：⏳ + label + 旋转字符（单行反复覆盖）；
+    - 完成时：输出一行 ✔ + label。
+    fn: 实际执行的函数，返回结果会被原样返回。
     """
 
     done = False
@@ -159,12 +160,9 @@ def _run_with_spinner(label: str, fn, *args, **kwargs):
         frames = itertools.cycle("|/-\\")
         while not done:
             frame = next(frames)
-            sys.stdout.write(f"\r{_CYAN}{label}{_RESET} {frame}")
+            sys.stdout.write(f"\r{_CYAN}⏳ {label}{_RESET} {frame}")
             sys.stdout.flush()
             time.sleep(0.1)
-        # 擦掉这一行
-        sys.stdout.write("\r" + " " * (len(label) + 4) + "\r")
-        sys.stdout.flush()
 
     t = threading.Thread(target=spinner_worker, daemon=True)
     t.start()
@@ -173,6 +171,9 @@ def _run_with_spinner(label: str, fn, *args, **kwargs):
     finally:
         done = True  # type: ignore[assignment]
         t.join()
+        # 以对勾形式输出完成行
+        sys.stdout.write(f"\r{_GREEN}✔ {label}{_RESET}\n")
+        sys.stdout.flush()
     return result
 
 
@@ -246,11 +247,11 @@ def _scan_targets_with_spinner(targets: list[dict[str, Any]], timeout: float) ->
     kinds = {t.get("kind") for t in targets}
     n = len(targets)
     if kinds == {"local"}:
-        label = f"[local] scanning {n} port(s)"
+        label = f"[LOCAL] scanning {n} port(s)"
     elif kinds == {"remote"}:
-        label = f"[remote] checking {n} board(s)"
+        label = f"[REMOTE] checking {n} board(s)"
     else:
-        label = f"[scan] checking {n} target(s)"
+        label = f"[SCAN] checking {n} target(s)"
 
     return _run_with_spinner(label, _scan_targets, targets, timeout)
 
@@ -304,11 +305,32 @@ def cmd_server_status(args: argparse.Namespace) -> int:
 def _resolve_demoboard_target_for_shell() -> Tuple[Optional[str], str, int]:
     """
     解析 shell 使用的 demoboard：
-    - 优先使用本地激活记录；
+    - 优先使用「远程激活」记录（host:/dev/ttyUSBx）；
+    - 其次使用「本地激活」记录（/dev/ttyUSBx）；
     - 否则回退到默认本地端口 + 波特率。
     返回 (host, port, baudrate)，其中 host 为 None 表示本地。
     """
-    # 1. 本地激活优先
+    # 1. 远程激活优先：从 discovery 的 activation 记录中选择 active 的一条。
+    try:
+        remote_records = discovery.load_activations()
+    except Exception:
+        remote_records = []
+    for r in remote_records:
+        if not isinstance(r, dict):
+            continue
+        if not r.get("active"):
+            continue
+        host = (r.get("host") or "").strip()
+        port = (r.get("port") or "").strip()
+        if not host or not port:
+            continue
+        try:
+            baud = int(r.get("baudrate") or _get_default_baudrate())
+        except (TypeError, ValueError):
+            baud = _get_default_baudrate()
+        return host, port, baud
+
+    # 2. 本地激活
     act = _load_local_activation()
     if act and act.get("active") and act.get("port"):
         port = str(act.get("port"))
@@ -318,7 +340,7 @@ def _resolve_demoboard_target_for_shell() -> Tuple[Optional[str], str, int]:
             baud = _get_default_baudrate()
         return None, port, baud
 
-    # 默认本地
+    # 3. 默认本地
     return None, _get_default_port(), _get_default_baudrate()
 
 
@@ -332,14 +354,12 @@ def cmd_shell(args: argparse.Namespace) -> int:
 
     with Demoboard(port, baudrate, host=host) as board:
         try:
-            lines = board.execute_command(args.command, flag=args.flag, timeout=args.timeout)
+            _ = board.execute_command(args.command, flag=args.flag, timeout=args.timeout)
         except TimeoutError as e:
             print(e, file=sys.stderr)
             return 1
-        for line in lines:
-            # 直接原样输出设备返回的行
-            sys.stdout.write(line)
-        sys.stdout.flush()
+        print()
+        # sys.stdout.flush()
     return 0
 
 
@@ -472,6 +492,9 @@ def cmd_demoboard_list(args: argparse.Namespace) -> int:
     if args.local:
         return cmd_list_local(args)
 
+    # 延迟导入以避免无关子命令时的额外依赖开销。
+    from ..base.serial_core import scan_serial_ports
+
     # 本地与远程发现阶段并行：
     # - 线程 A：本地串口非阻塞检查（不输出）；
     # - 线程 B：远程 host 发现 + boards 列表拉取（不输出）；
@@ -504,17 +527,47 @@ def cmd_demoboard_list(args: argparse.Namespace) -> int:
     def _local_worker() -> None:
         nonlocal local_results
         try:
+            if local_targets:
+                print(f"{_CYAN}[LOCAL]{_RESET} scanning {len(local_targets)} local port(s)...")
+            else:
+                print(f"{_YELLOW}[LOCAL]{_RESET} 未发现任何本机串口（ttyUSB*）。")
             local_results = _scan_targets(local_targets, args.timeout)
+            if local_results:
+                up_count = sum(1 for r in local_results if r.get("available"))
+                print(f"{_CYAN}[LOCAL]{_RESET} scan done: {up_count}/{len(local_results)} up")
         finally:
             local_done.set()
 
     def _remote_discovery_worker() -> None:
         nonlocal all_boards
         try:
-            hosts = discovery.get_remote_hosts(service_port=service_port, override=getattr(args, "remote_hosts", None))
+            print(f"{_CYAN}[REMOTE]{_RESET} discovering remote hosts...")
+            hosts = discovery.get_remote_hosts(
+                service_port=service_port,
+                override=getattr(args, "remote_hosts", None),
+            )
+            if not hosts:
+                print(
+                    f"{_YELLOW}[REMOTE]{_RESET} 未发现任何在线 host（请确认各机已执行 'sdev server start' 且在同一网络）"
+                )
             for host, port in hosts:
                 boards = discovery.fetch_boards_from_host(host, port, timeout=args.timeout)
                 all_boards.append(boards)
+                up_count = sum(1 for b in boards if b.get("available"))
+                total = len(boards)
+                if total == 0:
+                    state = "EMPTY"
+                    extra = "no boards reported"
+                    color = _YELLOW
+                elif up_count > 0:
+                    state = "UP"
+                    extra = f"{up_count}/{total} up"
+                    color = _GREEN
+                else:
+                    state = "DOWN"
+                    extra = f"0/{total} up"
+                    color = _RED
+                print(f"{color}[remote {state}]{_RESET} {host}:{port} - {extra}")
         finally:
             remote_done.set()
 
@@ -528,7 +581,9 @@ def cmd_demoboard_list(args: argparse.Namespace) -> int:
         local_done.wait()
         remote_done.wait()
 
-    _run_with_spinner("[INFO] scanning local & discovering remote", _wait_both)
+    # 这里不再使用单行 spinner，以免与本地/远程的进度日志挤在同一行。
+    print(f"{_CYAN}[INFO]{_RESET} scanning local & discovering remote ...")
+    _wait_both()
 
     t_local.join()
     t_remote.join()
@@ -644,7 +699,6 @@ def cmd_remote_activate(args: argparse.Namespace) -> int:
     reason = result.get("reason", "")
     status = "OK" if ok else "FAILED"
     color = _GREEN if ok else _RED
-    prefix = _format_shell_prefix(host, serial_port, baudrate)
     msg = f"probe {host}:{serial_port} baud={baudrate} -> {status}"
     if reason and not ok:
         msg += f" ({reason})"
@@ -682,8 +736,6 @@ def cmd_remote_activate(args: argparse.Namespace) -> int:
             }
         )
     discovery.save_activations(records)
-    if ok:
-        print(f"{_CYAN}{prefix}{_RESET}")
     return 0 if ok else 1
 
 
@@ -703,7 +755,6 @@ def cmd_activate_local(args: argparse.Namespace) -> int:
     reason = result.get("reason", "")
     status = "OK" if ok else "FAILED"
     color = _GREEN if ok else _RED
-    prefix = _format_shell_prefix(None, port, baudrate)
     msg = f"probe local {port} baud={baudrate} -> {status}"
     if reason and not ok:
         msg += f" ({reason})"
@@ -716,8 +767,6 @@ def cmd_activate_local(args: argparse.Namespace) -> int:
         "last_reason": reason,
     }
     _save_local_activation(record)
-    if ok:
-        print(f"{_CYAN}{prefix}{_RESET}")
     return 0 if ok else 1
 
 
@@ -793,13 +842,16 @@ def cmd_server_start(args: argparse.Namespace) -> int:
     python = sys.executable or "python3"
     cmd = [python, "-m", "sdev.remote.server", str(port)]
 
-    # 将输出重定向到日志文件
-    log_path = _get_server_log_path()
-    log_file = open(log_path, "a", encoding="utf-8")
-
     # cwd 设为项目根目录（包含顶层 sdev 包），以确保使用当前源码而不是已安装旧版本。
+    # server 进程内部会自行将日志写入 server.log（带大小限制），
+    # 这里无需再重定向 stdout/stderr 到日志文件。
     project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-    proc = subprocess.Popen(cmd, stdout=log_file, stderr=subprocess.STDOUT, cwd=project_root)
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        cwd=project_root,
+    )
     with open(_get_server_pid_path(), "w", encoding="utf-8") as f:
         f.write(str(proc.pid))
     print(f"sdev server 已启动：port={port}, pid={proc.pid}")

{sdev-0.5.2 → sdev-0.5.4}/sdev/remote/discovery.py

@@ -19,6 +19,73 @@ from typing import Any
 DISCOVERY_PORT = 7001
 
 
+def _debug(msg: str) -> None:
+    """
+    轻量级调试输出：
+    - 仅在环境变量 SDEV_REMOTE_DEBUG 为非空时生效；
+    - 直接写入 stderr，避免额外依赖。
+    """
+    if not os.environ.get("SDEV_REMOTE_DEBUG"):
+        return
+    try:
+        sys.stderr.write(f"[sdev-remote-debug] {msg}\n")
+        sys.stderr.flush()
+    except OSError:
+        # 调试输出失败时静默忽略，避免影响正常流程
+        pass
+
+
+def _discover_hosts_via_zeroconf(timeout: float = 0.8) -> list[tuple[str, int]]:
+    """
+    通过 zeroconf(mDNS) 发现在线 host：
+    - server 侧会发布 `_sdev._tcp.local.` 服务；
+    - 这里简单浏览该服务若干秒，收集所有实例的 IP + 端口。
+    """
+    # 允许通过环境变量彻底关闭 zeroconf，便于在特殊网络或调试时缩短等待。
+    if os.environ.get("SDEV_DISABLE_ZEROCONF"):
+        _debug("zeroconf discovery disabled by SDEV_DISABLE_ZEROCONF")
+        return []
+
+    try:
+        from zeroconf import ServiceBrowser, ServiceStateChange, Zeroconf
+    except Exception as e:  # pragma: no cover - 依赖缺失时直接跳过
+        _debug(f"zeroconf unavailable, skip mDNS discovery: {e}")
+        return []
+
+    found: dict[tuple[str, int], None] = {}
+
+    def _on_service_state(zeroconf, service_type, name, state_change) -> None:
+        if state_change is not ServiceStateChange.Added:
+            return
+        try:
+            info = zeroconf.get_service_info(service_type, name, timeout=1000)
+        except Exception:
+            return
+        if not info:
+            return
+        addrs = getattr(info, "parsed_addresses", lambda: [])()
+        if not addrs:
+            return
+        host = (addrs[0] or "").strip()
+        port = int(getattr(info, "port", 0) or 0)
+        if host and port:
+            found[(host, port)] = None
+
+    zc = Zeroconf()
+    try:
+        ServiceBrowser(zc, "_sdev._tcp.local.", handlers=[_on_service_state])
+        time.sleep(max(0.1, timeout))
+    finally:
+        try:
+            zc.close()
+        except Exception:
+            pass
+
+    hosts = [(h, p) for (h, p) in found.keys()]
+    _debug(f"zeroconf discovery hosts={hosts}")
+    return hosts
+
+
 def get_discovery_cache_path() -> str:
     if sys.platform == "win32":
         base = os.environ.get("APPDATA") or os.path.join(os.path.expanduser("~"), "AppData", "Roaming")
@@ -70,6 +137,7 @@ def _discover_hosts_via_udp(timeout: float = 1.5) -> list[tuple[str, int]]:
             targets.add(("255.255.255.255", DISCOVERY_PORT))
 
         # 发送探测报文到所有候选地址（通常只有 1~数个，很轻量）
+        _debug(f"UDP discovery targets={list(targets)}, timeout={timeout}")
         for host, port in targets:
             try:
                 sock.sendto(b"SDEV_DISCOVERY", (host, port))
@@ -95,6 +163,13 @@ def _discover_hosts_via_udp(timeout: float = 1.5) -> list[tuple[str, int]]:
                 obj = json.loads(data.decode("utf-8"))
             except (json.JSONDecodeError, UnicodeDecodeError):
                 continue
+
+            # 仅接受带有正确 magic 的 sdev 响应，避免误把其他服务当成 sdev server。
+            magic = (obj.get("magic") or "").strip()
+            if magic != "sdev-remote-v1":
+                _debug(f"UDP discovery ignore packet from {addr}: magic={magic!r}")
+                continue
+
             host = (obj.get("host") or addr[0]).strip()
             try:
                 port = int(obj.get("port") or 7000)
@@ -102,7 +177,9 @@ def _discover_hosts_via_udp(timeout: float = 1.5) -> list[tuple[str, int]]:
                 port = 7000
             if host:
                 hosts.add((host, port))
-        return list(hosts)
+        out = list(hosts)
+        _debug(f"UDP discovery got hosts={out}")
+        return out
     finally:
         try:
             sock.close()
@@ -131,9 +208,35 @@ def get_remote_hosts(service_port: int = 7000, override: str | None = None) -> l
                     out.append((s, service_port))
             else:
                 out.append((s, service_port))
+        _debug(f"get_remote_hosts from override/raw='{raw}' -> {out}")
         return out
 
-    return _discover_hosts_via_udp()
+    # 组合 UDP + zeroconf 两种发现方式，去重后返回：
+    # - UDP：对简单局域网兼容性最好；
+    # - zeroconf：对 Mac 等环境在多播受限时更友好。
+    udp_hosts = _discover_hosts_via_udp()
+    zc_hosts = _discover_hosts_via_zeroconf()
+    merged: dict[tuple[str, int], None] = {}
+    for h, p in udp_hosts + zc_hosts:
+        # service_port 仅在 host 省略端口时起作用，这里已是 (host, port) 形式，直接使用。
+        merged[(h, int(p or service_port))] = None
+
+    # 过滤掉本机 IP（包括 127.0.0.1），避免把自己当作 remote host。
+    import socket
+
+    local_ips: set[str] = {"127.0.0.1"}
+    try:
+        hostname = socket.gethostname()
+        for info in socket.getaddrinfo(hostname, None, family=socket.AF_INET):
+            ip = info[4][0]
+            if ip:
+                local_ips.add(ip)
+    except OSError:
+        pass
+
+    hosts = [(h, p) for (h, p) in merged.keys() if h not in local_ips]
+    _debug(f"get_remote_hosts via UDP+zeroconf -> {hosts} (local_ips={list(local_ips)})")
+    return hosts
 
 
 def load_discovery_cache() -> list[dict[str, Any]]:
@@ -159,6 +262,8 @@ def fetch_boards_from_host(host: str, port: int, timeout: float = 10.0) -> list[
     """向 host:port 发送 list 请求，返回带 host 字段的 boards 列表。"""
     import socket
 
+    _debug(f"fetch_boards_from_host: connect to {host}:{port}, timeout={timeout}")
+
     try:
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.settimeout(timeout)
@@ -171,12 +276,14 @@ def fetch_boards_from_host(host: str, port: int, timeout: float = 10.0) -> list[
                 break
             buf += chunk
         sock.close()
-    except Exception:
+    except Exception as e:
+        _debug(f"fetch_boards_from_host: network error host={host} port={port} err={e!r}")
         return []
     try:
         line = buf.split(b"\n", 1)[0].decode("utf-8")
         obj = json.loads(line)
     except (json.JSONDecodeError, UnicodeDecodeError):
+        _debug(f"fetch_boards_from_host: invalid response host={host} port={port} raw={buf!r}")
         return []
     boards = obj.get("boards") if isinstance(obj, dict) else []
     if not isinstance(boards, list):
@@ -184,6 +291,10 @@ def fetch_boards_from_host(host: str, port: int, timeout: float = 10.0) -> list[
     for b in boards:
         if isinstance(b, dict):
             b["host"] = host
+    _debug(
+        f"fetch_boards_from_host: parsed boards from {host}:{port} -> "
+        f"{[{'port': b.get('port'), 'baudrate': b.get('baudrate'), 'available': b.get('available')} for b in boards]}"
+    )
     return [b for b in boards if isinstance(b, dict)]
 
 
@@ -247,6 +358,10 @@ def probe_remote_port(
         "port": serial_port,
         "baudrate": baudrate,
     }
+    _debug(
+        f"probe_remote_port: connect to {host}:{service_port}, "
+        f"serial_port={serial_port}, baudrate={baudrate}, timeout={timeout}"
+    )
     try:
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.settimeout(timeout)
@@ -261,6 +376,10 @@ def probe_remote_port(
             buf += chunk
         sock.close()
     except Exception as e:
+        _debug(
+            f"probe_remote_port: network error host={host} service_port={service_port} "
+            f"serial_port={serial_port} err={e!r}"
+        )
         return {
             "port": serial_port,
             "baudrate": baudrate,
@@ -272,6 +391,10 @@ def probe_remote_port(
         line = buf.split(b"\n", 1)[0].decode("utf-8")
         obj = json.loads(line)
     except (json.JSONDecodeError, UnicodeDecodeError):
+        _debug(
+            f"probe_remote_port: invalid response host={host} service_port={service_port} "
+            f"serial_port={serial_port} raw={buf!r}"
+        )
         return {
             "port": serial_port,
             "baudrate": baudrate,
@@ -280,6 +403,10 @@ def probe_remote_port(
         }
 
     if not isinstance(obj, dict):
+        _debug(
+            f"probe_remote_port: response is not dict host={host} service_port={service_port} "
+            f"serial_port={serial_port} obj_type={type(obj)}"
+        )
         return {
             "port": serial_port,
             "baudrate": baudrate,
@@ -289,6 +416,10 @@ def probe_remote_port(
     # 远端直接返回 result 字典
     result = obj.get("result") if "result" in obj else obj
     if not isinstance(result, dict):
+        _debug(
+            f"probe_remote_port: result is not dict host={host} service_port={service_port} "
+            f"serial_port={serial_port} result_type={type(result)}"
+        )
         return {
             "port": serial_port,
             "baudrate": baudrate,
@@ -300,6 +431,10 @@ def probe_remote_port(
     result.setdefault("baudrate", baudrate)
     result.setdefault("available", False)
     result.setdefault("reason", "")
+    _debug(
+        f"probe_remote_port: ok host={host} service_port={service_port} serial_port={serial_port} "
+        f"available={result.get('available')} reason={result.get('reason')!r}"
+    )
     return result
 
 

{sdev-0.5.2 → sdev-0.5.4}/sdev/remote/server.py

@@ -88,8 +88,12 @@ def _discovery_loop(udp_sock, service_port: int) -> None:
         if msg != b"SDEV_DISCOVERY":
             continue
         logger.info(f"[server] discovery ping from {addr}, respond with port={service_port}")
+        # 回传固定 magic + TCP 服务端口，便于客户端甄别非 sdev 的 UDP 应答。
         resp = json.dumps(
-            {"host": addr[0], "port": service_port},
+            {
+                "magic": "sdev-remote-v1",
+                "port": service_port,
+            },
             ensure_ascii=False,
         ).encode("utf-8")
         try:
@@ -98,6 +102,44 @@ def _discovery_loop(udp_sock, service_port: int) -> None:
             continue
 
 
+def _get_server_log_path() -> str:
+    """
+    server.log 路径计算逻辑，与 CLI 侧保持一致：
+    默认 ~/.cache/sdev/server.log 或 XDG_RUNTIME_DIR/sdev/server.log。
+    """
+    import os
+
+    base = os.environ.get("XDG_RUNTIME_DIR") or os.path.join(os.path.expanduser("~"), ".cache")
+    log_dir = os.path.join(base, "sdev")
+    os.makedirs(log_dir, mode=0o700, exist_ok=True)
+    return os.path.join(log_dir, "server.log")
+
+
+def _setup_logging() -> None:
+    """
+    配置 loguru 日志输出到 server.log，并限制最大大小：
+    - 单个日志文件按 1 MiB 自动轮转；
+    - 保留若干历史文件，避免无限增长。
+    """
+    import os
+
+    log_path = _get_server_log_path()
+    # 确保目录存在（_get_server_log_path 已处理），这里冗余一次也无妨。
+    os.makedirs(os.path.dirname(log_path) or ".", exist_ok=True)
+
+    # 移除默认 stderr sink，避免重复输出。
+    logger.remove()
+    logger.add(
+        log_path,
+        rotation="1 MB",  # 单文件约 1 MiB 时自动轮转
+        retention=5,  # 最多保留 5 个历史文件
+        encoding="utf-8",
+        enqueue=True,
+        backtrace=False,
+        diagnose=False,
+    )
+
+
 def _handle(conn, addr):
     import json
 
@@ -199,6 +241,48 @@ class RemoteServer:
 
     def __init__(self, port: int = 7000):
         self.port = port
+        # 保留 zeroconf 对象引用，避免被 GC 提前释放
+        self._zeroconf = None
+        self._zeroconf_info = None
+
+    def _start_zeroconf(self) -> None:
+        """
+        通过 zeroconf(mDNS) 发布 sdev server 服务，便于在不支持 UDP 广播的环境中发现。
+        失败时静默降级，不影响主流程。
+        """
+        try:
+            import socket
+            from zeroconf import IPVersion, ServiceInfo, Zeroconf
+        except Exception as e:  # pragma: no cover - 依赖缺失时直接跳过
+            logger.warning(f"[server] zeroconf unavailable, skip mDNS advertise: {e}")
+            return
+
+        try:
+            host_ip = socket.gethostbyname(socket.gethostname())
+        except OSError:
+            # 回退到本地回环地址，至少不会报错；client 侧会同时使用 UDP 发现。
+            host_ip = "127.0.0.1"
+
+        service_type = "_sdev._tcp.local."
+        service_name = f"sdev-{host_ip}-{self.port}.{service_type}"
+
+        try:
+            info = ServiceInfo(
+                type_=service_type,
+                name=service_name,
+                addresses=[socket.inet_aton(host_ip)],
+                port=self.port,
+                properties={},
+            )
+            zc = Zeroconf(ip_version=IPVersion.V4Only)
+            zc.register_service(info)
+        except Exception as e:  # pragma: no cover - mDNS 故障时直接降级
+            logger.warning(f"[server] zeroconf advertise failed: {e}")
+            return
+
+        self._zeroconf = zc
+        self._zeroconf_info = info
+        logger.info(f"[server] zeroconf advertised as {service_name} ({host_ip}:{self.port})")
 
     def serve_forever(self) -> int:
         import socket
@@ -214,6 +298,9 @@ class RemoteServer:
         udp_sock.bind(("0.0.0.0", 7001))
         threading.Thread(target=_discovery_loop, args=(udp_sock, self.port), daemon=True).start()
 
+        # 通过 zeroconf 发布服务，作为 UDP discovery 的补充通道。
+        self._start_zeroconf()
+
         logger.info(f"[server] listening on 0.0.0.0:{self.port} (TCP) and 0.0.0.0:7001 (UDP discovery)")
         while True:
             conn, addr = sock.accept()
@@ -227,12 +314,15 @@ def main() -> int:
     """
     import sys
 
+    # 在解析参数后立即配置日志，保证后续日志都写入带大小限制的 server.log。
     port: int = 7000
     if len(sys.argv) > 1:
         try:
             port = int(sys.argv[1])
         except ValueError:
             pass
+
+    _setup_logging()
     server = RemoteServer(port=port)
     server.serve_forever()
     return 0

{sdev-0.5.2 → sdev-0.5.4/sdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdev
-Version: 0.5.2
+Version: 0.5.4
 Summary: 串口控制器工具包
 Home-page: https://github.com/klrc/sdev
 Author: klrc
@@ -27,6 +27,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyserial>=3.5
 Requires-Dist: loguru>=0.6.0
+Requires-Dist: zeroconf>=0.39.0
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file

{sdev-0.5.2 → sdev-0.5.4}/sdev.egg-info/requires.txt

@@ -1,2 +1,3 @@
 pyserial>=3.5
 loguru>=0.6.0
+zeroconf>=0.39.0

{sdev-0.5.2 → sdev-0.5.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="sdev",
-    version="0.5.2",
+    version="0.5.4",
     author="klrc",
     author_email="144069824@qq.com",
     description="串口控制器工具包",
@@ -31,6 +31,7 @@ setup(
     install_requires=[
         "pyserial>=3.5",
         "loguru>=0.6.0",
+        "zeroconf>=0.39.0",
     ],
     entry_points={
         "console_scripts": ["sdev=sdev.cli.cli_wrapper:main"],