raidlock 0.1.0__py3-none-any.whl

raidlock/core/model.py

@@ -0,0 +1,126 @@
+import re
+
+from .errors import Precondition
+
+LANES = ("todo", "doing", "review", "blocked", "done", "cancelled")
+HOLD_LANES = ("doing", "review", "blocked")
+ACTIVE_LANES = ("doing", "review", "blocked")
+A2A_STATE = {
+    "todo": "submitted",
+    "doing": "working",
+    "blocked": "input-required",
+    "done": "completed",
+    "cancelled": "canceled",
+    "review": "review",
+}
+VERDICTS = ("approve", "changes", "comment")
+ROLES = ("lead", "worker", "reviewer")
+CARD_ID = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$")
+AGENT_NAME = re.compile(r"^[a-z0-9][a-z0-9-]{2,39}$")
+TEAM_NAME = re.compile(r"^[a-z0-9][a-z0-9-]{0,39}$")
+_LINE_CONTROL = re.compile(r"[\x00-\x1f\x7f-\x9f

]")
+_BLOCK_CONTROL = re.compile(r"[\x00-\x08\x0b-\x1f\x7f-\x9f

]")
+TEXT_FIELDS = ("title", "scope", "ticket", "verify", "output")
+
+
+def line_text(value, field, limit=2000):
+    """Validate a single-line text field: no control characters, bounded length."""
+    text = "" if value is None else str(value)
+    if _LINE_CONTROL.search(text):
+        raise Precondition(f"{field} must not contain control characters or newlines", field=field)
+    if len(text) > limit:
+        raise Precondition(f"{field} is longer than {limit} characters", field=field)
+    return text.strip()
+
+
+def block_text(value, field, limit=32768):
+    """Validate multi-line text: newlines and tabs allowed, other control characters rejected."""
+    text = "" if value is None else str(value)
+    if _BLOCK_CONTROL.search(text):
+        raise Precondition(f"{field} must not contain control characters", field=field)
+    if len(text.encode("utf-8")) > limit:
+        raise Precondition(f"{field} is larger than {limit} bytes", field=field, limit=limit)
+    return text
+
+
+def card_id(value):
+    if not value or not isinstance(value, str) or not CARD_ID.fullmatch(value):
+        raise Precondition(f"invalid card id {value!r}: use [a-z0-9-], max 64", id=value)
+    return value
+
+
+def slug(title):
+    value = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")
+    if len(value) > 40:
+        boundary = value.rfind("-", 0, 41)
+        value = value[:boundary] if boundary >= 0 else ""
+    return value or "card"
+
+
+def agent_name(value):
+    if not value or not isinstance(value, str) or not AGENT_NAME.fullmatch(value):
+        raise Precondition(f"invalid agent name {value!r}: use [a-z0-9-], 3-40 characters", agent=value)
+    return value
+
+
+def team_name(value):
+    if not value or not TEAM_NAME.match(value):
+        raise Precondition(f"invalid team name {value!r}: use [a-z0-9-], max 40", team=value)
+    return value
+
+
+def lane(value):
+    if value not in LANES:
+        raise Precondition(f"lane must be one of {', '.join(LANES)}", lane=value)
+    return value
+
+
+def new_card(cid, title, created, **fields):
+    card = {
+        "id": card_id(cid),
+        "title": line_text(title, "title", 300),
+        "lane": "todo",
+        "owner": "",
+        "team": fields.get("team") or "",
+        "ticket": line_text(fields.get("ticket"), "ticket", 200),
+        "scope": line_text(fields.get("scope"), "scope"),
+        "output": line_text(fields.get("output"), "output"),
+        "verify": line_text(fields.get("verify"), "verify"),
+        "verify_cmd": line_text(fields.get("verify_cmd"), "verify_cmd"),
+        "locks": list(fields.get("locks") or []),
+        "repo": fields.get("repo") or "",
+        "allow_protected": list(fields.get("allow_protected") or []),
+        "depends": list(fields.get("depends") or []),
+        "reviewers": list(fields.get("reviewers") or []),
+        "fence": 0,
+        "rev": 0,
+        "released": False,
+        "created": created,
+        "updated": created,
+        "notes": [],
+        "reviews": [],
+        "verifications": [],
+        "costs": [],
+    }
+    if not card["title"]:
+        raise Precondition("title is required")
+    return card
+
+
+def a2a_state(card):
+    if card["lane"] == "todo" and card.get("released"):
+        return "canceled"
+    return A2A_STATE[card["lane"]]
+
+
+def approvals(card):
+    latest = {}
+    for r in card.get("reviews", []):
+        if r["verdict"] != "comment":
+            latest[r["by"]] = r["verdict"]
+    return sorted(a for a, v in latest.items() if v == "approve" and a != card.get("owner"))
+
+
+def last_verification(card):
+    runs = card.get("verifications") or []
+    return runs[-1] if runs else None

