keywright 0.0.1__py3-none-any.whl

keywright/hook.py

@@ -0,0 +1,161 @@
+"""Claude Code hooks, stdlib only.
+
+PreToolUse on Bash: the hazard tripwire over the whole line, with one refinement for lines that
+invoke `kw` itself. The part of a `kw run/put/get/capture` line that is the remote payload is
+the server's to judge (it is flagged there, prompted or refused there), so here it only earns a
+note. Everything local on the same line (other segments, substitutions, redirections, `get -o`
+destinations) is enforced as usual. And `kw setup|login|logout|session-start` always asks,
+whatever options precede the subcommand: an agent must not rewrite its own gate.
+"""
+
+from __future__ import annotations
+
+import json
+import shlex
+from typing import Any
+
+from .hazards import Hazard, blocks, describe, scan_command, scan_path, worst
+
+CLI_NAMES = {"kw", "keywright"}
+GUARDED = {"setup", "login", "logout", "session-start"}
+REMOTE_COMMAND = {"run", "capture"}
+GLOBAL_VALUE_OPTS = {"--profile", "-p"}
+_SEPARATORS = {";", "|", "||", "&&", "&", "(", ")"}
+
+
+def _tokens(command: str) -> list[str] | None:
+    try:
+        lex = shlex.shlex(command, posix=True, punctuation_chars=";|&()<>")
+        lex.whitespace_split = True
+        return list(lex)
+    except ValueError:
+        return None
+
+
+def _segments(tokens: list[str]) -> list[list[str]]:
+    segs: list[list[str]] = [[]]
+    for tok in tokens:
+        if tok in _SEPARATORS:
+            if segs[-1]:
+                segs.append([])
+        else:
+            segs[-1].append(tok)
+    return [s for s in segs if s]
+
+
+def parse_invocation(words: list[str]) -> dict[str, Any] | None:
+    """For a segment that invokes kw: {sub, host, remote, local_writes, local_reads}. None otherwise."""
+    if not words or words[0].rsplit("/", 1)[-1] not in CLI_NAMES:
+        return None
+    i = 1
+    while i < len(words) and words[i].startswith("-"):
+        if words[i] in GLOBAL_VALUE_OPTS and "=" not in words[i]:
+            i += 2
+        else:
+            i += 1
+    if i >= len(words):
+        return {"sub": None, "remote": [], "local_writes": [], "local_reads": []}
+    sub, rest = words[i], words[i + 1:]
+    out: dict[str, Any] = {"sub": sub, "remote": [], "local_writes": [], "local_reads": []}
+    if sub in REMOTE_COMMAND:
+        if "--" in rest:
+            k = rest.index("--")
+            out["remote"].append(shlex.join(rest[k + 1:]))
+            rest = rest[:k]
+        for j, w in enumerate(rest):
+            if w in ("-c", "--command") and j + 1 < len(rest):
+                out["remote"].append(rest[j + 1])
+            if w.startswith(("-c=", "--command=")):
+                out["remote"].append(w.split("=", 1)[1])
+    positional = [w for w in rest if not w.startswith("-")]
+    if sub == "put" and len(positional) >= 2:
+        out["remote_write"] = positional[1]
+        for j, w in enumerate(rest):
+            if w in ("--file", "-f") and j + 1 < len(rest):
+                out["local_reads"].append(rest[j + 1])
+    if sub == "get":
+        if len(positional) >= 2:
+            out["remote_read"] = positional[1]
+        for j, w in enumerate(rest):
+            if w in ("-o", "--output") and j + 1 < len(rest):
+                out["local_writes"].append(rest[j + 1])
+    return out
+
+
+def analyze(command: str) -> tuple[list[Hazard], list[Hazard], bool]:
+    """(local hazards, server-gated hazards, guarded-subcommand present)."""
+    tokens = _tokens(command)
+    if tokens is None:
+        return scan_command(command), [], False
+    segments = _segments(tokens)
+    if not any(s[0].rsplit("/", 1)[-1] in CLI_NAMES for s in segments):
+        return scan_command(command), [], False
+    local_parts: list[str] = []
+    remote: list[Hazard] = []
+    local_extra: list[Hazard] = []
+    guarded = False
+    for seg in segments:
+        inv = parse_invocation(seg)
+        if inv is None:
+            local_parts.append(shlex.join(seg))
+            continue
+        if inv["sub"] in GUARDED:
+            guarded = True
+        for r in inv["remote"]:
+            remote.extend(scan_command(r))
+        if inv.get("remote_write"):
+            remote.extend(scan_path(inv["remote_write"], "write"))
+        if inv.get("remote_read"):
+            remote.extend(scan_path(inv["remote_read"], "read"))
+        for p in inv["local_writes"]:
+            local_extra.extend(scan_path(p, "write"))
+        for p in inv["local_reads"]:
+            local_extra.extend(scan_path(p, "read"))
+        # the invocation minus its payload still takes part in the local scan (cd, pipes around it)
+        local_parts.append(shlex.join([w for w in seg if w not in inv["remote"]]).split(" -- ")[0])
+    local = scan_command(" ; ".join(local_parts)) + [h for h in local_extra if h not in local_extra[:0]]
+    seen: list[Hazard] = []
+    for h in local:
+        if h not in seen:
+            seen.append(h)
+    return seen, remote, guarded
+
+
+def pre_tool_use(payload: dict[str, Any]) -> dict[str, Any] | None:
+    if payload.get("tool_name") != "Bash":
+        return None
+    command = str((payload.get("tool_input") or {}).get("command") or "")
+    if not command.strip():
+        return None
+    local, remote, guarded = analyze(command)
+    notes = []
+    if local:
+        notes.append("local " + describe(local))
+    if remote:
+        notes.append("server-gated " + describe(remote))
+    text = "Keywright hazard check: " + "; ".join(notes) if notes else ""
+    if guarded:
+        reason = "kw setup/login/logout change the agent's own gate; the human runs them."
+        return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "permissionDecision": "ask",
+                                       "permissionDecisionReason": reason},
+                "systemMessage": reason + (" " + text if text else "")}
+    level = worst(local)
+    if level is None:
+        return {"systemMessage": text} if text else None
+    if not blocks(level):
+        return {"systemMessage": text}
+    decision = "deny" if level == "critical" else "ask"
+    reason = text + (". Refused: if this must happen, the user runs it by hand." if level == "critical"
+                     else ". Flagged as destructive; an existing allow rule does not cover it.")
+    return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "permissionDecision": decision,
+                                   "permissionDecisionReason": reason},
+            "systemMessage": text}
+
+
+def run_pre_tool_use(stdin_text: str) -> str:
+    try:
+        payload = json.loads(stdin_text)
+    except ValueError:
+        return ""
+    out = pre_tool_use(payload) if isinstance(payload, dict) else None
+    return json.dumps(out) if out else ""

