ha(H1): исправления по ревью — жизненный цикл сессии, самодостаточный wheel

- C1: единственный владелец stop+destroy — reader-поток; close() только
  выставляет флаг и ждёт; повторный close и close из колбэка безопасны
  (регресс-тесты; TSan на close с мёртвым модулем — 0 гонок)
- M1: wheel собирается с bundled mbedtls (нет внешней soname mbedcrypto);
  попутно исправлена bundled-ветка CMake (-lSTATIC)
- C-API: счётчики потерянных событий/логов, лог-кольцо без union-балласта,
  атомарные fn/ctx лог-синка
- provision: валидация формата облачных ответов; CLI: человеческие ошибки
  (exit 2), --out с правами 0600, console_script pyfglair
- упаковка: MANIFEST.in (sdist с C++-исходниками), очистка stale .so,
  readme в метаданных; find_library без ложных .bak
- тесты: close-сценарии, доставка логов, ошибки CLI/provision, C-API очередь

tests/pyfglair/conftest.py

@@ -90,7 +90,13 @@ def ac_env() -> dict:
 @pytest.fixture
 async def cloud():
     """Мок облака Ayla: sign_in / devices / lan.json."""
-    state = {"url": "", "fail_login": False, "no_key": False}
+    state = {
+        "url": "",
+        "fail_login": False,
+        "no_key": False,
+        "bad_devices": False,
+        "bad_lanip": False,
+    }
 
     async def sign_in(request):
         if state["fail_login"]:
@@ -99,6 +105,8 @@ async def cloud():
 
     async def devices(request):
         assert request.headers["Authorization"] == "auth_token tok-123"
