code-coordinator 0.5.318__tar.gz → 0.5.319__tar.gz

{code_coordinator-0.5.318 → code_coordinator-0.5.319}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.318
+Version: 0.5.319
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.318 → code_coordinator-0.5.319}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.318
+Version: 0.5.319
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.318 → code_coordinator-0.5.319}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.318",
+  "tag": "0.5.319",
   "distance": 0,
-  "node": "g232148cbec6041ecf0afda964794347d61a21a64",
+  "node": "g165faa16cdaa61de166b57fd7ce0d5b3adaa018c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-31"

{code_coordinator-0.5.318 → code_coordinator-0.5.319}/coord/db.py

@@ -1775,13 +1775,27 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
     error raised for a duplicate column (SQLite's ``OperationalError``;
     Postgres's equivalent under ``sql.driver_errors()``, #2784) is silently
     swallowed.
+
+    #2982: Postgres aborts the whole transaction on a failed statement, so
+    without a ``conn.rollback()`` here the *first* duplicate ALTER (every
+    entry in ``_MIGRATE_ADD_COLUMNS`` is one, against a freshly-created
+    schema) leaves the connection unusable -- every statement after it,
+    including the remaining ALTERs and ``_set_schema_version``'s own
+    ``DELETE FROM schema_version``, fails with
+    ``psycopg.errors.InFailedSqlTransaction``. SQLite has no such concept
+    (a failed statement there doesn't touch the transaction), so the
+    rollback is a no-op on that backend -- and by this point in
+    ``_ensure_schema`` there is nothing uncommitted to lose on either
+    backend: the schema script already committed, and each successful ALTER
+    in this loop commits immediately, so a rollback can only ever discard
+    the one statement that just failed.
     """
     for ddl in _MIGRATE_ADD_COLUMNS:
         try:
             sql.execute(conn, ddl)
             conn.commit()
         except sql.driver_errors():
-            pass  # Column already exists
+            conn.rollback()  # Column already exists; Postgres needs the tx cleared
 
 
 # ── JSON migration ─────────────────────────────────────────────────────────────

{code_coordinator-0.5.318 → code_coordinator-0.5.319}/tests/test_db.py

@@ -6,6 +6,7 @@ import json
 import sqlite3
 import threading
 from pathlib import Path
+from typing import Any
 
 import pytest
 
@@ -20,6 +21,7 @@ from coord.db import (
     is_lock_contention_error,
     retry_on_locked,
 )
+from tests import backends
 
 
 # ── Fixtures ──────────────────────────────────────────────────────────────────
@@ -2254,6 +2256,154 @@ class TestMigrateAddColumnsVersionGuard:
         )
 
 
+# ── _migrate_add_columns rolls back on a Postgres-style tx abort (#2982) ───
+#
+# Root cause: every entry in `_MIGRATE_ADD_COLUMNS` duplicates a column
+# `_SCHEMA_SQL` already creates, so on a freshly-created schema the very
+# first ALTER in the loop errors. SQLite tolerates a failed statement without
+# touching the transaction, so the old `except sql.driver_errors(): pass`
+# was invisible there -- but Postgres aborts the *whole* transaction on any
+# error, so without a `conn.rollback()` every statement after the first
+# swallowed error fails with `psycopg.errors.InFailedSqlTransaction`,
+# including `_set_schema_version`'s own `DELETE FROM schema_version` inside
+# the very same `_ensure_schema()` call that is running the loop.
+
+
+class _AbortOnErrorCursor:
+    """Delegates to a real sqlite3 cursor, except it flags its parent
+    connection as aborted the moment a statement raises -- see
+    ``_AbortOnErrorConn`` below."""
+
+    def __init__(self, real_cursor: Any, parent: "_AbortOnErrorConn") -> None:
+        self._real = real_cursor
+        self._parent = parent
+
+    def execute(self, *args: Any, **kwargs: Any) -> "_AbortOnErrorCursor":
+        if self._parent._aborted:
+            raise sqlite3.OperationalError("current transaction is aborted")
+        try:
+            self._real.execute(*args, **kwargs)
+        except sqlite3.OperationalError:
+            self._parent._aborted = True
+            raise
+        return self
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._real, name)
+
+
+class _AbortOnErrorConn:
+    """Wraps a real, already-schema'd sqlite3 connection and reproduces
+    Postgres's abort-the-whole-transaction-on-error behaviour on top of it:
+    once a statement raises, every later statement -- including
+    ``commit()`` -- raises the same error until ``rollback()`` clears it.
+
+    This is what lets the #2982 regression be driven -- and go red on the
+    pre-fix code -- on a SQLite-only dev machine with no Postgres server:
+    nothing here talks to a real Postgres, but the observable shape (a
+    swallowed error leaves the connection unusable until rolled back) is
+    the same defect.
+    """
+
+    def __init__(self, real: sqlite3.Connection) -> None:
+        self._real = real
+        self._aborted = False
+
+    def cursor(self) -> _AbortOnErrorCursor:
+        if self._aborted:
+            raise sqlite3.OperationalError("current transaction is aborted")
+        return _AbortOnErrorCursor(self._real.cursor(), self)
+
+    def commit(self) -> None:
+        if self._aborted:
+            raise sqlite3.OperationalError("current transaction is aborted")
+        self._real.commit()
+
+    def rollback(self) -> None:
+        self._aborted = False
+        self._real.rollback()
+
+
+class TestMigrateAddColumnsRollsBackOnDriverError:
+    """Drives the #2982 regression with the abort-simulating stub above --
+    meaningful without a Postgres server, per the issue's acceptance
+    criterion."""
+
+    def _wrapped_conn_with_columns_already_present(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> _AbortOnErrorConn:
+        real = sqlite3.connect(":memory:")
+        real.row_factory = sqlite3.Row
+        db_mod._ensure_schema(real)  # every _MIGRATE_ADD_COLUMNS column now exists
+        # `sql.detect_dialect` keys off `type(conn).__module__`, which the
+        # stub fails (it isn't a sqlite3.Connection subclass) -- pin it to
+        # "sqlite" so `sql.execute`/`sql.executescript`'s translate() and
+        # cursor() calls behave exactly as they would against the real
+        # connection underneath.
+        monkeypatch.setattr(sql, "detect_dialect", lambda conn: sql.DIALECT_SQLITE)
+        return _AbortOnErrorConn(real)
+
+    def test_ensure_schema_completes_when_a_duplicate_alter_aborts_the_tx(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """The acceptance criterion, verbatim: `_ensure_schema()` runs to
+        completion, and `schema_version` ends up holding
+        `_DB_SCHEMA_VERSION`, on a connection where a duplicate ALTER
+        errors. Pre-fix, this raises `OperationalError("current
+        transaction is aborted")` out of `_set_schema_version`'s `DELETE
+        FROM schema_version` -- the exact failure the issue reports,
+        reproduced without touching a real Postgres."""
+        conn = self._wrapped_conn_with_columns_already_present(monkeypatch)
+
+        db_mod._ensure_schema(conn)  # every ALTER this pass is a duplicate
+
+        rows = sql.execute(conn, "SELECT version FROM schema_version").fetchall()
+        assert len(rows) == 1
+        assert rows[0]["version"] == db_mod._DB_SCHEMA_VERSION
+
+    def test_migrate_add_columns_leaves_the_connection_usable(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Narrower unit check directly on `_migrate_add_columns`: every one
+        of the 74 duplicate ALTERs must be individually recovered, not just
+        "the suite happens to still work by the end" -- a plain `commit()`
+        right after must not raise."""
+        conn = self._wrapped_conn_with_columns_already_present(monkeypatch)
+
+        db_mod._migrate_add_columns(conn)
+
+        conn.commit()  # raises "current transaction is aborted" pre-fix
+
+
+class TestMigrateAddColumnsRollsBackOnRealPostgres:
+    """The same #2982 regression against an actual Postgres server, when one
+    is reachable -- the stub-based class above proves the fix is logically
+    correct; this proves it against the real driver-error shape
+    (`psycopg.errors.InFailedSqlTransaction`) the issue was filed against.
+    Skips outright on a machine with no Postgres server, matching the
+    #2885 write-parity harness's own skip pattern."""
+
+    def test_ensure_schema_completes_on_postgres_with_columns_already_present(
+        self,
+    ) -> None:
+        unavailable = backends.postgres_available()
+        if unavailable:
+            pytest.skip(f"no Postgres backend available: {unavailable}")
+
+        session = backends.open_named_session(backends.BACKEND_POSTGRES)
+        try:
+            db_mod._ensure_schema(session.conn)  # first pass: fresh schema
+            db_mod._ensure_schema(session.conn)  # second pass: every ALTER duplicates
+
+            rows = sql.execute(
+                session.conn, "SELECT version FROM schema_version"
+            ).fetchall()
+            assert len(rows) == 1
+            assert rows[0]["version"] == db_mod._DB_SCHEMA_VERSION
+        finally:
+            session.close()
+
+
 # ── #2752: non-release builds must not stamp the production DB's schema ─────
 #
 # #1960's guard only fires under pytest, so it can't prove anything about

{code_coordinator-0.5.318 → code_coordinator-0.5.319}/tests/test_sqlite_connect_ratchet.py

@@ -116,7 +116,7 @@ SQLITE_CONNECT_ALLOWLIST: dict[str, Classification] = {
 
     # ── A: legitimately SQLite-specific ───────────────────────────────────
     "test_db.py": Classification(
-        38, (BUCKET_A,),
+        39, (BUCKET_A,),
         "The canonical bucket-A file: it tests coord/db.py's SQLite "
         "connection machinery itself — pre-migration CREATE TABLEs read back "
         "with PRAGMA table_info, busy_timeout contention across two "
@@ -136,7 +136,24 @@ SQLITE_CONNECT_ALLOWLIST: dict[str, Classification] = {
         "back a connection on the active backend — under "
         "COORD_TEST_BACKEND=postgres that is the very thing this test proves "
         "is bypassed. A bare sqlite3 sentinel, matching the neighbouring "
-        "TestOverrideConnection cases, is the point.",
+        "TestOverrideConnection cases, is the point. "
+        "+1 for #2982's TestMigrateAddColumnsRollsBackOnDriverError::"
+        "_wrapped_conn_with_columns_already_present: it schemas a real "
+        "sqlite3 connection and then wraps it in a stub that reproduces "
+        "Postgres's abort-the-whole-transaction-on-error semantics on top, "
+        "so _migrate_add_columns' missing conn.rollback() can be driven red "
+        "on a machine with no Postgres server. The connection underneath has "
+        "to be a genuine sqlite3 one: the stub raises and catches "
+        "sqlite3.OperationalError and pins sql.detect_dialect to "
+        "DIALECT_SQLITE so translate()/cursor() behave as they do against "
+        "the real driver. coord_db is out (it is already installed as the "
+        "override, and under COORD_TEST_BACKEND=postgres it is a psycopg "
+        "connection that already aborts for real, which is the behaviour "
+        "being *simulated* here), and scratch_database() is out for the same "
+        "backend-following reason. Same subject as the rest of this file — "
+        "coord/db.py's migration machinery — so it files A alongside it. The "
+        "sibling TestMigrateAddColumnsRollsBackOnRealPostgres class adds no "
+        "site: it goes through tests.backends.open_named_session().",
     ),
     "test_sql_dialect.py": Classification(
         7, (BUCKET_A,),