collab-runtime 0.6.0__tar.gz → 0.6.2__tar.gz

{collab_runtime-0.6.0/collab_runtime.egg-info → collab_runtime-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collab-runtime
-Version: 0.6.0
+Version: 0.6.2
 Summary: Collaborative file locking runtime
 Author-email: KirilMT <kiril.mt95@gmail.com>
 License-Expression: MIT
@@ -164,7 +164,7 @@ collab release path/to/file.py
 # Check lock status for a specific file
 collab status path/to/file.py
 
-# Release all locks held by you
+# Release all locks held by you (including your own AI-agent locks)
 collab release-all
 
 # Force release (requires SUPABASE_SERVICE_ROLE_KEY)

{collab_runtime-0.6.0 → collab_runtime-0.6.2}/collab/live_locks_watcher.py

@@ -822,9 +822,9 @@ def _fetch_dev_other_identity_locks(client) -> dict[str, dict]:
 def _filter_agent_held_new_files(client, new_files: set[str]) -> set[str]:
     """Drop files already held by this developer's AI agent from the auto-lock set.
 
-    Prevents the human watcher from fighting (and logging false CONFLICTs for) the
-    developer's own agent locks. The ``acquire_lock`` RPC lets an agent take over a
-    human auto-lock, never the reverse, so the human watcher must simply step aside.
+    Prevents the human watcher from downgrading the developer's own agent locks during
+    bulk auto-watch. Explicit ``acquire`` / pre-commit paths may still re-own same-
+    developer agent locks via the ``acquire_lock`` RPC.
     """
     if not new_files:
         return new_files

{collab_runtime-0.6.0 → collab_runtime-0.6.2}/collab/lock_client.py

@@ -1118,6 +1118,11 @@ class LockClient:
     def release(self, file_path: str) -> Tuple[bool, str]:
         """Release a lock on file_path owned by this developer.
 
+        When called by a **human** (``agent_id`` is ``None``), any lock owned by this
+        ``developer_id`` is released regardless of which agent claimed it — the human is
+        in charge of all their agents.  When called by an **agent** (``agent_id`` is
+        set), only locks claimed by that specific agent identity are released.
+
         Returns (success: bool, message: str).
         """
         # If ephemeral, nothing was persisted so there's nothing to delete.
@@ -1127,16 +1132,45 @@ class LockClient:
             )
             return True, "ephemeral-released"
 
+        norm = self._normalize_file_path(file_path)
         client = self._require_client()
+
+        # Pre-check: verify a lock row exists for this file *and* belongs to
+        # this developer before attempting the DELETE.  PostgREST returns
+        # 204 No Content even when zero rows are deleted, so without this
+        # guard the CLI would falsely report "✓ released" for locks that
+        # belong to another developer or do not exist at all.
+        try:
+            check_res = _retry_on_network_error(
+                lambda: client.table("file_locks")
+                .select("developer_id")
+                .eq("file_path", norm)
+                .execute()
+            )
+        except Exception as e:
+            return False, f"API Error: {e}"
+        _st, rows, _err = self._parse_response(check_res)
+        if not rows or not isinstance(rows, list) or len(rows) == 0:
+            return False, f"No lock found for: {file_path}"
+        lock_owner = rows[0].get("developer_id")
+        if lock_owner != self.developer_id:
+            return False, (
+                f"Permission denied: {file_path} is locked by @{lock_owner or '?'}. "
+                "Use `collab force-release` if you have admin credentials."
+            )
+
         try:
-            norm = self._normalize_file_path(file_path)
             delete_query = (
                 client.table("file_locks")
                 .delete()
                 .eq("file_path", norm)
                 .eq("developer_id", self.developer_id)
             )
-            delete_query = self._apply_agent_scope(delete_query)
+            # Human (agent_id is None): developer-scoped — release any agent's
+            # lock.  Agent (agent_id is set): identity-scoped — only release
+            # this specific agent's lock.
+            if self.agent_id is not None:
+                delete_query = delete_query.eq("agent_id", self.agent_id)
             res = _retry_on_network_error(lambda: delete_query.execute())
         except Exception as e:
             return False, f"API Error: {e}"
@@ -1145,9 +1179,7 @@ class LockClient:
         if error:
             return False, f"API Error: {error}"
         if status in (200, 204) or data is not None:
-            logger.info(
-                "🔓 [RELEASED] %s — lock released", self._normalize_file_path(file_path)
-            )
+            logger.info("🔓 [RELEASED] %s — lock released", norm)
             return True, "released"
         return False, "No lock released (not owner or lock does not exist)"
 
@@ -1227,22 +1259,45 @@ class LockClient:
             "can_edit": self._lock_owned_by_me(lock),
         }
 
-    def release_all(self) -> int:
-        """Release all locks held by this developer.
+    def release_all(self, include_agent: bool = True) -> int:
+        """Release locks held by this developer.
+
+        By default (``include_agent=True``) every lock owned by this ``developer_id`` is
+        released regardless of ``agent_id`` — both the human auto-locks and this
+        developer's own AI-agent locks. This lets a human session fully clear locks left
+        behind by its own agents (for example stale agent locks after a session ended
+        without pushing). Genuine cross-developer locks are never touched.
+
+        Set ``include_agent=False`` to restrict cleanup to the current ``(developer_id,
+        agent_id)`` identity only.
 