+        if state["bad_devices"]:
+            return web.json_response([{"device": "not-an-object"}])
         return web.json_response([
             {
                 "device": {
@@ -114,6 +122,8 @@ async def cloud():
     async def lan(request):
         if state["no_key"]:
             return web.json_response({"lanip": {}})
+        if state["bad_lanip"]:
+            return web.json_response({"lanip": ["unexpected"]})
         return web.json_response({
             "lanip": {"lanip_key": "TW9ja0tleQ==", "lanip_key_id": KEY_ID}
         })

tests/pyfglair/test_cli.py

@@ -40,6 +40,38 @@ async def test_cli_discover_esphome_secrets(cloud, capfd):
     assert "bedroom_lanip_key_id: 64201" in out
 
 
+async def test_cli_discover_error(cloud, capfd):
+    cloud["fail_login"] = True
+    rc = await asyncio.to_thread(
+        main,
+        [
+            "discover", "--api-base", cloud["url"],
+            "--email", "user@example.com", "--password", "bad",
+        ],
+    )
+    assert rc == 2
+    err = capfd.readouterr().err
+    assert "Ошибка входа" in err
+    assert "Traceback" not in err
+
+
+async def test_cli_discover_out_file(cloud, capfd, tmp_path):
+    out_file = tmp_path / "config_bedroom.json"
+    rc = await asyncio.to_thread(
+        main,
+        [
+            "discover", "--api-base", cloud["url"],
+            "--email", "user@example.com", "--password", "secret",
+            "--out", str(out_file),
+        ],
+    )
+    assert rc == 0
+    capfd.readouterr()
+    assert out_file.stat().st_mode & 0o777 == 0o600
+    config = json.loads(out_file.read_text())
+    assert config["dsn"] == "AC000W00MOCK0001"
+
+
 async def test_cli_monitor(mock_ac, ac_env, capfd):
     proc = mock_ac()
     rc = await asyncio.to_thread(

tests/pyfglair/test_core_api.py

@@ -0,0 +1,55 @@
+"""Низкоуровневые проверки C-API: очередь событий, счётчики, ошибки входа."""
+from __future__ import annotations
+
+from pyfglair._cffi import ffi, lib
+
+
+def _make_session():
+    cfg = ffi.new("fgl_config_t*")
+    cfg.host = ffi.new("char[]", b"127.0.0.1")
+    cfg.device_port = 9
+    cfg.dsn = ffi.new("char[]", b"AC000W00MOCK0001")
+    cfg.lanip_key = ffi.new("char[]", b"key")
+    cfg.lanip_key_id = 1
+    cfg.tmpl = 0
+    cfg.listen_port = 0
+    cfg.keepalive_ms = 1000
+    cfg.max_queue = 40
+    session = lib.fgl_session_create(cfg, ffi.NULL)
+    assert session != ffi.NULL
+    return session
+
+
+def test_poll_wait_empty():
+    session = _make_session()
+    try:
+        out = ffi.new("fgl_event_t[]", 4)
+        assert lib.fgl_session_poll_events(session, out, 4) == 0
+        assert lib.fgl_session_wait_events(session, out, 4, 0) == 0
+        assert lib.fgl_session_events_dropped(session) == 0
+    finally:
+        lib.fgl_session_destroy(session)
+
+
+def test_poll_invalid_args():
+    session = _make_session()
+    try:
+        out = ffi.new("fgl_event_t[]", 4)
+        assert lib.fgl_session_poll_events(session, ffi.NULL, 4) == 0
+        assert lib.fgl_session_poll_events(session, out, 0) == 0
+        assert lib.fgl_session_wait_events(session, out, 0, 0) == 0
+        assert lib.fgl_session_poll_events(ffi.NULL, out, 4) == 0
+        assert lib.fgl_session_events_dropped(ffi.NULL) == 0
+    finally:
+        lib.fgl_session_destroy(session)
+
+
+def test_create_null_config():
+    assert lib.fgl_session_create(ffi.NULL, ffi.NULL) == ffi.NULL
+
+
+def test_log_poll_empty():
+    out = ffi.new("fgl_log_event_t[]", 4)
+    assert lib.fgl_log_poll_events(out, 4) >= 0
+    assert lib.fgl_log_wait_events(out, 4, 0) >= 0
+    assert lib.fgl_log_events_dropped() >= 0

tests/pyfglair/test_provision.py

@@ -47,3 +47,15 @@ async def test_discover_no_key(cloud):
 async def test_discover_unknown_region():
     with pytest.raises(ProvisionError, match="регион"):
         await discover("user@example.com", "secret", "xx")
+
+
+async def test_discover_malformed_devices(cloud):
+    cloud["bad_devices"] = True
+    with pytest.raises(ProvisionError, match="формат устройства"):
+        await discover("user@example.com", "secret", "eu", base_url=cloud["url"])
+
+
+async def test_discover_malformed_lanip(cloud):
+    cloud["bad_lanip"] = True
+    with pytest.raises(ProvisionError, match="lanip"):
+        await discover("user@example.com", "secret", "eu", base_url=cloud["url"])

tests/pyfglair/test_session.py

@@ -74,6 +74,114 @@ async def test_session_against_mock(mock_ac, ac_env):
     assert proc.wait_line("DELETE", 10) is not None
 
 
+async def test_close_idempotent(mock_ac, ac_env):
+    proc = mock_ac()
+    cfg = Config(
+        host="127.0.0.1",
+        device_port=proc.port,
+        dsn=ac_env["dsn"],
+        lanip_key=ac_env["key"],
+        lanip_key_id=ac_env["key_id"],
+    )
+    session = Session(cfg)
+    assert session.start()
+    await session.async_stop()
+    await session.async_stop()
+    assert session.close() is None
+    assert session.closed
+    assert session.set_int(Prop.FAN_SPEED, 1) is False
+    assert session.cached(Prop.FAN_SPEED) is None
+
+
+async def test_close_offline_module(ac_env):
+    import socket
+
+    sock = socket.socket()
+    sock.bind(("127.0.0.1", 0))
+    dead_port = sock.getsockname()[1]
+    sock.close()
+
+    cfg = Config(
+        host="127.0.0.1",
+        device_port=dead_port,
+        dsn=ac_env["dsn"],
+        lanip_key=ac_env["key"],
+        lanip_key_id=ac_env["key_id"],
+        keepalive_ms=500,
+    )
+    session = Session(cfg)
+    session.start()
+    await asyncio.sleep(0.5)
+    await session.async_stop()
+    assert session.closed
+    assert session.events_dropped == 0
+
+
+async def test_close_from_callback(mock_ac, ac_env):
+    """Без loop колбэк идёт в reader-потоке; close() оттуда не дедлочится."""
+    import threading
+
+    proc = mock_ac()
+    holder: list[Session] = []
+    called = threading.Event()
+
+    def on_state(state, error):
+        if state == State.REGISTERING and holder:
+            holder[0].close()
+            called.set()
+
+    cfg = Config(
+        host="127.0.0.1",
+        device_port=proc.port,
+        dsn=ac_env["dsn"],
+        lanip_key=ac_env["key"],
+        lanip_key_id=ac_env["key_id"],
+    )
+
+    def build():
+        session = Session(cfg, loop=None, on_state=on_state)
+        holder.append(session)
+        session.start()
+        return session
+
+    session = await asyncio.to_thread(build)
+    assert await asyncio.to_thread(called.wait, 10), "колбэк не пришёл"
+    deadline = time.monotonic() + 10
+    while not session.closed and time.monotonic() < deadline:
+        await asyncio.sleep(0.05)
+    assert session.closed
+    assert session.close() is None
+
+
+async def test_log_delivery(mock_ac, ac_env):
+    from pyfglair import set_log_handler, set_log_level
+
+    logs: list[tuple[int, str]] = []
+    set_log_level(0)
+    set_log_handler(lambda level, msg: logs.append((level, msg)))
+    try:
+        proc = mock_ac()
+        cfg = Config(
+            host="127.0.0.1",
+            device_port=proc.port,
+            dsn=ac_env["dsn"],
+            lanip_key=ac_env["key"],
+            lanip_key_id=ac_env["key_id"],
+            keepalive_ms=1000,
+        )
+        session = Session(cfg)
+        session.start()
+        deadline = time.monotonic() + 10
+        while not logs and time.monotonic() < deadline:
+            await asyncio.sleep(0.1)
+        await session.async_stop()
+    finally:
+        set_log_handler(None)
+        set_log_level(1)
+    assert logs, "логи ядра не доставлены"
+    assert all(isinstance(level, int) and message for level, message in logs)
+
+
 async def test_callbacks_run_in_loop_thread(mock_ac, ac_env):
     proc = mock_ac()
     loop = asyncio.get_running_loop()