@caddis/cli 0.4.39 → 0.4.42

package/bundles/antigravity-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "caddis",
-  "version": "1.3.126",
+  "version": "1.3.128",
   "description": "caddis — agent-agnostic dev harness as an Antigravity (agy) plugin: TDD skills + commands, single-sourced with the Claude Code plugin."
 }

package/bundles/antigravity-plugin/scripts/caddis_governor.py

@@ -406,6 +406,19 @@ def job_process_ids(job: int) -> list[int]:
     return [int(lst.ProcessIdList[i]) for i in range(lst.NumberOfProcessIdsInList)]
 
 
+def query_named_job(name: str) -> tuple[float, list[int]]:
+    """Read a named job from a separate process using query access only."""
+    if sys.platform != "win32" or not name:
+        raise GovernorError("a Windows job name is required")
+    job = kernel32.OpenJobObjectW(JOB_OBJECT_QUERY, False, name)
+    if not job:
+        raise _winerr("OpenJobObjectW(query)")
+    try:
+        return job_cpu_seconds(job), job_process_ids(job)
+    finally:
+        close_job(job)
+
+
 def close_job(job: int) -> None:
     """Close a job handle. Never call it on the last handle of a job the calling process belongs to."""
     kernel32.CloseHandle(job)
@@ -451,7 +464,8 @@ def _host_kind() -> str:
 
 
 def exec_governed(argv: list[str], scope: str, budget: Path | None = None,
-                  machine_budget: Path | None = None, allow_uncapped: bool = False) -> int:
+                  machine_budget: Path | None = None, allow_uncapped: bool = False,
+                  job_name: str | None = None) -> int:
     """Run `argv` under the scope's limits and return its exit code.
 
     On Windows this puts the CURRENT process into the job for the rest of its life, so it is only
@@ -470,7 +484,7 @@ def exec_governed(argv: list[str], scope: str, budget: Path | None = None,
             parent = verified_parent_percent(os.environ)
             rate = effective_cpu_rate(limits, parent)
             machine_pct = effective_machine_percent(limits, parent)
-            name = new_job_name()
+            name = job_name or new_job_name()
             job = create_job(limits, rate, name)
             try:
                 assign_current_process(job)
@@ -518,6 +532,7 @@ def main(argv: list[str] | None = None) -> int:
     p_exec.add_argument("--scope", choices=SCOPES, required=True)
     p_exec.add_argument("--budget", type=Path)
     p_exec.add_argument("--machine-budget", type=Path, help=argparse.SUPPRESS)  # additional ceiling only
+    p_exec.add_argument("--job-name", help=argparse.SUPPRESS)
     p_exec.add_argument("--allow-uncapped", action="store_true",
                         help="where no cap can be applied (no systemd-run, macOS), run at lower priority anyway")
     p_show = sub.add_parser("show", help="print the effective limits")
@@ -538,7 +553,8 @@ def main(argv: list[str] | None = None) -> int:
     if not command:
         sys.stderr.write("usage: caddis_governor.py exec --scope session|lane [--budget PATH] -- <command...>\n")
         return EXIT_USAGE
-    return exec_governed(command, args.scope, args.budget, args.machine_budget, args.allow_uncapped)
+    return exec_governed(command, args.scope, args.budget, args.machine_budget,
+                         args.allow_uncapped, args.job_name)
 
 
 if __name__ == "__main__":

package/bundles/antigravity-plugin/scripts/caddis_heavy_slot.py

@@ -0,0 +1,227 @@
+"""Heavy-run slot manager.
+
+Limits concurrent test-heavy runs (test suites, gates) using non-blocking OS byte locks.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import datetime
+import errno
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import BinaryIO, Callable, Iterator
+
+if os.name == "nt":
+    import msvcrt
+else:
+    import fcntl
+
+
+class HeavySlotBusy(Exception):
+    """Raised when all heavy-run slots remain busy after the wait budget expires."""
+
+    def __init__(self, holder: str | None = None) -> None:
+        self.holder = holder
+        message = f"heavy-run slot busy: {holder}" if holder else "heavy-run slot busy"
+        super().__init__(message)
+
+
+def _try_lock(handle: BinaryIO) -> bool:
+    try:
+        if os.name == "nt":
+            handle.seek(0)
+            msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        return True
+    except OSError as exc:
+        if exc.errno not in (errno.EACCES, errno.EAGAIN, errno.EDEADLK):
+            raise
+        return False
+
+
+def _unlock(handle: BinaryIO) -> None:
+    try:
+        if os.name == "nt":
+            handle.seek(0)
+            msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+        else:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+    except OSError:
+        pass
+
+
+def _read_holder(slot_path: Path) -> str | None:
+    try:
+        flags = os.O_RDONLY | getattr(os, "O_BINARY", 0)
+        fd = os.open(slot_path, flags)
+        with os.fdopen(fd, "rb") as f:
+            if os.name == "nt":
+                # On Windows, byte 0 is locked by the holder process, so reading byte 0
+                # raises PermissionError. Seeking to 1 reads the remainder of the payload.
+                f.seek(1)
+            raw = f.read()
+            text = raw.decode("utf-8", errors="replace").strip()
+            return text or None
+    except Exception:
+        return None
+
+
+def _resolve_slots(slots: int | None) -> int:
+    if slots is not None:
+        try:
+            val = int(slots)
+            if val < 0:
+                sys.stderr.write(f"CADDIS_HEAVY_SLOTS: invalid value {slots!r}; defaulting to 1\n")
+                return 1
+            return val
+        except (ValueError, TypeError):
+            sys.stderr.write(f"CADDIS_HEAVY_SLOTS: invalid value {slots!r}; defaulting to 1\n")
+            return 1
+
+    raw = os.environ.get("CADDIS_HEAVY_SLOTS")
+    if raw is None:
+        return 1
+
+    try:
+        val = int(raw.strip())
+        if val < 0:
+            sys.stderr.write(f"CADDIS_HEAVY_SLOTS: invalid value {raw!r}; defaulting to 1\n")
+            return 1
+        return val
+    except ValueError:
+        sys.stderr.write(f"CADDIS_HEAVY_SLOTS: invalid value {raw!r}; defaulting to 1\n")
+        return 1
+
+
+def _resolve_wait_s(wait_s: float | None) -> float:
+    if wait_s is not None:
+        try:
+            return max(0.0, float(wait_s))
+        except (ValueError, TypeError):
+            return 1200.0
+
+    raw = os.environ.get("CADDIS_HEAVY_WAIT_S")
+    if raw is None:
+        return 1200.0
+
+    try:
+        return max(0.0, float(raw.strip()))
+    except ValueError:
+        return 1200.0
+
+
+@contextlib.contextmanager
+def heavy_slot(
+    kind: str,
+    wait_s: float | None = None,
+    *,
+    slots: int | None = None,
+    clock: Callable[[], float] = time.monotonic,
+    sleep: Callable[[float], None] = time.sleep,
+    root: Path | str | None = None,
+) -> Iterator[None]:
+    """Acquire an OS-level byte-locked heavy execution slot.
+
+    Limits parallel test-heavy commands across processes and sessions.
+    """
+    if os.environ.get("CADDIS_HEAVY_SLOT_HELD") == "1":
+        yield
+        return
+
+    num_slots = _resolve_slots(slots)
+    if num_slots == 0:
+        yield
+        return
+
+    timeout_s = _resolve_wait_s(wait_s)
+    if root is not None:
+        slot_dir = Path(root)
+    else:
+        # Windows %TEMP% is already per user. On POSIX /tmp is shared, and the first user to create a
+        # shared folder would lock every other user out (they would see "busy" for ever), so each
+        # user gets their own folder: the limit is per account, as the guide says.
+        suffix = f"-{os.getuid()}" if hasattr(os, "getuid") else ""
+        slot_dir = Path(tempfile.gettempdir()) / f"caddis-heavy{suffix}"
+    slot_dir.mkdir(parents=True, exist_ok=True)
+
+    deadline = clock() + timeout_s
+    acquired_handle: BinaryIO | None = None
+    last_holder: str | None = None
+
+    while True:
+        holders: list[str] = []
+        for i in range(num_slots):
+            slot_file = slot_dir / f"slot-{i}"
+            flags = os.O_RDWR | os.O_CREAT | getattr(os, "O_BINARY", 0)
+            handle = None
+            try:
+                fd = os.open(slot_file, flags, 0o666)
+                handle = os.fdopen(fd, "r+b")
+                if _try_lock(handle):
+                    acquired_handle = handle
+                    break
+                else:
+                    h = _read_holder(slot_file)
+                    if h:
+                        holders.append(h)
+                    handle.close()
+                    handle = None
+            except OSError:
+                if handle is not None:
+                    try:
+                        handle.close()
+                    except OSError:
+                        pass
+                handle = None
+
+        if acquired_handle is not None:
+            break
+
+        if holders:
+            last_holder = ", ".join(holders)
+
+        now = clock()
+        remaining = deadline - now
+        if remaining <= 0:
+            raise HeavySlotBusy(last_holder)
+
+        sleep(min(2.0, remaining))
+
+    now_iso = datetime.datetime.now(datetime.timezone.utc).isoformat()
+    holder_text = f"{os.getpid()} {kind} {now_iso}"
+    payload = f"\n{holder_text}\n".encode("utf-8")
+    acquired_handle.seek(0)
+    acquired_handle.write(payload)
+    acquired_handle.truncate(len(payload))
+    acquired_handle.flush()
+
+    prev_held = os.environ.get("CADDIS_HEAVY_SLOT_HELD")
+    os.environ["CADDIS_HEAVY_SLOT_HELD"] = "1"
+
+    try:
+        yield
+    finally:
+        if prev_held is None:
+            os.environ.pop("CADDIS_HEAVY_SLOT_HELD", None)
+        else:
+            os.environ["CADDIS_HEAVY_SLOT_HELD"] = prev_held
+
+        try:
+            acquired_handle.seek(0)
+            acquired_handle.truncate(0)
+            acquired_handle.flush()
+        except OSError:
+            pass
+        finally:
+            try:
+                _unlock(acquired_handle)
+            finally:
+                try:
+                    acquired_handle.close()
+                except OSError:
+                    pass