keywright/patterns.py

@@ -0,0 +1,153 @@
+"""Permission paths and glob patterns.
+
+Paths are slash-separated:  ssh/<host>/exec/<bin>[/<sub>...]   mcp/<server>/tools/<tool>
+                            llm/<gateway>/model/<model>
+
+Pattern rules:
+  *   matches exactly one segment
+  **  matches zero or more segments (only meaningful as the last segment)
+  a pattern without wildcards also matches any path it is a segment-prefix of,
+  so granting `ssh/nvr/exec/docker` covers `ssh/nvr/exec/docker/ps`.
+  a segment may end in * to match a prefix: `entity_id=light.*` matches `entity_id=light.kitchen`.
+
+MCP calls are qualified by argument values when the resource names argument keys:
+  mcp/<server>/tools/<tool>/<key>=<value>   one path per configured key present in the call
+so `mcp/ha/tools/call_service` (a literal prefix) still covers every call, while a deny on
+`mcp/ha/tools/call_service/service=automation.turn_off` blocks only that service.
+"""
+
+from __future__ import annotations
+
+import re
+
+PATTERN_HELP = (
+    "Pattern syntax: slash-separated segments, ssh/<host>/exec/<command>[/<sub>], "
+    "mcp/<server>/tools/<tool>[/<key>=<value>] or llm/<gateway>/model/<model>. `*` alone matches one whole segment; `**` matches "
+    "everything below and must be last; a segment may END in `*` to match a prefix (tools/ha_get_*, "
+    "entity_id=light.*) but `*` cannot appear elsewhere in a segment. A literal pattern also covers "
+    "everything under it. Allowed characters: letters, digits and _ . : @ + = , - (no spaces). Each pattern "
+    "must name one concrete resource: the first two segments cannot be wildcards."
+)
+
+KINDS = ("ssh", "mcp", "llm")
+
+_SEGMENT = re.compile(r"^[A-Za-z0-9_.:@+=,-]+\*?$|^\*$|^\*\*$")
+_VALUE_CHARS = re.compile(r"[^A-Za-z0-9_.:@+=,-]")
+
+
+def validate(pattern: str) -> str:
+    pattern = pattern.strip().strip("/")
+    if not pattern:
+        raise ValueError("empty pattern")
+    parts = pattern.split("/")
+    for i, seg in enumerate(parts):
+        if not _SEGMENT.match(seg):
+            raise ValueError(f"invalid segment {seg!r} in {pattern!r}")
+        if seg == "**" and i != len(parts) - 1:
+            raise ValueError("** is only allowed as the last segment")
+    if parts[0] not in KINDS and parts[0] not in ("*", "**"):
+        raise ValueError("pattern must start with ssh/, mcp/ or llm/")
+    return pattern
+
+
+def matches(pattern: str, path: str) -> bool:
+    p = pattern.strip("/").split("/")
+    t = path.strip("/").split("/")
+    if p and p[-1] == "**":
+        head = p[:-1]
+        return len(t) >= len(head) and all(_seg(a, b) for a, b in zip(head, t, strict=False))
+    if len(t) == len(p):
+        return all(_seg(a, b) for a, b in zip(p, t, strict=True))
+    # implicit prefix rule for literal (and value-glob) patterns
+    if len(t) > len(p) and not any(s in ("*", "**") for s in p):
+        return all(_seg(a, b) for a, b in zip(p, t, strict=False))
+    return False
+
+
+def _seg(pat: str, seg: str) -> bool:
+    if pat == "*" or pat == seg:
+        return True
+    return pat.endswith("*") and len(pat) > 1 and seg.startswith(pat[:-1])
+
+
+def _is_glob(seg: str) -> bool:
+    return seg.endswith("*") and len(seg) > 1 and seg != "**"
+
+
+def _seg_covers(allowed: str, required: str) -> bool:
+    """Every concrete segment matched by `required` is matched by `allowed`."""
+    if allowed == "*" or allowed == required:
+        return True
+    if _is_glob(allowed):
+        base = allowed[:-1]
+        return required.startswith(base) if not _is_glob(required) else required[:-1].startswith(base)
+    return False
+
+
+def _seg_overlaps(a: str, b: str) -> bool:
+    if a == "*" or b == "*" or a == b:
+        return True
+    pa, pb = (a[:-1] if _is_glob(a) else None), (b[:-1] if _is_glob(b) else None)
+    if pa is not None and pb is not None:
+        return pa.startswith(pb) or pb.startswith(pa)
+    if pa is not None:
+        return b.startswith(pa)
+    if pb is not None:
+        return a.startswith(pb)
+    return False
+
+
+def qualifier(key: str, value: object) -> str:
+    """`key=value` segment for an MCP argument. Characters outside the segment alphabet become `_`,
+    so a value can never smuggle a wildcard or a path separator into a required path."""
+    text = _VALUE_CHARS.sub("_", str(value))[:120] or "_"
+    return f"{key}={text}"
+
+
+def resource_of(path: str) -> tuple[str, str] | None:
+    """('ssh', 'nvr') for 'ssh/nvr/exec/ls'. None if the path is too short."""
+    parts = path.strip("/").split("/")
+    if len(parts) < 2 or parts[0] not in KINDS:
+        return None
+    return parts[0], parts[1]
+
+
+def model_segment(model: str) -> str:
+    """The path segment for an LLM model name. Provider prefixes such as `openrouter/anthropic/x`
+    contain slashes, which are path separators here, so every character outside the segment
+    alphabet becomes `_`: `llm/<gateway>/model/openrouter_anthropic_x`."""
+    return _VALUE_CHARS.sub("_", model)[:120] or "_"
+
+
+def specificity(pattern: str) -> int:
+    """Higher = more specific. Used to prefer narrow grants when several match."""
+    parts = pattern.strip("/").split("/")
+    score = 0
+    for s in parts:
+        score += 0 if s == "**" else 1 if s == "*" else 2 if _is_glob(s) else 3
+    return score
+
+
+def _shape(pattern: str) -> tuple[list[str], bool]:
+    parts = pattern.strip("/").split("/")
+    if parts[-1] == "**":
+        return parts[:-1], True
+    return parts, not any(p == "*" for p in parts)
+
+
+def overlaps(left: str, right: str) -> bool:
+    """Whether two scopes share any concrete path (including implicit literal prefixes)."""
+    a, a_tail = _shape(left)
+    b, b_tail = _shape(right)
+    if (len(a) < len(b) and not a_tail) or (len(b) < len(a) and not b_tail):
+        return False
+    return all(_seg_overlaps(x, y) for x, y in zip(a, b, strict=False))
+
+
+def covers(allowed: str, required: str) -> bool:
+    """Whether the entire required scope is contained in the allowed scope."""
+    a, a_tail = _shape(allowed)
+    b, b_tail = _shape(required)
+    if len(a) > len(b) or (not a_tail and (b_tail or len(a) != len(b))):
+        return False
+    return all(_seg_covers(x, y) for x, y in zip(a, b, strict=False))

