raidlock 0.1.0__py3-none-any.whl

raidlock/runners/cli.py

@@ -0,0 +1,110 @@
+import argparse
+import os
+
+from ..core.identity import short_runtime
+
+RUNTIMES = ("codex", "claude", "gemini", "shell")
+
+
+def _setup(p):
+    p.add_argument("card", help="card id")
+    p.add_argument(
+        "--to",
+        required=True,
+        type=short_runtime,
+        choices=RUNTIMES,
+        help="which agent CLI runs the card: codex, claude, gemini (experimental) or shell; codex-cli, claude-code "
+        "and gemini-cli also work",
+    )
+    p.add_argument(
+        "--as",
+        dest="role",
+        default="worker",
+        choices=("worker", "reviewer"),
+        help="worker changes files and hands back; reviewer reads and records a verdict",
+    )
+    p.add_argument(
+        "--sandbox",
+        default=None,
+        choices=("read-only", "workspace-write"),
+        help="default: workspace-write for workers, read-only for reviewers",
+    )
+    p.add_argument("--ref", "--base", default=None, help="branch or commit to start the clone from")
+    p.add_argument("--model", default=None, help="model id passed to the CLI")
+    p.add_argument("--cmd", default=None, help="command to run for --to shell (prompt on stdin, cwd is the clone)")
+    p.add_argument(
+        "--tools", default=None, help='claude only: comma-separated allowed tools, e.g. "Read,Grep,Edit,Bash(pytest *)"'
+    )
+    p.add_argument(
+        "--unsafe-verify",
+        action="store_true",
+        help="run the card's verify command even when no sandbox is available (scrubbed env only)",
+    )
+    p.add_argument(
+        "--raw-capture",
+        action="store_true",
+        help="keep raw logs (0600) and secret-bearing rejected artifacts in a private quarantine (0700)",
+    )
+    p.add_argument(
+        "--timeout", type=float, default=3600.0, help="stop a hung worker after this many seconds (default: 3600)"
+    )
+    p.add_argument("--heartbeat", type=float, default=60.0, help=argparse.SUPPRESS)
+
+
+def _short(path):
+    home = os.path.expanduser("~")
+    return "~" + path[len(home) :] if path and path.startswith(home + os.sep) else path
+
+
+def _text(r):
+    cid = r["card"]
+    if r.get("role") == "reviewer":
+        if r.get("status") == "failed":
+            return f"{r['agent']} could not review {cid}: {r['reason']}\nNext: less {_short(r['run_dir'])}/stderr.log"
+        nxt = f"raidlock done {cid}" if r["verdict"] == "approve" else f"raidlock show {cid}"
+        return f"{r['agent']} reviewed {cid}: {r['verdict']}. {r['summary'][:200]}\nNext: {nxt}"
+    if r.get("status") == "lost":
+        return f"{r['agent']} stopped on {cid}: {r['reason']}\nNext: raidlock show {cid}"
+    if r["lane"] == "blocked":
+        return f"{r['agent']} blocked {cid}: {r['reason']}\nNext: raidlock show {cid}"
+    files = len(r["paths_changed"])
+    verify = (
+        f", verify {'passed' if r['verify']['passed'] else 'failed'}"
+        if r.get("verify")
+        else (", verify not run: no sandbox" if r.get("verify_skipped") else "")
+    )
+    patch = f" Patch: {_short(r['patch'])}" if r.get("patch") else ""
+    return f"{r['agent']} handed {cid} to review ({files} file(s) changed{verify}).{patch}\nNext: raidlock show {cid}"
+
+
+def _handler(ctx, args):
+    from .runner import delegate
+
+    board = ctx.board
+    result = delegate(
+        board,
+        ctx.caller(),
+        args.card,
+        args.to,
+        role=args.role,
+        sandbox=args.sandbox,
+        model=args.model,
+        cmd=args.cmd,
+        timeout=args.timeout,
+        heartbeat=args.heartbeat,
+        tools=args.tools,
+        unsafe_verify=args.unsafe_verify,
+        raw=args.raw_capture,
+        ref=args.ref,
+    )
+    return result, _text(result)
+
+
+def register_cli(add_command):
+    add_command(
+        "delegate",
+        "run a card with codex, claude, gemini or a shell command in its own clone",
+        _setup,
+        _handler,
+        mutating=True,
+    )