raidlock/core/models.py

@@ -0,0 +1,109 @@
+import json
+import os
+import re
+
+from . import store
+
+DEFAULT_DISPLAY = {
+    "claude-opus-5-5": "Claude Opus 5.5",
+    "claude-sonnet-5-5": "Claude Sonnet 5.5",
+    "claude-haiku-5-5": "Claude Haiku 5.5",
+    "gpt-6-astra": "GPT-6 Astra",
+}
+_TOML_MODEL = re.compile(r'^\s*model\s*=\s*"([^"]+)"\s*$')
+_TOML_EFFORT = re.compile(r'^\s*model_reasoning_effort\s*=\s*"([^"]+)"\s*$')
+_VERSION = re.compile(r"(?<![0-9])(\d{1,2})(?:[-.](\d{1,2}))?(?![0-9])")
+
+
+def display_map(home):
+    path = os.path.join(home, "models.json")
+    data = store.read_json(path)
+    if data is None:
+        store.write_doc(path, "models", DEFAULT_DISPLAY)
+        return dict(DEFAULT_DISPLAY)
+    store.check_schema(data, path)
+    return {**DEFAULT_DISPLAY, **data.get("models", {})}
+
+
+def display(model, home):
+    if not model:
+        return "unknown model"
+    return display_map(home).get(model, model)
+
+
+def version(model):
+    """Best-effort version from a model id: claude-opus-5-5 -> 5.5, gpt-6-astra -> 6."""
+    m = _VERSION.search(model or "")
+    if not m:
+        return ""
+    return m.group(1) + ("." + m.group(2) if m.group(2) else "")
+
+
+def _codex_config(env):
+    base = env.get("CODEX_HOME") or os.path.join(os.path.expanduser("~"), ".codex")
+    model = effort = ""
+    try:
+        with open(os.path.join(base, "config.toml"), encoding="utf-8") as f:
+            for line in f:
+                if line.lstrip().startswith("["):
+                    break
+                m, e = _TOML_MODEL.match(line), _TOML_EFFORT.match(line)
+                model = m.group(1) if m else model
+                effort = e.group(1) if e else effort
+    except OSError:
+        pass
+    return model, effort
+
+
+def _json_model(path, *keys):
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, ValueError):
+        return ""
+    for k in keys:
+        data = data.get(k) if isinstance(data, dict) else None
+    return data if isinstance(data, str) else ""
+
+
+def _claude_config(env):
+    base = env.get("CLAUDE_CONFIG_DIR") or os.path.join(os.path.expanduser("~"), ".claude")
+    return _json_model(os.path.join(base, "settings.json"), "model")
+
+
+def _gemini_config(env):
+    base = env.get("GEMINI_CONFIG_DIR") or os.path.join(os.path.expanduser("~"), ".gemini")
+    path = os.path.join(base, "settings.json")
+    return _json_model(path, "model", "name") or _json_model(path, "model")
+
+
+def _runtime_sources(runtime, env):
+    if runtime == "codex-cli":
+        model, effort = _codex_config(env)
+        return [(model, "config", effort)]
+    if runtime == "claude-code":
+        return [(env.get("ANTHROPIC_MODEL", ""), "env", ""), (_claude_config(env), "config", "")]
+    if runtime == "gemini-cli":
+        return [(env.get("GEMINI_MODEL", ""), "env", ""), (_gemini_config(env), "config", "")]
+    return []
+
+
+def detect(runtime, declared=None, flag=None, reported=None, effort=None, env=None):
+    """Resolve an agent's model: declared, RAIDLOCK_MODEL, runner flag, runtime-reported, runtime env, runtime
+    config."""
+    env = os.environ if env is None else env
+    sources = [
+        (declared, "declared", ""),
+        (env.get("RAIDLOCK_MODEL", ""), "env", ""),
+        (flag, "flag", ""),
+        (reported, "reported", ""),
+    ] + _runtime_sources(runtime, env)
+    for model, source, found_effort in sources:
+        if model:
+            return {
+                "model": model,
+                "model_version": version(model),
+                "effort": effort or found_effort or "",
+                "model_source": source,
+            }
+    return {"model": "", "model_version": "", "effort": effort or "", "model_source": "unknown"}

