comodor 0.8.0__tar.gz → 0.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: comodor
-Version: 0.8.0
+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.0 → 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.0'
-__version_tuple__ = version_tuple = (0, 8, 0)
+__version__ = version = '0.8.2'
+__version_tuple__ = version_tuple = (0, 8, 2)
 
 __commit_id__ = commit_id = None

{comodor-0.8.0 → comodor-0.8.2}/src/comodor/tools/delegate.py

@@ -192,9 +192,11 @@ class _Worktree:
             return None
         return cls(path, branch, root)
 
-    def diff(self) -> str:
+    def diff(self) -> bytes:
+        """The patch, as bytes. Decoding it would ruin a binary diff and
+        re-encoding it is one more chance to change a line ending."""
         _git(self.path, "add", "-A")
-        return _git(self.path, "diff", "--cached") or ""
+        return _git_bytes(self.path, "diff", "--cached") or b""
 
     def remove(self) -> None:
         _git(self.origin, "worktree", "remove", "--force", str(self.path))
@@ -236,7 +238,7 @@ def _with_changes(outcome: ToolResult, worktree: _Worktree, ctx: ToolContext,
             content=outcome.content + "\n\n[it changed no files]",
             **outcome.meta)
 
-    applied = _git(ctx.cwd, "apply", "--3way", "-", stdin=patch + "\n")
+    applied = _git(ctx.cwd, "apply", "--3way", "-", stdin=patch + b"\n")
     if applied is None:
         worktree.keep = True
         return ToolResult.success(
@@ -246,7 +248,8 @@ def _with_changes(outcome: ToolResult, worktree: _Worktree, ctx: ToolContext,
                      f"read the files there, or discard it.]"),
             worktree=str(worktree.path), applied=False, **outcome.meta)
 
-    files = sorted({line.split("/", 1)[-1] for line in patch.splitlines()
+    listed = patch.decode("utf-8", "replace")
+    files = sorted({line.split("/", 1)[-1] for line in listed.splitlines()
                     if line.startswith("+++ b/")})
     listed = ", ".join(files[:12]) or "none"
     return ToolResult.success(
@@ -263,11 +266,23 @@ def _git_root(cwd: Path) -> Path | None:
     return root if root.is_dir() else None
 
 
-def _git(cwd: Path, *args: str, stdin: str | None = None) -> str | None:
+def _git(cwd: Path, *args: str, stdin: bytes | None = None) -> str | None:
     """Run one git command. ``None`` means it failed, and failure is expected."""
+    raw = _git_bytes(cwd, *args, stdin=stdin)
+    return None if raw is None else raw.decode("utf-8", "replace")
+
+
+def _git_bytes(cwd: Path, *args: str, stdin: bytes | None = None) -> bytes | None:
+    """The same, without decoding anything.
+
+    Deliberately not `text=True`. That wraps stdin in a stream with default
+    newline handling, and on Windows every `\n` written becomes `\r\n` — which
+    turns a patch into one git will not apply, on that platform only, with an
+    error that reads exactly like a merge conflict.
+    """
     try:
         done = subprocess.run(
-            ["git", *args], cwd=str(cwd), input=stdin, text=True,
+            ["git", *args], cwd=str(cwd), input=stdin,
             capture_output=True, timeout=120.0,
         )
     except (OSError, subprocess.SubprocessError):

{comodor-0.8.0 → 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.0 → 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.0 → comodor-0.8.2}/tests/test_delegate.py

@@ -184,7 +184,7 @@ def test_the_parents_working_tree_is_not_where_it_experiments(config, bus,
         (worktree.path / "app.py").write_text("value = 2\n", encoding="utf-8")
 
         assert (repo / "app.py").read_text() == "value = 1\n"
-        assert "value = 2" in worktree.diff()
+        assert b"value = 2" in worktree.diff()
     finally:
         worktree.remove()
 
@@ -267,3 +267,53 @@ def test_a_repository_gets_the_checkout_and_says_nothing_about_it(config, bus,
     result = tool.run(tool_context, task="Change something.", write=True)
 
     assert "directly in this project" not in result.content
+
+
+def test_the_patch_reaches_git_as_the_bytes_it_was(config, bus, tool_context, repo):
+    """`subprocess(text=True)` wraps stdin in a stream with default newline
+    handling, and on Windows every "\n" written becomes "\r\n". For output that
+    is harmless; for a patch it is fatal — every line of the diff gains a
+    carriage return, the context no longer matches, and git refuses all of it.
+
+    The failure was silent and one-platform: on Linux and macOS nothing is
+    translated, so every delegate that changed a file worked here and reported
+    an imaginary merge conflict on Windows."""
+    from comodor.tools.base import ToolResult
+    from comodor.tools.delegate import _Worktree, _with_changes
+
+    tool_context.cwd = repo
+    worktree = _Worktree.create(repo)
+    assert worktree is not None
+    try:
+        (worktree.path / "app.py").write_text("value = 2\nsecond = 3\n",
+                                              encoding="utf-8", newline="")
+        patch = worktree.diff()
+
+        assert isinstance(patch, bytes), "a patch is bytes, not text"
+        assert b"\r\n" not in patch, "the patch already has carriage returns"
+
+        result = _with_changes(ToolResult.success("did it"), worktree,
+                               tool_context, 1.0)
+
+        assert result.meta["applied"] is True, result.content
+        # Read as text: git applies the checkout's own line-ending policy when
+        # it writes, and on Windows that legitimately produces CRLF. What had
+        # to survive is the content, which is what the mangled patch destroyed.
+        assert (repo / "app.py").read_text() == "value = 2\nsecond = 3\n"
+    finally:
+        worktree.keep = False
+        worktree.remove()
+
+
+def test_git_is_never_asked_to_translate_anything():
+    """The one line that caused it, pinned so it cannot come back."""
+    import inspect
+
+    from comodor.tools import delegate
+
+    source = inspect.getsource(delegate._git_bytes)
+    # The docstring explains the trap by name, so look at the code only.
+    code = source.split('"""')[-1]
+
+    assert "text=True" not in code
+    assert "universal_newlines" not in code

{comodor-0.8.0 → 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.0 → 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()