raidlock/runners/codex.py

@@ -0,0 +1,114 @@
+import os
+import re
+import shutil
+
+from ..core import Usage
+from .base import Adapter, short
+
+CONFIG_KEYS = ("model", "model_reasoning_effort")
+_LINE = re.compile(r'^\s*([A-Za-z_]+)\s*=\s*"([^"\n]*)"\s*$')
+
+
+def user_home(env):
+    return env.get("CODEX_HOME") or os.path.join(env.get("HOME") or os.path.expanduser("~"), ".codex")
+
+
+def top_level(config_text):
+    out = {}
+    for line in config_text.splitlines():
+        if line.strip().startswith("["):
+            break
+        m = _LINE.match(line)
+        if m and m.group(1) in CONFIG_KEYS:
+            out[m.group(1)] = m.group(2)
+    return out
+
+
+class Codex(Adapter):
+    name = "codex"
+    runtime = "codex-cli"
+    provider = "openai"
+    binary = "codex"
+    env_keys = ("CODEX_HOME",)
+    api_keys = ("OPENAI_API_KEY", "CODEX_API_KEY")
+
+    def prepare(self, run):
+        """An ephemeral CODEX_HOME: a link to the user's auth.json and a config.toml with only model and effort,
+        so the user's skills, rules, MCP servers and other config never reach the run."""
+        source = user_home(run.parent_env)
+        home = os.path.join(run.run_dir, "codex-home")
+        os.makedirs(home, mode=0o700, exist_ok=True)
+        auth = os.path.join(source, "auth.json")
+        if os.path.exists(auth):
+            try:
+                os.symlink(os.path.realpath(auth), os.path.join(home, "auth.json"))
+            except OSError:
+                shutil.copy2(auth, os.path.join(home, "auth.json"))
+        try:
+            with open(os.path.join(source, "config.toml"), encoding="utf-8") as f:
+                settings = top_level(f.read())
+        except OSError:
+            settings = {}
+        if run.model:
+            settings["model"] = run.model
+        with open(os.path.join(home, "config.toml"), "w", encoding="utf-8") as f:
+            f.write("".join(f'{k} = "{v}"\n' for k, v in sorted(settings.items())))
+        run.codex_config = settings
+        return {"CODEX_HOME": home}
+
+    def command(self, run):
+        argv = self.executable(run.parent_env) + [
+            "exec",
+            "-C",
+            run.clone,
+            "-s",
+            run.sandbox,
+            "--skip-git-repo-check",
+            "--ephemeral",
+            "--ignore-rules",
+            "--json",
+            "--color",
+            "never",
+            "--output-schema",
+            run.schema_path,
+            "-o",
+            run.last_path,
+        ]
+        if run.model:
+            argv += ["-m", run.model]
+        return argv + ["-"]
+
+    def parse(self, obj):
+        kind = obj.get("type", "")
+        item = obj.get("item") or {}
+        if kind == "item.completed":
+            itype = item.get("type")
+            if itype == "agent_message":
+                return [{"kind": "message", "text": item.get("text", "")}]
+            if itype == "command_execution":
+                return [
+                    {"kind": "command", "command": short(item.get("command", ""), 300), "exit": item.get("exit_code")}
+                ]
+            if itype == "file_change":
+                return [{"kind": "files", "paths": [c.get("path", "") for c in item.get("changes", [])]}]
+            if itype == "error":
+                return [{"kind": "error", "text": item.get("message", "")}]
+            return []
+        if kind == "turn.completed":
+            u = obj.get("usage") or {}
+            usage = Usage.from_codex(u)
+            usage.cache_write = int(u.get("cache_write_input_tokens", 0) or 0)
+            return [{"kind": "usage", "usage": usage}]
+        if kind == "turn.failed":
+            return [{"kind": "error", "text": (obj.get("error") or {}).get("message", "turn failed")}]
+        if kind == "error":
+            return [{"kind": "error", "text": obj.get("message", "error")}]
+        return []
+
+    def final(self, run, collected):
+        try:
+            with open(run.last_path, encoding="utf-8") as f:
+                text = f.read()
+        except OSError:
+            text = ""
+        return text.strip() or collected.final

raidlock/runners/gemini.py