raidlock/core/paths.py

@@ -0,0 +1,61 @@
+import posixpath
+import re
+import unicodedata
+
+from .errors import Precondition
+
+_DRIVE = re.compile(r"^[A-Za-z]:")
+_CONTROL = re.compile(r"[\x00-\x1f\x7f-\x9f

]")
+
+
+def canonical(raw, casefold=False):
+    """Return the canonical form of a lock path or raise Precondition."""
+    if not isinstance(raw, str):
+        raise Precondition("lock path must be text", path=repr(raw))
+    text = unicodedata.normalize("NFC", raw.strip())
+    if not text:
+        raise Precondition("empty lock path", path=raw)
+    if _CONTROL.search(text):
+        raise Precondition("control character in lock path", path=raw)
+    text = text.replace("\\", "/")
+    if text.startswith("/") or text.startswith("~") or _DRIVE.match(text):
+        raise Precondition(f"lock path must be relative to the workspace: {raw}", path=raw)
+    if ".." in text.split("/"):
+        raise Precondition(f"lock path must not contain '..': {raw}", path=raw)
+    text = posixpath.normpath(text).strip("/")
+    if text in ("", "."):
+        raise Precondition(f"lock path resolves to the workspace root: {raw}", path=raw)
+    return text.casefold() if casefold else text
+
+
+def split(text):
+    return [p for p in text.split("/") if p]
+
+
+def parse_list(value):
+    if value is None:
+        return []
+    items = value if isinstance(value, (list, tuple)) else re.split(r"[,\s]+", value)
+    out = []
+    for item in items:
+        if item and item.strip():
+            p = canonical(item)
+            if p not in out:
+                out.append(p)
+    return out
+
+
+def _parts(path, fold):
+    parts = split(path)
+    return [p.casefold() for p in parts] if fold else parts
+
+
+def contains(outer, inner, casefold=False):
+    """True when `inner` equals `outer` or lies under it on a `/` boundary."""
+    a, b = _parts(outer, casefold), _parts(inner, casefold)
+    return len(a) <= len(b) and b[: len(a)] == a
+
+
+def overlaps(a, b, casefold=False):
+    """True when one path contains the other."""
+    return contains(a, b, casefold) or contains(b, a, casefold)

raidlock/core/portable.py

@@ -0,0 +1,53 @@
+import errno
+import os
+import shutil
+import stat
+import sys
+
+NOFOLLOW = getattr(os, "O_NOFOLLOW", 0)
+NONBLOCK = getattr(os, "O_NONBLOCK", 0)
+BINARY = getattr(os, "O_BINARY", 0)
+
+
+def _redirected(path):
+    junction = getattr(os.path, "isjunction", None)
+    return os.path.islink(path) or bool(junction and junction(path))
+
+
+def open_nofollow(path, flags, mode=0o600):
+    """Open a path without following a final symlink, with an lstat check where O_NOFOLLOW is missing."""
+    if NOFOLLOW:
+        return os.open(path, flags | NOFOLLOW | BINARY, mode)
+    if _redirected(path):
+        raise OSError(errno.ELOOP, "refusing to follow a symlink", path)
+    fd = os.open(path, flags | BINARY, mode)
+    try:
+        opened = os.fstat(fd)
+        named = os.lstat(path)
+        if _redirected(path) or (opened.st_dev, opened.st_ino) != (named.st_dev, named.st_ino):
+            raise OSError(errno.ELOOP, "refusing to follow a symlink", path)
+    except BaseException:
+        os.close(fd)
+        raise
+    return fd
+
+
+def _writable_retry(function, path, exc):
+    if isinstance(exc, tuple):
+        exc = exc[1]
+    if os.path.islink(path) or not isinstance(exc, PermissionError):
+        raise exc
+    os.chmod(path, stat.S_IWRITE | stat.S_IREAD)
+    function(path)
+
+
+def remove_tree(path, ignore_errors=False):
+    """shutil.rmtree that also removes read-only files, such as git objects on Windows."""
+    try:
+        if sys.version_info >= (3, 12):
+            shutil.rmtree(path, onexc=_writable_retry)
+        else:
+            shutil.rmtree(path, onerror=_writable_retry)
+    except OSError:
+        if not ignore_errors:
+            raise