-        Returns count released.
+        Returns the number of locks released.
         """
         try:
             locks = self.active()
         except LockServiceUnavailableError as exc:
             logger.error("release_all skipped — lock service unavailable: %s", exc)
             return 0
-        my_locks = [lk for lk in locks if self._lock_owned_by_me(lk)]
+
         count = 0
-        for lk in my_locks:
-            ok, _ = self.release(lk.get("file_path", ""))
-            if ok:
-                count += 1
+        for lk in locks:
+            file_path = lk.get("file_path", "")
+            if not file_path:
+                continue
+            if include_agent:
+                # Developer-scoped: clear any lock under our developer_id,
+                # including this developer's own agent identities.
+                if lk.get("developer_id") != self.developer_id:
+                    continue
+                if self._release_developer_scope(file_path):
+                    count += 1
+            else:
+                # Identity-scoped: only the current (developer_id, agent_id).
+                if not self._lock_owned_by_me(lk):
+                    continue
+                ok, _ = self.release(file_path)
+                if ok:
+                    count += 1
         return count
 
     def force_release(self, file_path: str) -> Tuple[bool, str]:
@@ -1985,7 +2040,7 @@ class LockClient:
         try:
             pid = self._read_pid(strict=True)
         except PidParseError as exc:
-            print(f"❌ Lock watcher status unavailable: {exc.message}")
+            print(f"ℹ️  Lock watcher status unavailable: {exc.message}")
             return False
         local_only_mode = bool(getattr(self, "local_only", False))
         if pid and self._is_process_alive(pid):
@@ -2114,7 +2169,7 @@ class LockClient:
                     return True
             except (ValueError, OSError):
                 pass
-        print("❌ Lock watcher is NOT running.")
+        print("ℹ️  Lock watcher is not running.")
         return False
 
     def cleanup_orphaned_processes(self) -> None:
@@ -3117,7 +3172,10 @@ class LockClient:
         try:
             shutdown_file = _state_path(".shutdown_complete")
             with open(shutdown_file, "w") as f:
-                f.write(f"{n_kept}\n")
+                # Write -1 sentinel when enumeration failed so that IDE
+                # extensions can distinguish "0 locks held" (normal) from
+                # "could not verify" (transient service error).
+                f.write(f"{-1 if not enumeration_ok else n_kept}\n")
                 f.flush()
                 try:
                     os.fsync(f.fileno())
@@ -3265,8 +3323,8 @@ class LockClient:
 
         # Calculate lock categories. ``missing`` excludes files already held by
         # this developer under another (agent) identity so the human watcher does
-        # not generate conflicts trying to re-lock an agent's file. Agent claims
-        # take over human auto-locks atomically in the acquire_lock RPC instead.
+        # not downgrade agent attribution during bulk reconcile. Explicit acquire
+        # (e.g. pre-commit) may still re-own same-developer agent locks via RPC.
         stale = my_locks - git_modified
         missing = git_modified - my_locks - dev_other_locked
         still_valid = my_locks & git_modified

{collab_runtime-0.6.0 → collab_runtime-0.6.2}/collab/main.py

@@ -152,7 +152,18 @@ def _run_cli() -> None:
     st.add_argument("file_path")
 
     # release-all
-    sub.add_parser("release-all", help="Release all locks held by you")
+    ra = sub.add_parser(
+        "release-all",
+        help="Release all locks held by you (including your AI-agent locks)",
+    )
+    ra.add_argument(
+        "--identity-only",
+        action="store_true",
+        help=(
+            "Only release locks for the current identity (developer + agent), "
+            "not every lock owned by your developer id"
+        ),
+    )
 
     # force-release
     fr = sub.add_parser(
@@ -473,7 +484,9 @@ def _run_cli() -> None:
                 print("🔓 File is unlocked.")
 
         elif args.command == "release-all":
-            count = client.release_all()
+            count = client.release_all(
+                include_agent=not getattr(args, "identity_only", False)
+            )
             print(f"Released {count} lock(s).")
 
         elif args.command == "force-release":

{collab_runtime-0.6.0 → collab_runtime-0.6.2/collab_runtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collab-runtime
-Version: 0.6.0
+Version: 0.6.2
 Summary: Collaborative file locking runtime
 Author-email: KirilMT <kiril.mt95@gmail.com>
 License-Expression: MIT
@@ -164,7 +164,7 @@ collab release path/to/file.py
 # Check lock status for a specific file
 collab status path/to/file.py
 
-# Release all locks held by you
+# Release all locks held by you (including your own AI-agent locks)
 collab release-all
 
 # Force release (requires SUPABASE_SERVICE_ROLE_KEY)

{collab_runtime-0.6.0 → collab_runtime-0.6.2}/docs/pypi/README.md

@@ -139,7 +139,7 @@ collab release path/to/file.py
 # Check lock status for a specific file
 collab status path/to/file.py
 
-# Release all locks held by you
+# Release all locks held by you (including your own AI-agent locks)
 collab release-all
 
 # Force release (requires SUPABASE_SERVICE_ROLE_KEY)

{collab_runtime-0.6.0 → collab_runtime-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "collab-runtime"
-version = "0.6.0"
+version = "0.6.2"
 description = "Collaborative file locking runtime"
 readme = "docs/pypi/README.md"
 license = "MIT"