raidlock 0.1.0__py3-none-any.whl

raidlock/runners/base.py

@@ -0,0 +1,341 @@
+import json
+import os
+import re
+import shlex
+import signal
+import subprocess
+import threading
+import time
+
+from ..core import Usage
+from ..core.portable import open_nofollow
+from ..core.transcript import REDACTED, redact
+
+BASE_ENV = (
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "TERM",
+    "TMPDIR",
+    "TEMP",
+    "TMP",
+    "SYSTEMROOT",
+    "COMSPEC",
+    "PATHEXT",
+    "APPDATA",
+    "LOCALAPPDATA",
+    "USERPROFILE",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "NODE_EXTRA_CA_CERTS",
+    "REQUESTS_CA_BUNDLE",
+    "HTTPS_PROXY",
+    "HTTP_PROXY",
+    "NO_PROXY",
+    "https_proxy",
+    "http_proxy",
+    "no_proxy",
+)
+SUMMARY_CAP = 500
+SECRET_NAME = re.compile(r"(?i)(token|secret|password|passwd|api[_-]?key|access[_-]?key|credential|session[_-]?key)")
+MIN_SECRET = 8
+
+
+class Redactor:
+    """Masks the given literal secrets, then the common key and token patterns, in strings and JSON values."""
+
+    def __init__(self, secrets=()):
+        self.secrets = sorted(
+            {s for s in secrets if isinstance(s, str) and len(s.strip()) >= MIN_SECRET}, key=len, reverse=True
+        )
+
+    @classmethod
+    def for_env(cls, env, extra=()):
+        values = [v for k, v in (env or {}).items() if SECRET_NAME.search(k)]
+        return cls(list(values) + list(extra))
+
+    def text(self, value):
+        if not isinstance(value, str) or not value:
+            return value
+        for secret in self.secrets:
+            value = value.replace(secret, REDACTED)
+        return redact(value)
+
+    def stream(self, mask=True):
+        """A separate PEM-block state for each output stream."""
+        private = False
+
+        def clean(line):
+            nonlocal private
+            begin = re.search(r"-----BEGIN [A-Z ]*PRIVATE KEY-----", line)
+            end = re.search(r"-----END [A-Z ]*PRIVATE KEY-----", line)
+            if private:
+                if end:
+                    private = False
+                    return REDACTED + self.text(line[end.end() :])
+                return REDACTED + ("\n" if line.endswith("\n") else "")
+            if begin and not end:
+                private = True
+            return self.text(line) if mask or begin else line
+
+        return clean
+
+    def __call__(self, value):
+        if isinstance(value, str):
+            return self.text(value)
+        if isinstance(value, list):
+            return [self(v) for v in value]
+        if isinstance(value, tuple):
+            return tuple(self(v) for v in value)
+        if isinstance(value, dict):
+            return {
+                self(k) if isinstance(k, str) else k: REDACTED
+                if isinstance(k, str) and SECRET_NAME.search(k) and isinstance(v, str)
+                else self(v)
+                for k, v in value.items()
+            }
+        return value
+
+
+class Adapter:
+    """One external runtime. Subclasses set the identity fields and implement `command` and `parse`."""
+
+    prompt_stdin = True
+    name = ""
+    runtime = ""
+    provider = ""
+    binary = ""
+    env_keys = ()
+    api_keys = ()
+    sandboxes = ("read-only", "workspace-write")
+
+    def executable(self, env=None):
+        env = os.environ if env is None else env
+        override = env.get(f"RAIDLOCK_{self.name.upper()}_BIN", "")
+        return shlex.split(override) if override else [self.binary]
+
+    def child_env(self, env=None):
+        env = os.environ if env is None else env
+        keep = BASE_ENV + tuple(self.env_keys) + tuple(self.api_keys)
+        out = {k: env[k] for k in keep if k in env}
+        out.update(NO_COLOR="1", CI="1")
+        return out
+
+    def prepare(self, run):
+        return {}
+
+    def command(self, run):
+        raise NotImplementedError
+
+    def parse(self, obj):
+        return []
+
+    def final(self, run, collected):
+        return collected.structured if collected.structured is not None else collected.final
+
+
+def short(text, limit=SUMMARY_CAP):
+    text = " ".join(str(text or "").split())
+    return text if len(text) <= limit else text[: limit - 3] + "..."
+
+
+class Collector:
+    """Accumulates normalized events of one run."""
+
+    def __init__(self):
+        self.messages = []
+        self.commands = []
+        self.usage = Usage()
+        self.usd = None
+        self.final = ""
+        self.structured = None
+        self.error = ""
+        self.model = ""
+        self.billing = ""
+        self.files = []
+        self.events = 0
+
+    def add(self, event):
+        kind = event.get("kind")
+        self.events += 1
+        if kind == "message" and event.get("text"):
+            self.messages.append(event["text"])
+            self.final = event["text"]
+        elif kind == "command":
+            self.commands.append({"command": event.get("command", ""), "exit": event.get("exit")})
+        elif kind == "usage":
+            u = event.get("usage") or Usage()
+            self.usage = Usage(**{k: getattr(self.usage, k) + getattr(u, k) for k in self.usage.as_dict()})
+            if event.get("usd") is not None:
+                self.usd = (self.usd or 0.0) + float(event["usd"])
+        elif kind == "result":
+            if event.get("text"):
+                self.final = event["text"]
+            if event.get("structured") is not None:
+                self.structured = event["structured"]
+            if event.get("error"):
+                self.error = event["error"]
+        elif kind == "error":
+            self.error = event.get("text") or "error"
+        elif kind == "model":
+            self.model = event.get("model") or self.model
+            self.billing = event.get("billing") or self.billing
+        elif kind == "files":
+            self.files.extend(event.get("paths", []))
+
+    def summary(self):
+        return {
+            "messages": len(self.messages),
+            "commands": len(self.commands),
+            "usage": self.usage.as_dict(),
+            "usd": self.usd,
+            "model": self.model,
+            "error": self.error,
+            "events": self.events,
+        }
+
+
+def decode(line):
+    text = line.rstrip("\r\n")
+    if not text.strip():
+        return None
+    try:
+        obj = json.loads(text)
+    except ValueError:
+        return {"type": "raw", "text": text}
+    return obj if isinstance(obj, dict) else {"type": "raw", "text": text}
+
+
+class Process:
+    """Runs one adapter command: prompt on stdin, redacted events to disk, parsed events to `on_event`."""
+
+    def __init__(self, argv, cwd, env, prompt, events_path, stderr_path, timeout, redactor=None, raw=False):
+        self.argv, self.cwd, self.env, self.prompt = argv, cwd, env, prompt
+        self.events_path, self.stderr_path, self.timeout = events_path, stderr_path, timeout
+        self.redactor = redactor or Redactor()
+        self.raw = raw
+        self.proc = None
+        self.killed = ""
+        self._lock = threading.Lock()
+
+    def stop(self, reason):
+        with self._lock:
+            if self.killed or self.proc is None or self.proc.poll() is not None:
+                return
+            self.killed = reason
+            _terminate(self.proc)
+
+    def _raw_path(self, path):
+        root, ext = os.path.splitext(path)
+        return root + ".raw" + ext
+
+    def _open_raw(self, path, mode):
+        if not self.raw:
+            return None
+        fd = open_nofollow(
+            self._raw_path(path), os.O_WRONLY | os.O_CREAT | (os.O_APPEND if mode == "a" else os.O_TRUNC), 0o600
+        )
+        return os.fdopen(fd, mode, encoding="utf-8")
+
+    def _drain_stderr(self, stream, err, raw):
+        clean = self.redactor.stream()
+        for line in stream:
+            err.write(clean(line))
+            err.flush()
+            if raw:
+                raw.write(line)
+                raw.flush()
+
+    def run(self, adapter, on_event):
+        posix = os.name == "posix"
+        raw_events = self._open_raw(self.events_path, "a")
+        raw_err = self._open_raw(self.stderr_path, "w")
+        try:
+            return self._run(adapter, on_event, posix, raw_events, raw_err)
+        finally:
+            for f in (raw_events, raw_err):
+                if f:
+                    f.close()
+
+    def _run(self, adapter, on_event, posix, raw_events, raw_err):
+        with (
+            open(self.events_path, "a", encoding="utf-8") as events,
+            open(self.stderr_path, "w", encoding="utf-8") as err,
+        ):
+            try:
+                self.proc = subprocess.Popen(
+                    self.argv,
+                    cwd=self.cwd,
+                    env=self.env,
+                    stdin=subprocess.PIPE if adapter.prompt_stdin else subprocess.DEVNULL,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    encoding="utf-8",
+                    errors="replace",
+                    start_new_session=posix,
+                )
+            except OSError as e:
+                return None, f"could not start {self.argv[0]}: {e}"
+            drain = threading.Thread(target=self._drain_stderr, args=(self.proc.stderr, err, raw_err), daemon=True)
+            drain.start()
+            timer = threading.Timer(self.timeout, self.stop, args=(f"timed out after {self.timeout:g}s",))
+            timer.daemon = True
+            timer.start()
+            try:
+                try:
+                    if adapter.prompt_stdin:
+                        self.proc.stdin.write(self.prompt)
+                        self.proc.stdin.close()
+                except (BrokenPipeError, OSError):
+                    pass
+                clean = self.redactor.stream(mask=False)
+                for line in self.proc.stdout:
+                    obj = decode(line)
+                    if obj is None:
+                        continue
+                    if raw_events:
+                        raw_events.write(json.dumps(obj, ensure_ascii=False) + "\n")
+                        raw_events.flush()
+                    normalized = decode(clean(line))
+                    if normalized is None:
+                        continue
+                    obj = self.redactor(normalized)
+                    events.write(json.dumps(obj, ensure_ascii=False) + "\n")
+                    events.flush()
+                    for event in adapter.parse(normalized):
+                        on_event(self.redactor(event))
+                code = self.proc.wait(timeout=self.timeout)
+            except BaseException:
+                self.stop("interrupted")
+                raise
+            finally:
+                timer.cancel()
+                drain.join(timeout=10)
+        return code, self.killed
+
+
+def _terminate(proc):
+    try:
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGTERM)
+        else:
+            proc.terminate()
+    except (ProcessLookupError, PermissionError, OSError):
+        return
+    deadline = time.monotonic() + 5
+    while proc.poll() is None and time.monotonic() < deadline:
+        time.sleep(0.05)
+    if proc.poll() is None:
+        try:
+            if os.name == "posix":
+                os.killpg(proc.pid, signal.SIGKILL)
+            else:
+                proc.kill()
+        except (ProcessLookupError, PermissionError, OSError):
+            pass