@@ -0,0 +1,64 @@
+from ..core import Usage
+from .base import Adapter, short
+
+
+class Gemini(Adapter):
+    """Experimental: flags and stream-json event shapes are not verified against a real gemini binary."""
+
+    name = "gemini"
+    runtime = "gemini-cli"
+    provider = "google"
+    binary = "gemini"
+    env_keys = ("GEMINI_CONFIG_DIR", "GOOGLE_CLOUD_PROJECT", "GOOGLE_CLOUD_LOCATION", "GOOGLE_GENAI_USE_VERTEXAI")
+    api_keys = ("GEMINI_API_KEY", "GOOGLE_API_KEY")
+
+    def command(self, run):
+        mode = "auto_edit" if run.sandbox == "workspace-write" else "default"
+        argv = self.executable(run.parent_env) + [
+            "--output-format",
+            "stream-json",
+            "--approval-mode",
+            mode,
+            "-p",
+            "Follow the instructions given on stdin.",
+        ]
+        if run.model:
+            argv += ["-m", run.model]
+        return argv
+
+    def parse(self, obj):
+        kind = obj.get("type", "")
+        if kind == "init":
+            return [{"kind": "model", "model": obj.get("model", "")}]
+        if kind == "message" and obj.get("role") == "assistant" and obj.get("content"):
+            return [{"kind": "message", "text": obj["content"], "delta": bool(obj.get("delta"))}]
+        if kind == "tool_use":
+            return [
+                {
+                    "kind": "command",
+                    "command": short(f"{obj.get('tool_name', 'tool')} {obj.get('parameters', '')}", 300),
+                    "exit": None,
+                }
+            ]
+        if kind == "error":
+            return [{"kind": "error", "text": obj.get("message", "error")}]
+        if kind == "result":
+            stats = obj.get("stats") or {}
+            cached = int(stats.get("cached", 0) or 0)
+            out = [
+                {
+                    "kind": "usage",
+                    "usage": Usage(
+                        input=max(int(stats.get("input_tokens", 0) or 0) - cached, 0),
+                        cached_input=cached,
+                        output=int(stats.get("output_tokens", 0) or 0),
+                    ),
+                }
+            ]
+            if obj.get("status") not in (None, "success"):
+                out.append({"kind": "result", "error": short(obj.get("error") or obj.get("status"), 300)})
+            return out
+        return []
+
+    def final(self, run, collected):
+        return "".join(collected.messages) if collected.messages else collected.final

raidlock/runners/isolation.py