raidlock/core/receipts.py

@@ -0,0 +1,73 @@
+import hashlib
+import hmac
+import json
+import os
+import secrets
+import stat
+
+from .errors import Precondition
+from .portable import BINARY, NONBLOCK, open_nofollow
+
+
+def command_hash(command):
+    return hashlib.sha256(command.encode()).hexdigest()
+
+
+def _key(board, create=False):
+    from .identity import token_path
+
+    path = os.path.join(os.path.dirname(token_path(board.home, board.uid, board.lead)), "verify.key")
+    if os.path.commonpath((os.path.realpath(path), os.path.realpath(board.workspace))) == os.path.realpath(
+        board.workspace
+    ):
+        raise Precondition("verification key must live outside the workspace; move RAIDLOCK_HOME")
+    if create:
+        os.makedirs(os.path.dirname(path), mode=0o700, exist_ok=True)
+    try:
+        if create:
+            try:
+                fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | BINARY, 0o600)
+            except FileExistsError:
+                pass
+            else:
+                with os.fdopen(fd, "wb") as stream:
+                    stream.write(secrets.token_bytes(32))
+        if os.path.islink(path):
+            raise OSError("symlink")
+        fd = open_nofollow(path, os.O_RDONLY | NONBLOCK)
+        with os.fdopen(fd, "rb") as stream:
+            info = os.fstat(stream.fileno())
+            if (
+                not stat.S_ISREG(info.st_mode)
+                or info.st_nlink != 1
+                or (os.name == "posix" and stat.S_IMODE(info.st_mode) != 0o600)
+            ):
+                raise OSError("not a private regular file")
+            key = stream.read(33)
+        if len(key) != 32:
+            raise OSError("invalid key")
+        return key
+    except OSError as exc:
+        raise Precondition("missing or unsafe board verification key") from exc
+
+
+def _payload(receipt):
+    return json.dumps(
+        {k: v for k, v in receipt.items() if k != "signature"}, sort_keys=True, separators=(",", ":"), allow_nan=False
+    ).encode()
+
+
+def sign(board, receipt):
+    return {**receipt, "signature": hmac.new(_key(board, create=True), _payload(receipt), hashlib.sha256).hexdigest()}
+
+
+def valid(board, card, receipt):
+    try:
+        if receipt.get("card") != card["id"] or receipt.get("board") != board.uid:
+            return False
+        if receipt.get("command_hash") != command_hash(card.get("verify_cmd", "")):
+            return False
+        expected = hmac.new(_key(board), _payload(receipt), hashlib.sha256).hexdigest()
+        return hmac.compare_digest(expected, receipt.get("signature", ""))
+    except (Precondition, TypeError, ValueError, AttributeError):
+        return False

raidlock/core/registry.py

@@ -0,0 +1,39 @@
+import os
+
+
+def home():
+    """Global raidlock home: $RAIDLOCK_HOME or ~/.raidlock."""
+    return os.path.abspath(os.environ.get("RAIDLOCK_HOME") or os.path.join(os.path.expanduser("~"), ".raidlock"))
+
+
+_SYNC = (
+    ("/library/mobile documents/", "iCloud"),
+    ("/icloud drive/", "iCloud"),
+    ("/dropbox/", "Dropbox"),
+    ("/onedrive", "OneDrive"),
+    ("/google drive/", "Google Drive"),
+    ("/googledrive/", "Google Drive"),
+    ("/my drive/", "Google Drive"),
+    ("/library/cloudstorage/", "a cloud storage provider"),
+)
+
+
+def synced_folder(folder):
+    """Name of the sync provider when `folder` sits in a cloud-synced location, else ''."""
+    real = (os.path.realpath(folder).replace("\\", "/") + "/").lower()
+    return next((name for marker, name in _SYNC if marker in real), "")
+
+
+def register(index, uid, board_dir):
+    """Add or refresh a board in the global registry (raidlock.db); returns its workspace name."""
+    stem = os.path.basename(os.path.dirname(os.path.realpath(board_dir))) or "board"
+    return index.register(uid, board_dir, stem)
+
+
+def workspaces(index):
+    """Registered workspaces: [{uid, name, board, last_seen, version}]."""
+    return index.workspaces()
+
+
+def remove(index, names):
+    return index.unregister(names)