raidlock/runners/brief.py

@@ -0,0 +1,176 @@
+import json
+import re
+
+from ..core import redact
+from ..core.brief import UNTRUSTED_HEADER, UNTRUSTED_RULE, quote_data
+from ..lore.inject import HEADER as LORE_HEADER
+
+HANDBACK_CAP = 4096
+ITEM_CAP = 400
+LIST_CAP = 20
+STATUSES = ("done", "partial", "blocked")
+VERDICTS = ("approve", "changes", "comment")
+
+WORKER_CONTRACT = """# Worker contract (raidlock)
+
+You are a worker agent. The raidlock runner delegated one card to you.
+The current directory is a private clone of the repository. Nobody else works in it.
+
+- Change only files under the allowed paths listed at the end. Lock paths in the card are workspace paths;
+  the allowed paths are the same locks relative to this clone. A change anywhere else fails the run.
+- Never touch .github/workflows/, .claude/, .board/, *.pem, .env* or anything named secrets.
+- Do not commit, push, merge, apply infrastructure, change settings or permissions, or read secrets.
+  The runner collects your uncommitted changes as a patch and does all board work (notes, moves) for you.
+- Assume there is no network. Do not install packages. The runner runs the card's verify command after you finish.
+- Keep the final answer short: cite paths and commands, never paste file contents.
+- End with only the handback JSON object:
+  {"status": "done|partial|blocked", "evidence": ["..."], "paths_changed": ["..."], "open_questions": ["..."]}
+"""
+
+REVIEWER_CONTRACT = """# Reviewer contract (raidlock)
+
+You are a reviewer agent. The current directory is a private, read-only clone of the repository.
+The changes under review are the difference between {base} and HEAD: run `git diff {base} HEAD` and read the files.
+
+- Do not change files. Do not commit, push, merge, or read secrets.
+- Check correctness first, then the card's acceptance criteria, then risk.
+- Keep the final answer short: cite paths and lines, never paste file contents.
+- End with only the review JSON object:
+  {{"verdict": "approve|changes|comment", "summary": "...", "findings": ["path:line problem"]}}
+"""
+
+HANDBACK_SCHEMA = {
+    "type": "object",
+    "additionalProperties": False,
+    "required": ["status", "evidence", "paths_changed", "open_questions"],
+    "properties": {
+        "status": {"type": "string", "enum": list(STATUSES)},
+        "evidence": {"type": "array", "items": {"type": "string"}},
+        "paths_changed": {"type": "array", "items": {"type": "string"}},
+        "open_questions": {"type": "array", "items": {"type": "string"}},
+    },
+}
+
+REVIEW_SCHEMA = {
+    "type": "object",
+    "additionalProperties": False,
+    "required": ["verdict", "summary", "findings"],
+    "properties": {
+        "verdict": {"type": "string", "enum": list(VERDICTS)},
+        "summary": {"type": "string"},
+        "findings": {"type": "array", "items": {"type": "string"}},
+    },
+}
+
+
+def schema(role):
+    return REVIEW_SCHEMA if role == "reviewer" else HANDBACK_SCHEMA
+
+
+def render(card_brief, role, rels, base):
+    """Prompt text: the stable contract first (cacheable), then the core card brief without its board-command loop
+    (the runner does the board work), then the allowed paths as they appear inside the clone."""
+    contract = REVIEWER_CONTRACT.format(base=base) if role == "reviewer" else WORKER_CONTRACT
+    allowed = ", ".join(r or "(the whole repository)" for r in rels)
+    return redact(contract + "\n" + _quoted_brief(card_brief) + "\nAllowed paths in this clone: " + allowed + "\n")
+
+
+def _quoted_brief(text):
+    return (
+        UNTRUSTED_HEADER
+        + "\n"
+        + UNTRUSTED_RULE
+        + "\n"
+        + "\n".join(quote_data(line) for line in _without_loop(text).splitlines())
+        + "\n"
+    )
+
+
+def _without_loop(text):
+    out, skip = [], False
+    for line in text.splitlines():
+        if line.startswith("## ") or line == LORE_HEADER:
+            skip = line.strip() == "## Loop"
+        if not skip:
+            out.append(line)
+    return "\n".join(out).rstrip() + "\n"
+
+
+def _clip(text, limit):
+    text = " ".join(str(text).split())
+    return text if len(text) <= limit else text[: limit - 3] + "..."
+
+
+def find_json(text):
+    """The last JSON object in `text` (whole text first, then fenced or brace-delimited candidates)."""
+    if isinstance(text, dict):
+        return text
+    if not text:
+        return None
+    text = text.strip()
+    try:
+        value = json.loads(text)
+        return value if isinstance(value, dict) else None
+    except ValueError:
+        pass
+    for match in reversed(list(re.finditer(r"\{", text))):
+        try:
+            value, _ = json.JSONDecoder().raw_decode(text[match.start() :])
+        except ValueError:
+            continue
+        if isinstance(value, dict):
+            return value
+    return None
+
+
+def _strings(value):
+    if not isinstance(value, list):
+        value = [value] if value else []
+    return [_clip(redact(str(v)), ITEM_CAP) for v in value if str(v).strip()][:LIST_CAP]
+
+
+def handback(raw, fallback_text=""):
+    """Normalize an agent handback to {status, evidence[], paths_changed[], open_questions[]}."""
+    data = find_json(raw) or {}
+    status = data.get("status") if data.get("status") in STATUSES else ""
+    out = {
+        "status": status or "partial",
+        "evidence": _strings(data.get("evidence")),
+        "paths_changed": _strings(data.get("paths_changed")),
+        "open_questions": _strings(data.get("open_questions")),
+    }
+    if not data and fallback_text:
+        out["evidence"] = [_clip(redact(fallback_text), ITEM_CAP)]
+        out["open_questions"] = ["the agent returned no handback JSON"]
+    return out
+
+
+def review(raw, fallback_text=""):
+    """Normalize a review to {verdict, summary, findings[]}; anything unparseable is a comment."""
+    data = find_json(raw) or {}
+    verdict = data.get("verdict") if data.get("verdict") in VERDICTS else "comment"
+    summary = data.get("summary") or (fallback_text if not data else "") or "no summary"
+    return {
+        "verdict": verdict,
+        "summary": _clip(redact(str(summary)), 1500),
+        "findings": _strings(data.get("findings")),
+    }
+
+
+def cap(obj, limit=HANDBACK_CAP):
+    """Trim list items (longest lists first) until the JSON encoding fits in `limit` bytes."""
+    obj = json.loads(json.dumps(obj))
+    while len(json.dumps(obj, ensure_ascii=False).encode("utf-8")) > limit:
+        lists = [(len(v), k) for k, v in obj.items() if isinstance(v, list) and v]
+        if not lists:
+            for k, v in obj.items():
+                if isinstance(v, str) and len(v) > 200:
+                    obj[k] = v[: len(v) // 2] + "..."
+                    break
+            else:
+                break
+            continue
+        _, key = max(lists)
+        obj[key].pop()
+        obj.setdefault("truncated", True)
+    return obj

raidlock/runners/claude_code.py

@@ -0,0 +1,121 @@
+import json
+import re
+
+from ..core import Usage
+from ..core.errors import Precondition
+from .base import Adapter, short
+
+READ_TOOLS = (
+    "Read",
+    "Grep",
+    "Glob",
+    "Bash(git diff *)",
+    "Bash(git log *)",
+    "Bash(git show *)",
+    "Bash(git status *)",
+    "Bash(ls *)",
+)
+WRITE_TOOLS = READ_TOOLS + ("Edit(./**)", "Write(./**)", "NotebookEdit(./**)")
+READ_NAMES = ("Read", "Grep", "Glob", "WebSearch", "WebFetch", "TodoWrite", "Bash")
+WRITE_NAMES = ("Edit", "Write", "NotebookEdit")
+_RULE = re.compile(r"^([A-Za-z]+)(?:\(([A-Za-z0-9 ._/*:@=+-]+)\))?$")
+
+
+class ClaudeCode(Adapter):
+    name = "claude"
+    runtime = "claude-code"
+    provider = "anthropic"
+    binary = "claude"
+    env_keys = ("CLAUDE_CONFIG_DIR",)
+    api_keys = ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN")
+
+    def tools(self, sandbox, override=None):
+        if override:
+            return tuple(override)
+        return WRITE_TOOLS if sandbox == "workspace-write" else READ_TOOLS
+
+    def check_tools(self, value, sandbox):
+        """Validate a --tools override: known tool names, optional plain rule specs, Bash only with a command
+        prefix, write tools only in a workspace-write sandbox."""
+        items = [t.strip() for t in (value.split(",") if isinstance(value, str) else value) if t.strip()]
+        if not items:
+            raise Precondition("--tools is empty")
+        for item in items:
+            m = _RULE.match(item)
+            name = m.group(1) if m else ""
+            if name not in READ_NAMES + WRITE_NAMES:
+                raise Precondition(
+                    f"--tools: {item!r} is not an allowed tool rule; allowed tools: "
+                    + ", ".join(READ_NAMES + WRITE_NAMES),
+                    tool=item,
+                )
+            if name == "Bash" and not m.group(2):
+                raise Precondition("--tools: Bash needs a command prefix, e.g. Bash(pytest *)", tool=item)
+            if name in WRITE_NAMES and sandbox != "workspace-write":
+                raise Precondition(f"--tools: {name} needs --sandbox workspace-write", tool=item)
+        return items
+
+    def command(self, run):
+        argv = self.executable(run.parent_env) + [
+            "-p",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--permission-mode",
+            "dontAsk",
+            "--safe-mode",
+            "--no-session-persistence",
+            "--setting-sources",
+            "",
+            "--strict-mcp-config",
+            "--allowedTools",
+            ",".join(self.tools(run.sandbox, getattr(run, "tools", None))),
+            "--json-schema",
+            json.dumps(run.schema, separators=(",", ":")),
+        ]
+        if run.model:
+            argv += ["--model", run.model]
+        return argv
+
+    def parse(self, obj):
+        kind = obj.get("type", "")
+        if kind == "system" and obj.get("subtype") == "init":
+            source = obj.get("apiKeySource")
+            billing = "" if source is None else ("plan" if source == "none" else "api")
+            return [{"kind": "model", "model": obj.get("model", ""), "billing": billing}]
+        if kind == "assistant":
+            out = []
+            for block in (obj.get("message") or {}).get("content") or []:
+                if block.get("type") == "text" and block.get("text"):
+                    out.append({"kind": "message", "text": block["text"]})
+                elif block.get("type") == "tool_use" and block.get("name") != "StructuredOutput":
+                    out.append({"kind": "command", "command": _tool(block), "exit": None})
+            return out
+        if kind == "result":
+            usage = {
+                "kind": "usage",
+                "usage": Usage.from_anthropic(obj.get("usage") or {}),
+                "usd": obj.get("total_cost_usd"),
+            }
+            error = ""
+            if obj.get("is_error") or (obj.get("subtype") and obj.get("subtype") != "success"):
+                error = short(obj.get("result") or obj.get("subtype") or "error", 300)
+            return [
+                usage,
+                {
+                    "kind": "result",
+                    "text": obj.get("result") or "",
+                    "structured": obj.get("structured_output"),
+                    "error": error,
+                },
+            ]
+        return []
+
+    def final(self, run, collected):
+        return collected.structured if collected.structured is not None else collected.final
+
+
+def _tool(block):
+    data = block.get("input") or {}
+    detail = data.get("command") or data.get("file_path") or data.get("pattern") or data.get("path") or ""
+    return short(f"{block.get('name', 'tool')} {detail}".strip(), 300)