@@ -0,0 +1,391 @@
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+
+from ..core import lead
+from ..core.portable import remove_tree
+
+ENV_KEEP = ("PATH", "LANG", "LC_ALL", "LC_CTYPE", "SYSTEMROOT")
+SANDBOX_EXEC = "/usr/bin/sandbox-exec"
+TAIL_LINES = 40
+TAIL_BYTES = 4000
+HOME_SECRETS = (
+    ".ssh",
+    ".aws",
+    ".azure",
+    ".kube",
+    ".docker",
+    ".gnupg",
+    ".netrc",
+    ".git-credentials",
+    ".npmrc",
+    ".pypirc",
+    ".codex",
+    ".claude",
+    ".claude.json",
+    ".gemini",
+    ".raidlock",
+    ".config/gcloud",
+    ".config/gh",
+    ".config/raidlock",
+    ".config/git",
+    ".gitconfig",
+    "Library/Keychains",
+)
+ENV_DIRS = (
+    "RAIDLOCK_HOME",
+    "TEAM_BOARD_HOME",
+    "CODEX_HOME",
+    "CLAUDE_CONFIG_DIR",
+    "GEMINI_CONFIG_DIR",
+    "AWS_CONFIG_FILE",
+    "AWS_SHARED_CREDENTIALS_FILE",
+    "GOOGLE_APPLICATION_CREDENTIALS",
+    "KUBECONFIG",
+)
+
+
+CONTAINER_MARKERS = ("/.dockerenv", "/run/.containerenv")
+
+
+def mode(platform=None, which=shutil.which, env=None, exists=os.path.exists):
+    """The sandbox this host offers for verify: "bwrap", "bwrap-container", "sandbox-exec" or None."""
+    platform = platform or sys.platform
+    env = os.environ if env is None else env
+    sandbox = env.get("RAIDLOCK_SANDBOX", "")
+    if sandbox:
+        in_container = any(exists(m) for m in CONTAINER_MARKERS)
+        if sandbox == "container" and platform.startswith("linux") and which("bwrap") and in_container:
+            return "bwrap-container"
+        return None
+    if platform.startswith("linux"):
+        return "bwrap" if which("bwrap") else None
+    if platform == "darwin":
+        return "sandbox-exec" if os.path.exists(SANDBOX_EXEC) else None
+    return None
+
+
+def scrub_env(parent_env, home, agent=""):
+    env = {k: parent_env[k] for k in ENV_KEEP if parent_env.get(k)}
+    env.setdefault("PATH", os.defpath)
+    env.update(HOME=home, TMPDIR=home, TMP=home, TEMP=home, NO_COLOR="1", CI="1")
+    if agent:
+        env["RAIDLOCK_AGENT_ID"] = agent
+    return env
+
+
+def hidden(parent_env, extra=()):
+    """Paths the verify command must not read: the board's state, agent CLI homes and credential stores."""
+    home = parent_env.get("HOME") or os.path.expanduser("~")
+    out = [home] + [os.path.join(home, rel) for rel in HOME_SECRETS]
+    out += [parent_env[k] for k in ENV_DIRS if parent_env.get(k)]
+    out += [p for p in extra if p]
+    seen, result = set(), []
+    for p in out:
+        real = os.path.realpath(os.path.abspath(os.path.expanduser(p)))
+        if real not in seen:
+            seen.add(real)
+            result.append(real)
+    return result
+
+
+def _sb(path):
+    return '"' + path.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _ancestors(path):
+    out = []
+    cur = os.path.dirname(path)
+    while cur and cur != os.path.dirname(cur):
+        out.append(cur)
+        cur = os.path.dirname(cur)
+    return out
+
+
+def profile(writable, deny_read, readable=()):
+    writable = [os.path.realpath(p) for p in writable]
+    readable = [os.path.realpath(p) for p in readable]
+    rules = [
+        "(version 1)",
+        "(allow default)",
+        "(deny network*)",
+        "(deny process-info*)",
+        "(allow process-info* (target same-sandbox))",
+        "(deny signal)",
+        "(allow signal (target same-sandbox))",
+        "(deny mach-lookup)",
+        "(deny file-write*)",
+        "(allow file-write* "
+        + " ".join(f"(subpath {_sb(p)})" for p in writable)
+        + ' (literal "/dev/null") (literal "/dev/zero") (literal "/dev/dtracehelper")'
+        + ' (regex #"^/dev/tty") (regex #"^/dev/fd/"))',
+    ]
+    if deny_read:
+        rules.append("(deny file-read* " + " ".join(f"(subpath {_sb(p)})" for p in deny_read) + ")")
+        rules.append("(allow file-read* " + " ".join(f"(subpath {_sb(p)})" for p in writable + readable) + ")")
+        parents = sorted({a for p in writable + readable for a in _ancestors(p)})
+        if parents:
+            rules.append("(allow file-read-metadata " + " ".join(f"(literal {_sb(a)})" for a in parents) + ")")
+    return "".join(rules)
+
+
+def wrap(kind, argv, cwd, home, deny_read, readable=(), writable=()):
+    cwd, home = os.path.realpath(cwd), os.path.realpath(home)
+    readable = [os.path.realpath(p) for p in readable]
+    if kind == "sandbox-exec":
+        return [SANDBOX_EXEC, "-p", profile([cwd, home, *writable], deny_read, readable), *argv]
+    if kind in ("bwrap", "bwrap-container"):
+        proc = ["--unshare-user", "--tmpfs", "/proc"] if kind == "bwrap-container" else ["--proc", "/proc"]
+        out = [
+            "bwrap",
+            "--ro-bind",
+            "/",
+            "/",
+            "--dev",
+            "/dev",
+            *proc,
+            "--tmpfs",
+            os.path.join(os.sep, "tmp"),
+            "--tmpfs",
+            os.path.join(os.sep, "run"),
+            "--cap-drop",
+            "ALL",
+        ]
+        for p in deny_read:
+            if os.path.isdir(p):
+                out += ["--tmpfs", p]
+            elif os.path.lexists(p):
+                out += ["--ro-bind", os.devnull, p]
+        for p in readable:
+            out += ["--ro-bind", p, p]
+        out += [
+            "--bind",
+            cwd,
+            cwd,
+            "--bind",
+            home,
+            home,
+            "--chdir",
+            cwd,
+            "--unshare-net",
+            "--unshare-pid",
+            "--unshare-ipc",
+            "--unshare-uts",
+            "--die-with-parent",
+            "--new-session",
+            "--",
+            *argv,
+        ]
+        return out
+    return list(argv)
+
+
+def uv_paths(parent_env):
+    home = parent_env.get("HOME") or os.path.expanduser("~")
+    cache_home = parent_env.get("XDG_CACHE_HOME") or os.path.join(home, ".cache")
+    data_home = parent_env.get("XDG_DATA_HOME") or os.path.join(home, ".local", "share")
+    cache = parent_env.get("UV_CACHE_DIR") or os.path.join(cache_home, "uv")
+    python = parent_env.get("UV_PYTHON_INSTALL_DIR") or os.path.join(data_home, "uv", "python")
+    executable = shutil.which("uv", path=parent_env.get("PATH", os.defpath))
+    readable = [python, os.path.join(home, ".local", "bin")]
+    if executable:
+        readable.append(os.path.dirname(os.path.realpath(executable)))
+    return os.path.realpath(cache), [os.path.realpath(p) for p in readable]
+
+
+def failure_reason(code, kind):
+    if not isinstance(code, int) or code == 0:
+        return ""
+    if code == 127:
+        return (
+            "verify command not found (exit 127): install it or give its full path with "
+            'raid edit CARD --verify-cmd "..."'
+        )
+    number = -code if code < 0 else code - 128
+    try:
+        name = signal.Signals(number).name
+    except ValueError:
+        return ""
+    if kind:
+        return (
+            f"verify terminated by {name} (exit {code}); likely sandbox denial or process crash; "
+            "for uv, allow UV_CACHE_DIR and Python install paths, or rerun with --unsafe-verify"
+        )
+    return f"verify terminated by {name} (exit {code}); inspect the command output and retry"
+
+
+def _kill(proc):
+    try:
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGKILL)
+        else:
+            proc.kill()
+    except (ProcessLookupError, PermissionError, OSError):
+        pass
+
+
+CLEANUP_TIMEOUT = 1.0
+
+
+def _process_rows(home):
+    rows = {}
+    if sys.platform == "darwin":
+        import ctypes
+
+        lib = ctypes.CDLL("/usr/lib/libproc.dylib", use_errno=True)
+        lib.proc_listpids.argtypes = (ctypes.c_uint, ctypes.c_uint, ctypes.c_void_p, ctypes.c_int)
+        lib.proc_listpids.restype = ctypes.c_int
+        pids = (ctypes.c_int * 65536)()
+        count = lib.proc_listpids(1, 0, pids, ctypes.sizeof(pids))
+        buf = ctypes.create_string_buffer(1024 * 1024)
+        marker = f"HOME={home}".encode()
+        for pid in pids[: max(0, count) // ctypes.sizeof(ctypes.c_int)]:
+            try:
+                row = lead._sysctl_row(pid)
+                if not row:
+                    continue
+                group = os.getpgid(pid)
+                mib = (ctypes.c_int * 3)(lead.CTL_KERN, 49, pid)
+                size = ctypes.c_size_t(len(buf))
+                tagged = lead._libc().sysctl(mib, 3, buf, ctypes.byref(size), None, 0) == 0 and marker in buf.raw[
+                    : size.value
+                ].split(b"\0")
+                rows[pid] = (row[0], group, tagged)
+            except (OSError, ValueError):
+                continue
+    elif os.path.isdir("/proc/self"):
+        for name in os.listdir("/proc"):
+            if not name.isdigit():
+                continue
+            pid = int(name)
+            try:
+                row = lead._proc_row(pid)
+                if not row:
+                    continue
+                with open(f"/proc/{pid}/environ", "rb") as stream:
+                    tagged = f"HOME={home}".encode() in stream.read().split(b"\0")
+                rows[pid] = (row[0], os.getpgid(pid), tagged)
+            except (OSError, ValueError):
+                continue
+    return rows
+
+
+def _descendants(proc, home, known):
+    if os.name != "posix":
+        return {}
+    rows = _process_rows(home)
+    found = {proc.pid}
+    while True:
+        more = {pid for pid, (parent, group, tagged) in rows.items() if parent in found or group == proc.pid or tagged}
+        if more <= found:
+            break
+        found.update(more)
+    found.update(known)
+    lookup = lead.row_lookup()
+    live = {}
+    for pid in found - {proc.pid, os.getpid()}:
+        try:
+            row = lookup(pid)
+        except (OSError, ValueError):
+            continue
+        if row and (pid not in known or row[1] == known[pid]):
+            live[pid] = row[1]
+    return live
+
+
+def _cleanup(proc, home, known):
+    stray = _descendants(proc, home, known)
+    _kill(proc)
+    lookup = lead.row_lookup()
+    for pid, start in stray.items():
+        try:
+            row = lookup(pid)
+            if row and row[1] == start:
+                os.kill(pid, signal.SIGKILL)
+        except (OSError, ValueError):
+            pass
+    return bool(stray)
+
+
+def _tail(output):
+    return "\n".join(output.splitlines()[-TAIL_LINES:])[-TAIL_BYTES:]
+
+
+def run(cmd, cwd, parent_env, timeout, kind=None, agent="", deny_read=(), redact=None, readable=()):
+    """Run `cmd` with /bin/sh in `cwd` with a scrubbed env, a throwaway HOME and, when `kind` is set, a sandbox
+    that only writes to `cwd` and that HOME and cannot read `deny_read`, except the read-only `readable` paths.
+    Returns (exit or None, tail, ms)."""
+    home = tempfile.mkdtemp(prefix="raidlock-verify-")
+    start = time.monotonic()
+    try:
+        env = scrub_env(parent_env, home, agent)
+        writable = []
+        if kind == "sandbox-exec":
+            cache, uv_readable = uv_paths(parent_env)
+            env.update(UV_CACHE_DIR=cache, UV_PYTHON_INSTALL_DIR=uv_readable[0], UV_OFFLINE="1")
+            writable.append(cache)
+            readable = [*readable, *uv_readable]
+        if os.name == "posix":
+            shell = ["/bin/sh", "-c", cmd]
+            argv = wrap(kind, shell, cwd, home, list(deny_read), list(readable), writable) if kind else shell
+        else:
+            argv = f'"{os.environ.get("COMSPEC", "cmd.exe")}" /d /s /c "{cmd}"'
+        try:
+            proc = subprocess.Popen(
+                argv,
+                cwd=cwd,
+                env=env,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                start_new_session=os.name == "posix",
+            )
+        except OSError as e:
+            return None, f"could not start verify: {e}", int((time.monotonic() - start) * 1000)
+        known = {}
+        deadline = time.monotonic() + timeout
+        expired = False
+        out = b""
+        try:
+            while True:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    expired = True
+                    break
+                try:
+                    out, _ = proc.communicate(timeout=min(0.1, remaining))
+                    break
+                except subprocess.TimeoutExpired as exc:
+                    out = exc.output or b""
+                    known.update(_descendants(proc, home, known))
+        finally:
+            stray = _cleanup(proc, home, known)
+            try:
+                out, _ = proc.communicate(timeout=CLEANUP_TIMEOUT)
+            except subprocess.TimeoutExpired as exc:
+                stray = True
+                out = exc.output or out
+                _cleanup(proc, home, known)
+                if proc.stdout:
+                    proc.stdout.close()
+                try:
+                    proc.wait(timeout=CLEANUP_TIMEOUT)
+                except subprocess.TimeoutExpired:
+                    _kill(proc)
+        code = None if expired or stray else proc.returncode
+        text = out.decode("utf-8", "replace")
+        if expired:
+            text += f"\n[timed out after {timeout:g}s]"
+        if stray:
+            text += "\n[stray verification processes detected; receipt failed]"
+        reason = failure_reason(code, kind)
+        if reason:
+            text += "\n" + reason
+        tail = _tail(redact(text) if redact else text)
+        return code, tail, int((time.monotonic() - start) * 1000)
+    finally:
+        remove_tree(home, ignore_errors=True)