craftkit 0.3.0__py3-none-any.whl

craft_kit/home.py

@@ -0,0 +1,370 @@
+"""The home screen: `craft` on its own. The title, past creations to browse with the arrow keys,
+and a new project in a few questions. Actions run in the normal terminal, then come back here."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+from typing import Callable, Optional
+
+from . import __version__, banner, proc, tables
+from .ui import UI
+from .workspace import CraftError, Project, forget, parse_target, projects_dir, read_json, remembered, slug, STATE
+
+ALT_ON, ALT_OFF = "\033[?1049h", "\033[?1049l"
+DESCRIPTION = [
+    ("Study", "looks at the original: screenshots, what it prints, its files (Deep mode)"),
+    ("Build", "your agent (Claude Code, Codex, Gemini) writes a new version in app/"),
+    ("Check", "compares it with the original and measures what differs"),
+    ("Refine", "sends the differences back until every check passes"),
+]
+HIDE, SHOW = "\033[?25l", "\033[?25h"
+CLEAR = "\033[H\033[2J"
+
+
+# --- keys -----------------------------------------------------------------------------------------
+
+def read_key() -> str:
+    """One key press: up, down, enter, esc, backspace, or the character itself."""
+    if os.name == "nt":
+        import msvcrt  # type: ignore
+
+        ch = msvcrt.getwch()
+        if ch in ("\x00", "\xe0"):
+            return {"H": "up", "P": "down", "K": "left", "M": "right"}.get(msvcrt.getwch(), "")
+        if ch == "\x03":
+            raise KeyboardInterrupt
+        return {"\r": "enter", "\x1b": "esc", "\x08": "backspace"}.get(ch, ch)
+    import select
+    import termios
+    import tty
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        ch = os.read(fd, 1)
+        if ch == b"\x1b":
+            seq = b""
+            while len(seq) < 2 and select.select([fd], [], [], 0.04)[0]:
+                seq += os.read(fd, 1)
+            return {b"[A": "up", b"[B": "down", b"[C": "right", b"[D": "left", b"OA": "up", b"OB": "down"}.get(seq, "esc")
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    if ch == b"\x03":
+        raise KeyboardInterrupt
+    if ch in (b"\r", b"\n"):
+        return "enter"
+    if ch in (b"\x7f", b"\x08"):
+        return "backspace"
+    return ch.decode("utf-8", "replace")
+
+
+# --- what a project looks like in the list -------------------------------------------------------
+
+def ago(iso: str) -> str:
+    try:
+        t = time.mktime(time.strptime(iso, "%Y-%m-%dT%H:%M:%S"))
+    except (ValueError, OverflowError):
+        return ""
+    s = max(0, int(time.time() - t))
+    for unit, size in (("d", 86400), ("h", 3600), ("min", 60)):
+        if s >= size:
+            return f"{s // size} {unit} ago"
+    return "just now"
+
+
+def summary(path: str) -> dict:
+    state = read_json(Path(path) / STATE)
+    if not isinstance(state, dict):
+        return {"path": path, "name": Path(path).name, "missing": True}
+    steps = state.get("steps") or {}
+    if steps.get("ready") == "done":
+        badge = ("done", "ready")
+    elif steps.get("ready") == "failed":
+        badge = ("fail", "not yet")
+    elif steps.get("build") == "waiting":
+        badge = ("wait", "question")
+    elif steps.get("build") in ("running", "paused", "done"):
+        badge = ("run", "building")
+    elif steps.get("study") == "done":
+        badge = ("run", "studied")
+    else:
+        badge = ("todo", "new")
+    return {
+        "path": path,
+        "name": str(state.get("name") or Path(path).name),
+        "request": str(state.get("request", "")),
+        "kind": str(state.get("kind", "")),
+        "stack": str(state.get("stack", "")),
+        "badge": badge,
+        "missing": False,
+    }
+
+
+def nearby() -> list[str]:
+    """Projects in the current folder and the projects folder that the list doesn't know yet."""
+    found = []
+    for base in {Path.cwd(), projects_dir()}:
+        try:
+            for child in base.iterdir():
+                if (child / STATE).is_file():
+                    found.append(str(child.resolve()))
+        except OSError:
+            continue
+    if (Path.cwd() / STATE).is_file():
+        found.append(str(Path.cwd().resolve()))
+    return found
+
+
+# --- the screen -------------------------------------------------------------------------------------
+
+class Home:
+    def __init__(self, ui: UI, loop: Callable, show_status: Callable):
+        self.ui = ui
+        self.loop = loop  # cli.loop(project, ui, message, agent)
+        self.show_status = show_status
+        self.out = ui.out
+
+    def w(self, text: str) -> None:
+        self.out.write(text)
+        self.out.flush()
+
+    def line(self, text: str = "") -> None:
+        self.w(text + "\n")
+
+    def title(self, describe: bool = False) -> None:
+        self.w(CLEAR)
+        self.line()
+        for row in banner.render(self.ui.width(), self.ui.fancy):
+            self.line(row)
+        self.line("  " + (banner.gradient(f"study → build → check → refine · v{__version__}") if self.ui.fancy else f"study → build → check → refine · v{__version__}"))
+        self.line()
+        if describe:
+            self.describe()
+
+    def describe(self) -> None:
+        """What the tool does, in a few lines, on the home screen."""
+        ui = self.ui
+        rows = shutil.get_terminal_size((80, 24)).lines
+        if rows < 30 or ui.width() < 70:  # a small window keeps one line, so the list stays visible
+            self.line(ui.dim("  Rebuilds any software with your coding agent, checked against the original."))
+            self.line()
+            return
+        self.line("  Recreate a website, CLI, app or game, or build a new one, with your coding agent,")
+        self.line("  and prove the result with real checks. Four steps, run for you:")
+        self.line()
+        for i, (name, text) in enumerate(DESCRIPTION):
+            label = f"{i + 1} {name:<7}"
+            if ui.fancy:
+                label = f"\033[3m\033[1m{banner.fg(banner.colour_at(0.1 + i * 0.22))}{label}\033[0m"
+            self.line(f"    {label} {ui.dim(text)}")
+        self.line()
+
+    def menu(self, draw_top: Callable[[], None], items: list[str], footer: str, start: int = 0, keys: str = "") -> tuple[str, int]:
+        """Draw a list and let the person move through it. Returns (key, index): key is "enter",
+        "esc", or one of `keys`."""
+        i = min(max(0, start), max(0, len(items) - 1))
+        while True:
+            draw_top()
+            rows = shutil.get_terminal_size((80, 24)).lines
+            room = max(3, rows - (22 if rows >= 30 else 15))
+            first = min(max(0, i - room // 2), max(0, len(items) - room))
+            if first > 0:
+                self.line(self.ui.dim("    ↑ more"))
+            for k in range(first, min(len(items), first + room)):
+                if k == i:
+                    self.line("  " + banner.gradient("›", italic=False, bold=True) + " " + self.ui.bold(items[k]) if self.ui.fancy else f"  > {items[k]}")
+                else:
+                    self.line(f"    {items[k]}")
+            if first + room < len(items):
+                self.line(self.ui.dim("    ↓ more"))
+            self.line()
+            self.line(self.ui.dim(f"  {footer}"))
+            key = read_key()
+            if key in ("up", "k") and items:
+                i = (i - 1) % len(items)
+            elif key in ("down", "j") and items:
+                i = (i + 1) % len(items)
+            elif key in ("enter", "right") and items:
+                return "enter", i
+            elif key in ("esc", "q", "left"):
+                return "esc", i
+            elif key and key in keys:
+                return key, i
+
+    # actions run in the normal screen, so their output stays in the terminal's history
+    def outside(self, action: Callable[[], object]) -> None:
+        self.w(ALT_OFF + SHOW)
+        pause = True
+        try:
+            pause = action() is not False
+        except CraftError as e:
+            self.ui.error(e.message)
+            if e.fix:
+                self.ui.say(f"   {self.ui.dim(e.fix)}")
+        except KeyboardInterrupt:
+            self.ui.say(f"\n   {self.ui.dim('stopped')}")
+        if pause:
+            self.ui.say("")
+            self.ui.ask(self.ui.dim("press Enter to go back"))
+        self.w(ALT_ON + HIDE)
+
+    def run(self) -> int:
+        self.w(ALT_ON + HIDE)
+        try:
+            self.projects()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.w(ALT_OFF + SHOW)
+        return 0
+
+    def projects(self) -> None:
+        known = [i["path"] for i in remembered()]
+        for path in nearby():
+            if path not in known:
+                known.append(path)
+        sel = 0
+        while True:
+            entries = [summary(p) for p in known]
+            opened = {i["path"]: i.get("opened", "") for i in remembered()}
+            width = self.ui.width()
+            labels = [self.ui.c("33", "+ New project")]
+            for e in entries:
+                if e["missing"]:
+                    labels.append(self.ui.dim(f"{e['name'][:28]:<28}  folder not found"))
+                    continue
+                icon, code = {"done": ("✓", "32"), "fail": ("✗", "31"), "wait": ("?", "33"), "run": ("●", "36"), "todo": ("○", "2")}[e["badge"][0]]
+                meta = f"{e['kind']} · {e['stack']}"
+                label = f"{e['name'][:28]:<28}  {self.ui.c(code, icon)} {e['badge'][1]:<9} {self.ui.dim(f'{meta[:26]:<26}')}"
+                when = ago(opened.get(e["path"], ""))
+                if when and width >= 90:
+                    label += "  " + self.ui.dim(when)
+                labels.append(label)
+
+            def top() -> None:
+                self.title(describe=True)
+                self.line(self.ui.bold("  Your creations") + self.ui.dim(f"  ({len(entries)})") if entries else self.ui.bold("  Nothing made yet: start with a new project"))
+                self.line()
+
+            key, sel = self.menu(top, labels, "↑↓ move · ⏎ open · n new · x remove from list · q quit", sel, keys="nx")
+            if key == "esc":
+                return
+            if key == "n" or (key == "enter" and sel == 0):
+                made = self.new_project()
+                if made:
+                    known = [made, *[k for k in known if k != made]]
+                    sel = 1
+                    self.project(made)
+                continue
+            if sel == 0:
+                continue
+            entry = entries[sel - 1]
+            if key == "x":
+                forget(entry["path"])
+                known.remove(entry["path"])
+                sel = max(0, sel - 1)
+            elif key == "enter" and not entry["missing"]:
+                self.project(entry["path"])
+
+    def project(self, path: str) -> None:
+        sel = 0
+        while True:
+            try:
+                p = Project.open(Path(path))
+            except CraftError:
+                return
+            actions = []
+            if p.pending_questions():
+                actions.append(("answer", "Answer the builder's questions"))
+            ready = p.state["steps"].get("ready") == "done"
+            actions.append(("run", "Continue building" if not ready else "Build again"))
+            actions += [("change", "Ask for a change…"), ("open", "Open the result"), ("check", "Check it again"), ("folder", "Show the folder"), ("back", "Back")]
+
+            def top() -> None:
+                self.title()
+                self.show_status(p, self.ui)
+                self.line()
+
+            key, sel = self.menu(top, [a[1] for a in actions], "↑↓ move · ⏎ choose · q back", sel)
+            if key == "esc" or actions[sel][0] == "back":
+                return
+            self.act(p, actions[sel][0])
+
+    def act(self, p: Project, what: str) -> None:
+        from . import cli  # the same commands the CLI runs
+
+        ui = self.ui
+        if what == "run":
+            self.outside(lambda: (cli.show_header(p, ui), self.loop(p, ui, None, None)))
+        elif what == "change":
+            def change() -> None:
+                msg = ui.ask("What should change?")
+                if msg:
+                    cli.show_header(p, ui)
+                    self.loop(p, ui, msg, None)
+            self.outside(change)
+        elif what == "answer":
+            self.outside(lambda: cli.ask_questions(p, ui))
+        elif what == "check":
+            self.outside(lambda: (cli.show_header(p, ui), cli.do_check(p, ui)))
+        elif what == "open":
+            self.outside(lambda: cli.open_result(p, ui))
+        elif what == "folder":
+            opener = {"darwin": ["open"], "win32": ["explorer"]}.get(sys.platform, ["xdg-open"])
+            r = proc.run([*opener, str(p.root)], timeout=15)
+            if not r.ok and sys.platform != "win32":  # explorer exits 1 even when it worked
+                self.outside(lambda: ui.say(f"   {p.root}"))
+
+    def new_project(self) -> Optional[str]:
+        """A few questions in the normal screen, then the project is made in the projects folder."""
+        result: dict = {}
+
+        def ask() -> bool:
+            ui = self.ui
+            self.w(CLEAR)
+            for row in banner.render(ui.width(), ui.fancy):
+                ui.say(row)
+            ui.say("")
+            ui.say(ui.bold("  New project") + ui.dim(f"  (in {projects_dir()}, empty answer to cancel)"))
+            ui.say("")
+            request = ui.ask("What do you want to make?")
+            if not request:
+                return False
+            while True:
+                raw = ui.ask("Something to recreate? web address, file, folder or command (Enter for none):")
+                try:
+                    target = parse_target(raw)
+                    break
+                except CraftError as e:
+                    ui.error(e.message)
+                    ui.say(f"   {ui.dim(e.fix)}")
+            deep = ui.choose("Mode?", ["Clean room: only what a visitor or user sees", "Deep: look inside the original (private use)"]).startswith("Deep")
+            allow_run = False
+            if target["type"] == "local" and os.access(target["value"], os.X_OK) and Path(target["value"]).is_file():
+                allow_run = ui.ask("Run it to record what it prints? [y/N]").lower() in ("y", "yes", "o", "oui")
+            folder = projects_dir() / slug(request)
+            n = 2
+            while folder.exists():
+                folder = projects_dir() / f"{slug(request)}-{n}"
+                n += 1
+            kind = tables.detect_kind(request, target["type"])
+            stack = tables.detect_stack(request)["name"]
+            p = Project.create(folder, target, request, kind, stack, deep, allow_run)
+            ui.step("done", "new", f"{folder}  ·  {kind} · {stack} · {p.mode()}")
+            result["path"] = str(folder)
+            if ui.choose("Start building now?", ["Yes, start", "Later"]).startswith("Yes"):
+                ui.say("")
+                from . import cli
+
+                cli.show_header(p, ui)
+                self.loop(p, ui, None, None)
+                return True
+            return False
+
+        self.outside(ask)
+        return result.get("path")

craft_kit/png.py

@@ -0,0 +1,135 @@
+"""Comparing screenshots without dependencies: a small PNG reader (8-bit, non-interlaced, the kind
+browsers write) and a grid similarity. Uses Pillow instead when it's installed."""
+
+from __future__ import annotations
+
+import struct
+import zlib
+from pathlib import Path
+from typing import Optional
+
+MAX_ROWS = 2400  # compare the top of long pages; enough for the layout, quick in pure Python
+COLS = 64
+TOLERANCE = 32  # a cell matches when no channel differs by more than this
+
+
+class Grid:
+    def __init__(self, width: int, height: int, cells: list[list[tuple[int, int, int]]]):
+        self.width, self.height, self.cells = width, height, cells
+
+    def blank(self) -> bool:
+        first = self.cells[0][0] if self.cells and self.cells[0] else None
+        return all(c == first for row in self.cells for c in row)
+
+
+def _paeth(a: int, b: int, c: int) -> int:
+    p = a + b - c
+    pa, pb, pc = abs(p - a), abs(p - b), abs(p - c)
+    return a if pa <= pb and pa <= pc else (b if pb <= pc else c)
+
+
+def _grid_pure(path: Path) -> Optional[Grid]:
+    data = path.read_bytes()
+    if data[:8] != b"\x89PNG\r\n\x1a\n":
+        return None
+    pos, idat, palette = 8, [], b""
+    width = height = depth = ctype = interlace = 0
+    while pos + 8 <= len(data):
+        length, kind = struct.unpack(">I4s", data[pos : pos + 8])
+        body = data[pos + 8 : pos + 8 + length]
+        pos += 12 + length
+        if kind == b"IHDR" and len(body) >= 13:
+            width, height, depth, ctype, _, _, interlace = struct.unpack(">IIBBBBB", body[:13])
+        elif kind == b"PLTE":
+            palette = body
+        elif kind == b"IDAT":
+            idat.append(body)
+        elif kind == b"IEND":
+            break
+    channels = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4}.get(ctype)
+    if depth != 8 or interlace or not channels or width <= 0 or height <= 0 or width > 20_000:
+        return None
+    rows = min(height, MAX_ROWS)
+    stride = width * channels
+    raw = zlib.decompressobj().decompress(b"".join(idat), (stride + 1) * rows)
+    step = max(1, width // COLS)
+    grid_rows = max(1, rows * COLS // width) if width >= COLS else rows
+    want = {min(rows - 1, int((r + 0.5) * rows / grid_rows)) for r in range(grid_rows)}
+    cols = [min(width - 1, c * step + step // 2) for c in range(min(COLS, width))]
+    prev = bytearray(stride)
+    cells: list[list[tuple[int, int, int]]] = []
+    for y in range(rows):
+        start = y * (stride + 1)
+        if start + stride + 1 > len(raw):
+            break
+        f = raw[start]
+        line = bytearray(raw[start + 1 : start + 1 + stride])
+        if f == 1:
+            for i in range(channels, stride):
+                line[i] = (line[i] + line[i - channels]) & 255
+        elif f == 2:
+            for i in range(stride):
+                line[i] = (line[i] + prev[i]) & 255
+        elif f == 3:
+            for i in range(stride):
+                left = line[i - channels] if i >= channels else 0
+                line[i] = (line[i] + ((left + prev[i]) >> 1)) & 255
+        elif f == 4:
+            for i in range(stride):
+                left = line[i - channels] if i >= channels else 0
+                up_left = prev[i - channels] if i >= channels else 0
+                line[i] = (line[i] + _paeth(left, prev[i], up_left)) & 255
+        if y in want:
+            row = []
+            for x in cols:
+                o = x * channels
+                if ctype == 3:
+                    k = line[o] * 3
+                    px = tuple(palette[k : k + 3]) if k + 3 <= len(palette) else (0, 0, 0)
+                elif channels <= 2:
+                    px = (line[o],) * 3
+                else:
+                    px = (line[o], line[o + 1], line[o + 2])
+                row.append(px)  # type: ignore[arg-type]
+            cells.append(row)
+        prev = line
+    return Grid(width, height, cells) if cells else None
+
+
+def _grid_pillow(path: Path) -> Optional[Grid]:
+    try:
+        from PIL import Image  # type: ignore
+    except ImportError:
+        return None
+    with Image.open(path) as im:
+        im = im.convert("RGB")
+        w, h = im.size
+        h2 = min(h, MAX_ROWS)
+        im = im.crop((0, 0, w, h2))
+        cols = min(COLS, w)
+        rows = max(1, h2 * cols // w)
+        small = im.resize((cols, rows))
+        px = small.load()
+        return Grid(w, h, [[px[x, y] for x in range(cols)] for y in range(rows)])
+
+
+def grid(path: Path) -> Optional[Grid]:
+    try:
+        return _grid_pillow(path) or _grid_pure(path)
+    except (OSError, ValueError, zlib.error, struct.error):
+        return None
+
+
+def similarity(a: Grid, b: Grid) -> float:
+    """Percent of grid cells that match; rows only one image has count as different."""
+    rows = max(len(a.cells), len(b.cells))
+    cols = min(len(a.cells[0]), len(b.cells[0])) if a.cells and b.cells else 0
+    if rows == 0 or cols == 0:
+        return 0.0
+    same = 0
+    for y in range(min(len(a.cells), len(b.cells))):
+        for x in range(cols):
+            pa, pb = a.cells[y][x], b.cells[y][x]
+            if max(abs(pa[0] - pb[0]), abs(pa[1] - pb[1]), abs(pa[2] - pb[2])) <= TOLERANCE:
+                same += 1
+    return 100.0 * same / (rows * cols)

craft_kit/proc.py

@@ -0,0 +1,161 @@
+"""Running other programs without ever hanging: stdin closed or piped, wall-clock and idle deadlines,
+output drained on a thread and capped, the whole process group killed on timeout or Ctrl-C."""
+
+from __future__ import annotations
+
+import os
+import queue
+import shutil
+import signal
+import subprocess
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Callable, Optional, Sequence
+
+WINDOWS = os.name == "nt"
+
+
+@dataclass
+class Result:
+    code: Optional[int]
+    output: str = ""
+    timed_out: bool = False
+    error: str = ""  # why it couldn't start or was stopped, in plain words
+    lines: int = 0
+    meta: dict = field(default_factory=dict)
+
+    @property
+    def ok(self) -> bool:
+        return self.code == 0 and not self.timed_out and not self.error
+
+    def tail(self, n: int = 30) -> str:
+        return "\n".join(self.output.rstrip().splitlines()[-n:])
+
+
+def which(program: str) -> Optional[str]:
+    return shutil.which(program)
+
+
+def _kill(p: subprocess.Popen) -> None:
+    try:
+        if WINDOWS:
+            subprocess.run(["taskkill", "/F", "/T", "/PID", str(p.pid)], stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=10)
+        else:
+            os.killpg(p.pid, signal.SIGTERM)
+            try:
+                p.wait(timeout=3)
+                return
+            except subprocess.TimeoutExpired:
+                os.killpg(p.pid, signal.SIGKILL)
+    except (OSError, subprocess.SubprocessError):
+        pass
+    try:
+        p.kill()
+        p.wait(timeout=3)
+    except (OSError, subprocess.SubprocessError):
+        pass
+
+
+def run(
+    argv: Sequence[str],
+    cwd: Optional[str] = None,
+    timeout: float = 600,
+    idle: Optional[float] = None,
+    input_text: Optional[str] = None,
+    on_line: Optional[Callable[[str], None]] = None,
+    cap: int = 400_000,
+    env: Optional[dict] = None,
+) -> Result:
+    if not argv:
+        return Result(None, error="nothing to run")
+    exe = which(argv[0]) or argv[0]
+    if not os.path.isabs(exe) and os.sep not in exe and not which(exe):
+        return Result(None, error=f"`{argv[0]}` isn't installed or isn't on your PATH")
+    kwargs: dict = {}
+    if WINDOWS:
+        kwargs["creationflags"] = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) | getattr(subprocess, "CREATE_NO_WINDOW", 0)
+    else:
+        kwargs["start_new_session"] = True
+    try:
+        p = subprocess.Popen(
+            [exe, *argv[1:]],
+            cwd=cwd,
+            stdin=subprocess.PIPE if input_text is not None else subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            env={**os.environ, **(env or {})},
+            **kwargs,
+        )
+    except FileNotFoundError:
+        return Result(None, error=f"`{argv[0]}` isn't installed or isn't on your PATH")
+    except OSError as e:
+        return Result(None, error=f"`{argv[0]}` couldn't start: {e}")
+
+    lines: "queue.Queue[Optional[str]]" = queue.Queue()
+
+    def feed() -> None:
+        try:
+            assert p.stdin is not None
+            p.stdin.write(input_text.encode("utf-8", "replace"))  # type: ignore[union-attr]
+            p.stdin.close()
+        except (OSError, ValueError):
+            pass
+
+    def drain() -> None:
+        try:
+            assert p.stdout is not None
+            for raw in iter(p.stdout.readline, b""):
+                lines.put(raw.decode("utf-8", "replace"))
+        except (OSError, ValueError):
+            pass
+        finally:
+            lines.put(None)
+
+    if input_text is not None:
+        threading.Thread(target=feed, daemon=True).start()
+    threading.Thread(target=drain, daemon=True).start()
+
+    out: list[str] = []
+    size = 0
+    count = 0
+    start = last = time.monotonic()
+    timed_out = False
+    error = ""
+    try:
+        while True:
+            try:
+                line = lines.get(timeout=0.25)
+            except queue.Empty:
+                now = time.monotonic()
+                if now - start > timeout:
+                    timed_out, error = True, f"stopped after {int(timeout)} s (time limit)"
+                    break
+                if idle is not None and now - last > idle:
+                    timed_out, error = True, f"stopped after {int(idle)} s with no output"
+                    break
+                continue
+            if line is None:
+                break
+            last = time.monotonic()
+            count += 1
+            out.append(line)
+            size += len(line)
+            while size > cap and len(out) > 1:
+                size -= len(out.pop(0))
+            if on_line is not None:
+                try:
+                    on_line(line.rstrip("\n"))
+                except Exception:  # a display callback must never stop the run
+                    pass
+    except KeyboardInterrupt:
+        _kill(p)
+        raise
+    if timed_out:
+        _kill(p)
+    try:
+        code = p.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        _kill(p)
+        code = p.poll()
+    return Result(None if timed_out else code, "".join(out), timed_out, error, count)