keywright/session.py

@@ -0,0 +1,144 @@
+"""Which conversation this call belongs to.
+
+The server scopes "This session" approvals to whatever the client names in X-Keywright-Session,
+and Claude Code's stateless MCP transport names nothing. The CLI names it, in this order:
+
+1. KW_SESSION in the environment: automation can set `job:<id>`, Claude Code gets
+   `claude:<session_id>` from the SessionStart hook (`kw session-start --hook`) through
+   CLAUDE_ENV_FILE. This is the preferred path because it is per conversation.
+2. CODEX_THREAD_ID when supplied by Codex: a conversation identity that survives hidden
+   process ancestry in a sandbox. Only a bounded, header-safe value is accepted.
+3. A per-agent-process fallback: a file named by the nearest non-shell ancestor's
+   (pid, start time, boot id), created with O_EXCL and holding a random id. PID reuse cannot
+   revive an old identity because the start time differs; stale files are swept on every run.
+4. None: the server then offers no "This session" scope, as before the CLI existed.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import secrets
+import sys
+from pathlib import Path
+
+SHELLS = {"bash", "sh", "zsh", "dash", "fish", "ksh", "sudo", "env", "timeout", "nohup", "script", "python3",
+          "python"}
+AGENT_HINTS = {"claude": "claude", "codex": "codex", "cephloom": "cephloom"}
+MAX_LEN = 128
+
+
+def runtime_dir() -> Path:
+    base = os.environ.get("XDG_RUNTIME_DIR")
+    if base and os.access(base, os.W_OK):
+        return Path(base) / "keywright"
+    return Path(os.environ.get("XDG_CACHE_HOME") or str(Path.home() / ".cache")) / "keywright" / "run"
+
+
+def resolve() -> tuple[str | None, str]:
+    """(session value or None, how it was found)."""
+    env = os.environ.get("KW_SESSION")
+    if env:
+        return env[:MAX_LEN], "KW_SESSION"
+    thread = os.environ.get("CODEX_THREAD_ID", "")
+    if re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,121}", thread):
+        return f"codex:{thread}", "CODEX_THREAD_ID"
+    if not sys.platform.startswith("linux"):
+        return None, "none (no /proc on this platform)"
+    anchor = _agent_ancestor()
+    if anchor is None:
+        return None, "none (no agent process found above this shell)"
+    pid, start, kind = anchor
+    try:
+        value = _per_process(pid, start, kind)
+    except OSError as e:
+        return None, f"none ({e})"
+    return value, f"process {pid} ({kind})"
+
+
+def _proc_field(pid: int) -> tuple[int, str, str] | None:
+    """(ppid, comm, starttime) from /proc/<pid>/stat, or None when the process is gone."""
+    try:
+        stat = Path(f"/proc/{pid}/stat").read_text()
+    except OSError:
+        return None
+    # comm may contain spaces; it is bracketed
+    comm = stat[stat.index("(") + 1:stat.rindex(")")]
+    rest = stat[stat.rindex(")") + 2:].split()
+    return int(rest[1]), comm, rest[19]
+
+
+def _cmdline(pid: int) -> str:
+    try:
+        return Path(f"/proc/{pid}/cmdline").read_bytes().replace(b"\0", b" ").decode(errors="replace")
+    except OSError:
+        return ""
+
+
+def _agent_ancestor() -> tuple[int, str, str] | None:
+    pid = os.getppid()
+    for _ in range(64):
+        if pid <= 1:
+            return None
+        info = _proc_field(pid)
+        if info is None:
+            return None
+        ppid, comm, start = info
+        if comm not in SHELLS:
+            line = _cmdline(pid).lower()
+            kind = next((k for k, needle in AGENT_HINTS.items() if needle in comm.lower() or needle in line), "shell")
+            return pid, start, kind
+        pid = ppid
+    return None
+
+
+def _boot_id() -> str:
+    try:
+        return Path("/proc/sys/kernel/random/boot_id").read_text().strip()[:8]
+    except OSError:
+        return "noboot"
+
+
+def _per_process(pid: int, start: str, kind: str) -> str:
+    d = runtime_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    os.chmod(d, 0o700)
+    _sweep(d)
+    path = d / f"{pid}-{start}-{_boot_id()}"
+    try:
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+    except FileExistsError:
+        return path.read_text().strip()
+    value = f"{kind}:{secrets.token_urlsafe(12)}"
+    with os.fdopen(fd, "w") as f:
+        f.write(value)
+    return value
+
+
+def _sweep(d: Path) -> None:
+    boot = _boot_id()
+    for f in d.iterdir():
+        parts = f.name.split("-")
+        if len(parts) != 3:
+            continue
+        pid, start, b = parts
+        info = _proc_field(int(pid)) if pid.isdigit() else None
+        if b != boot or info is None or info[2] != start:
+            try:
+                f.unlink()
+            except OSError:
+                pass
+
+
+def session_start_hook(payload: dict) -> str | None:
+    """Claude Code SessionStart hook: persist the conversation id for later Bash calls.
+    Returns the line written, or None when there was nowhere to write it."""
+    sid = str(payload.get("session_id") or "").strip()
+    target = os.environ.get("CLAUDE_ENV_FILE")
+    if not sid or not target:
+        return None
+    safe = "".join(c for c in sid if c.isalnum() or c in "-_.")[:MAX_LEN - 7]
+    line = f"export KW_SESSION=claude:{safe}\n"
+    with open(target, "a") as f:
+        f.write(line)
+    return line.strip()

keywright/setup/__init__.py

@@ -0,0 +1,2 @@
+"""`kw setup ...`: owns the agent-machine side of Keywright (hooks, permission rules, skill, MCP
+registration) with read-merge-write edits, backups, idempotence and --dry-run."""

keywright/setup/check.py

@@ -0,0 +1,115 @@
+"""`kw setup check`: the doctor. Every line is a fact with a verdict; nonzero exit on any failure."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+
+from .. import __version__, config, session
+from .claude_code import LEGACY_HOOK_FILE, mcp_registrations, skill_version
+from .codex import BEGIN, END, codex_home
+from .common import binary_path, claude_dir, find_hooks, read_json
+
+
+def _line(ok: bool | None, what: str, detail: str = "") -> tuple[bool | None, str]:
+    mark = {True: "ok  ", False: "FAIL", None: "info"}[ok]
+    return ok, f"{mark}  {what}" + (f": {detail}" if detail else "")
+
+
+def integration_checks() -> list[tuple[bool | None, str]]:
+    """Check integrations present on this machine, including Codex-only installs."""
+    lines = []
+    home = claude_dir()
+    kw = binary_path()
+    has_claude = home.exists() or shutil.which("claude") is not None
+    codex_dir = codex_home()
+    has_codex = codex_dir.exists() or shutil.which("codex") is not None
+    if has_claude:
+        settings = read_json(home / "settings.json")
+        hooks = find_hooks(settings)
+        if hooks:
+            stale = [h for h in hooks if kw not in h and "gatekeeper-hazards.py" in h]
+            lines.append(_line(not stale, "claude code hooks", "; ".join(hooks)))
+            if stale:
+                lines.append(_line(False, "legacy hook", "points at a copied file; run `kw setup claude-code`"))
+        else:
+            lines.append(_line(False, "claude code hooks", "none; run `kw setup claude-code`"))
+        if (home / LEGACY_HOOK_FILE).exists():
+            lines.append(_line(False, "legacy hook file", f"{home / LEGACY_HOOK_FILE} still present"))
+        sv = skill_version(home / "skills" / "keywright" / "SKILL.md")
+        lines.append(_line(sv == __version__, "claude code skill", sv or "not installed"))
+    else:
+        lines.append(_line(None, "claude code", "not installed; skipped"))
+    if has_codex:
+        # Match Codex's global instruction-file precedence.
+        candidates = [codex_dir / "AGENTS.override.md", codex_dir / "AGENTS.md"]
+        active = next((p for p in candidates if p.is_file() and p.read_text().strip()), None)
+        text = active.read_text() if active else ""
+        installed = BEGIN in text and END in text and text.index(BEGIN) < text.index(END)
+        detail = str(active) if installed else "Keywright instructions missing from the active global file; run `kw setup codex`"
+        lines.append(_line(installed, "codex instructions", detail))
+    if not has_claude and not has_codex:
+        lines.append(_line(False, "agent integration", "none; run `kw setup codex` or `kw setup claude-code`"))
+    regs = mcp_registrations() if has_claude else []
+    lines.append(_line(None, "mcp registrations", ", ".join(regs) if regs else "none (CLI only)"))
+    return lines
+
+
+def run(*, profile_name: str | None = None, out=None) -> int:
+    out = out or sys.stdout
+    lines: list[tuple[bool | None, str]] = []
+    lines.append(_line(None, "client", f"keywright {__version__} at {binary_path()}"))
+
+    profile = None
+    try:
+        profile = config.load(profile_name)
+        lines.append(_line(True, "profile", f"{profile.name} -> {profile.mcp_url}"))
+    except config.ConfigError as e:
+        lines.append(_line(False, "profile", str(e)))
+    mode = config.file_mode_ok()
+    if mode is not None:
+        lines.append(_line(mode, "config file mode", "0600" if mode else f"{config.config_file()} is readable by others"))
+
+    if profile:
+        base = profile.mcp_url[: -len("/mcp")]
+        try:
+            with urllib.request.urlopen(base + "/healthz", timeout=10) as r:
+                health = json.loads(r.read().decode())
+            lines.append(_line(bool(health.get("ok")), "server", f"{base} version {health.get('version', '?')} "
+                                                              f"notifier {health.get('notifier', '?')}"))
+            sv = str(health.get("version") or "")
+            if sv and sv.split(".")[:2] != __version__.split(".")[:2]:
+                lines.append(_line(False, "version match", f"server {sv} vs client {__version__}"))
+        except (urllib.error.URLError, ValueError, OSError) as e:
+            lines.append(_line(False, "server", f"{base}/healthz unreachable ({e})"))
+        try:
+            from ..transport import AuthError, TransportError, call, payload
+
+            listing = payload(call(profile, None, "access_list_resources", {}, read_timeout=20))
+            lines.append(_line(True, "token", f"agent {listing.get('agent')} sees {len(listing.get('resources', []))} resource(s)"))
+        except AuthError:
+            lines.append(_line(False, "token", "rejected (401); run `kw login` with a current token"))
+        except TransportError as e:
+            lines.append(_line(False, "token", f"could not call the server ({e})"))
+
+    value, source = session.resolve()
+    lines.append(_line(None, "session", f"{value or 'none'} ({source})"))
+
+    lines.extend(integration_checks())
+    for tool in ("claude", "codex"):
+        path = shutil.which(tool)
+        if path:
+            try:
+                ver = subprocess.run([tool, "--version"], capture_output=True, text=True, timeout=10, check=False).stdout.strip()
+            except (OSError, subprocess.TimeoutExpired):
+                ver = "?"
+            lines.append(_line(None, tool, ver.splitlines()[0] if ver else path))
+
+    failed = any(ok is False for ok, _ in lines)
+    for _, text in lines:
+        out.write(text + "\n")
+    return 1 if failed else 0