comodor 0.8.1__tar.gz → 0.8.2__tar.gz

{comodor-0.8.1 → comodor-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: comodor
-Version: 0.8.1
+Version: 0.8.2
 Summary: Comodor — a self-improving terminal coding agent with a Rich TUI
 Project-URL: Homepage, https://comodor.ai
 Project-URL: Repository, https://github.com/ifekri/Comodor

{comodor-0.8.1 → comodor-0.8.2}/src/comodor/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.8.1'
-__version_tuple__ = version_tuple = (0, 8, 1)
+__version__ = version = '0.8.2'
+__version_tuple__ = version_tuple = (0, 8, 2)
 
 __commit_id__ = commit_id = None

{comodor-0.8.1 → comodor-0.8.2}/src/comodor/ui/app.py

@@ -46,6 +46,11 @@ from .widgets.history import SessionRef
 from .widgets.overlay import info_overlay, permission_overlay, select_overlay
 from .widgets.statusbar import StatusModel
 
+#: How long quitting waits for a turn in flight. Quitting mid-task should give
+#: the agent a moment to stop rather than abandoning it, so shutting down can
+#: legitimately take this long — which is what anything timing the exit has to
+#: allow for.
+SHUTDOWN_JOIN_SECONDS = 2.0
 IDLE_SLEEP = 0.02
 SPINNER_INTERVAL = 0.1
 # How long the prompt must sit still before recall is warmed for the draft.
@@ -199,7 +204,7 @@ class App:
         if self.mcp is not None:
             self.mcp.close()
         if self.worker and self.worker.is_alive():
-            self.worker.join(timeout=2.0)
+            self.worker.join(timeout=SHUTDOWN_JOIN_SECONDS)
         # Flush whatever the agent produced after the last event we pumped —
         # quitting mid-turn must not lose the transcript.
         self._persist_new_messages()

{comodor-0.8.1 → comodor-0.8.2}/src/comodor/web/server.py

@@ -140,20 +140,43 @@ def _handler_for(server: Server) -> type[BaseHTTPRequestHandler]:
             return ""
 
         def _body(self) -> dict[str, Any]:
+            """Read the body, whatever is going to be done with it.
+
+            Always read, and read all of it. Bytes left in the socket are read
+            by the *next* request on the connection as its request line, and a
+            socket closed with unread data sends a reset instead of a close —
+            which the client sees as a connection aborted rather than as the
+            401 that was actually sent.
+            """
             try:
                 length = int(self.headers.get("Content-Length") or 0)
             except ValueError:
+                length = 0
+            if length <= 0:
                 return {}
-            if length <= 0 or length > MAX_BODY:
+
+            raw = b""
+            remaining = length
+            while remaining > 0:
+                chunk = self.rfile.read(min(remaining, 65536))
+                if not chunk:
+                    break
+                remaining -= len(chunk)
+                # Past the cap it is drained and dropped, not left unread.
+                if len(raw) < MAX_BODY:
+                    raw += chunk
+            if length > MAX_BODY:
                 return {}
             try:
-                return json.loads(self.rfile.read(length) or b"{}")
-            except (ValueError, OSError):
+                return json.loads(raw or b"{}")
+            except ValueError:
                 return {}
 
         # -- reading ------------------------------------------------------- #
 
         def do_GET(self) -> None:
+            if self.headers.get("Content-Length"):
+                self._body()               # rare, but the same rule applies
             parts = urlparse(self.path)
             query = parse_qs(parts.query)
             route = parts.path
@@ -202,6 +225,10 @@ def _handler_for(server: Server) -> type[BaseHTTPRequestHandler]:
         # -- doing --------------------------------------------------------- #
 
         def do_POST(self) -> None:
+            # Before any verdict: an unread body breaks the connection it
+            # arrived on, and the caller sees a reset instead of the refusal.
+            body = self._body()
+
             if not server.authorised(self._token()):
                 self._json(401, {"error": "unauthorised"})
                 return
@@ -213,7 +240,6 @@ def _handler_for(server: Server) -> type[BaseHTTPRequestHandler]:
                 return
 
             route = urlparse(self.path).path
-            body = self._body()
 
             if route == "/api/send":
                 started = server.session.send(str(body.get("text") or ""))
@@ -243,6 +269,8 @@ def _handler_for(server: Server) -> type[BaseHTTPRequestHandler]:
         def do_OPTIONS(self) -> None:
             # No CORS for anyone. A preflight that gets no permissions means a
             # cross-origin fetch cannot send the header the POST routes want.
+            if self.headers.get("Content-Length"):
+                self._body()
             self._send(405)
 
     return Handler

{comodor-0.8.1 → comodor-0.8.2}/tests/test_run_loop.py

@@ -83,7 +83,13 @@ def run_with(app, events, monkeypatch, budget: float = 3.0):
         app.run()
     finally:
         watchdog.cancel()
-    assert time.monotonic() < deadline + 1.0, "the loop did not exit"
+    # Shutting down is allowed to wait for a turn still in flight, so the
+    # exit cannot be quicker than that however fast the loop itself is. The
+    # tolerance is that budget plus slack, taken from the source rather than
+    # guessed, or the two drift apart and the test fails on a loaded machine
+    # for a reason that is not a bug.
+    allowed = app_module.SHUTDOWN_JOIN_SECONDS + 1.5
+    assert time.monotonic() < deadline + allowed, "the loop did not exit"
     return terminal, live
 
 

{comodor-0.8.1 → comodor-0.8.2}/tests/test_web.py

@@ -373,3 +373,89 @@ def test_an_events_own_fields_cannot_overwrite_its_kind(served):
 
     assert frames and frames[0]["kind"] == "request"
     assert frames[0]["about"] == "permission"
+
+
+# --------------------------------------------------------------------------- #
+# a refusal must still leave the connection usable
+# --------------------------------------------------------------------------- #
+
+
+def test_a_refused_post_leaves_the_connection_clean(served):
+    """The bug this exists for. A verdict reached before the body is read
+    leaves those bytes in the socket; the next request on the connection reads
+    them as its own request line, and a socket closed with unread data sends a
+    reset — which the caller sees as an aborted connection rather than the 401
+    that was actually sent."""
+    import http.client
+
+    connection = http.client.HTTPConnection("127.0.0.1", served.port, timeout=15)
+    try:
+        payload = json.dumps({"text": "x" * 50_000})
+        # Rejected for the missing guard header, with a body already in flight.
+        connection.request("POST", "/api/send", body=payload,
+                           headers={"Content-Type": "application/json",
+                                    "Cookie": f"{COOKIE}={served.token}"})
+        first = connection.getresponse()
+        first.read()
+        assert first.status == 403
+
+        # The same connection, reused. If the body was not drained this reads
+        # the leftover as a request line and fails.
+        connection.request("GET", "/api/state",
+                           headers={"Cookie": f"{COOKIE}={served.token}"})
+        second = connection.getresponse()
+        state = json.loads(second.read())
+
+        assert second.status == 200
+        assert "mode" in state
+    finally:
+        connection.close()
+
+
+def test_an_unauthorised_post_leaves_the_connection_clean(served):
+    import http.client
+
+    connection = http.client.HTTPConnection("127.0.0.1", served.port, timeout=15)
+    try:
+        connection.request("POST", "/api/send",
+                           body=json.dumps({"text": "y" * 20_000}),
+                           headers={"Content-Type": "application/json",
+                                    "X-Comodor": "1"})
+        first = connection.getresponse()
+        first.read()
+        assert first.status == 401
+
+        connection.request("GET", "/api/state",
+                           headers={"Cookie": f"{COOKIE}={served.token}"})
+        second = connection.getresponse()
+        second.read()
+
+        assert second.status == 200
+    finally:
+        connection.close()
+
+
+def test_a_body_over_the_cap_is_drained_rather_than_left_in_the_socket(served):
+    """Refusing to read is what breaks the connection, so an oversized body is
+    read and dropped instead."""
+    import http.client
+
+    from comodor.web.server import MAX_BODY
+
+    connection = http.client.HTTPConnection("127.0.0.1", served.port, timeout=30)
+    try:
+        connection.request("POST", "/api/send", body="z" * (MAX_BODY + 5_000),
+                           headers={"Content-Type": "application/json",
+                                    "Cookie": f"{COOKIE}={served.token}",
+                                    "X-Comodor": "1"})
+        first = connection.getresponse()
+        first.read()
+
+        connection.request("GET", "/api/state",
+                           headers={"Cookie": f"{COOKIE}={served.token}"})
+        second = connection.getresponse()
+        second.read()
+
+        assert second.status == 200
+    finally:
+        connection.close()