Fix #10 + #11: transport hardening + controller resource leaks

#10 transport (obdcore/transport.py):
- TcpTransport.read raises IOError on a real socket error or peer-close instead
  of swallowing it as a timeout, so a dead WiFi link surfaces (via the #8 poll
  handler) as 'connection lost' rather than a frozen dashboard.
- TcpTransport.reset_input_buffer drains at most 64 chunks — never spins forever.
- BleTransport closes the client + stops the event-loop thread on connect
  timeout (no leak), caps the notification buffer at 64 KiB, and close() is
  robust when only partially initialised.

#11 controller (gui/controller.py, obdcore/store.py):
- connect() closes the transport and nulls the link if init()/connect() raises,
  so a failed/retried connect doesn't orphan sockets/threads.
- stop_record() unhooks store.recorder BEFORE closing it, and CsvRecorder now
  has a 'closed' guard so a poll-thread write racing close() is a no-op instead
  of an I/O-on-closed-file crash.

Closes #10
Closes #11

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016yT89n4zR4qbrySoSiEyZs

obdcore/store.py

@@ -128,13 +128,19 @@ class CsvRecorder:
         self._f = open(path, "w")
         self._f.write("t,key,value\n")
         self._lock = threading.Lock()
+        self._closed = False
 
     def write(self, key, t, v):
         with self._lock:
+            if self._closed:                  # a poll-thread write racing close() is a no-op
+                return
             self._f.write(f"{t:.3f},{key},{'' if v is None else v}\n")
 
     def close(self):
         with self._lock:
+            if self._closed:
+                return
+            self._closed = True
             self._f.close()
 
 

obdcore/transport.py

@@ -51,21 +51,31 @@ class TcpTransport:
 
     def read(self, n):
         try:
-            return self.sock.recv(n)
+            data = self.sock.recv(n)
         except socket.timeout:
-            return b""
-        except OSError:
-            return b""
+            return b""                        # no data yet -- normal
+        except OSError as e:
+            raise IOError(f"WiFi connection lost: {e}") from e
+        if data == b"":                       # peer closed the connection
+            raise IOError("WiFi connection closed by adapter")
+        return data
 
     def reset_input_buffer(self):
-        self.sock.settimeout(0.05)
+        # drain pending bytes, but never spin forever if data keeps arriving
+        self.sock.settimeout(0.02)
         try:
-            while self.sock.recv(4096):
-                pass
-        except Exception:
+            for _ in range(64):
+                if not self.sock.recv(4096):
+                    break
+        except socket.timeout:
+            pass
+        except OSError:
             pass
         finally:
-            self.sock.settimeout(self._rt)
+            try:
+                self.sock.settimeout(self._rt)
+            except OSError:
+                pass
 
     def close(self):
         try:
@@ -105,7 +115,9 @@ class BleTransport:
         self._thread = threading.Thread(target=self._run, daemon=True)
         self._thread.start()
         if not self._ready.wait(connect_timeout) or self._err:
-            raise RuntimeError(f"BLE connect failed: {self._err or 'timeout'}")
+            err = self._err or "timeout"
+            self.close()                      # don't leak the client + event-loop thread
+            raise RuntimeError(f"BLE connect failed: {err}")
 
     def _run(self):
         import asyncio
@@ -136,6 +148,8 @@ class BleTransport:
             def on_notify(_h, data):
                 with self._lock:
                     self._buf += bytes(data)
+                    if len(self._buf) > 65536:        # cap: never grow unbounded
+                        del self._buf[:-65536]
 
             await self._client.start_notify(notify_char, on_notify)
             self._ready.set()
@@ -168,10 +182,17 @@ class BleTransport:
             self._buf.clear()
 
     def close(self):
-        try:
-            import asyncio
-            asyncio.run_coroutine_threadsafe(self._client.disconnect(), self._loop).result(timeout=3.0)
-            self._loop.call_soon_threadsafe(self._loop.stop)
+        import asyncio
+        loop, client = self._loop, self._client
+        if loop is None:
+            return
+        if client is not None:
+            try:
+                asyncio.run_coroutine_threadsafe(client.disconnect(), loop).result(timeout=3.0)
+            except Exception:
+                pass
+        try:                                  # stop the loop even if disconnect failed,
+            loop.call_soon_threadsafe(loop.stop)   # so the background thread exits
         except Exception:
             pass