pcode 0.1.0__py3-none-any.whl

pcode/jobs_ui.py

@@ -0,0 +1,265 @@
+"""Popup over the shell jobs this session knows about: what runs, what it printed."""
+
+import asyncio
+import time
+from collections.abc import Callable
+
+from prompt_toolkit.application import Application, get_app
+from prompt_toolkit.document import Document
+from prompt_toolkit.filters import Always, has_focus
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.bindings.focus import focus_next, focus_previous
+from prompt_toolkit.layout import DynamicContainer, HSplit, Layout, VSplit
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.widgets import Label, TextArea
+from rich.text import Text
+from rich.theme import Theme
+
+from pcode.frame import Frame
+from pcode.inspector_ui import code_block, format_command
+from pcode.jobs import Job, JobRegistry, format_duration
+from pcode.popup_ui import (
+    RichPane,
+    bind_list_paging,
+    list_pane_height,
+    popup_container,
+    popup_mouse,
+    popup_style,
+)
+from pcode.prefix_keys import PrefixKeys
+from pcode.shell import preview_text
+from pcode.tool_display import command_text
+
+REFRESH_SECONDS = 0.5
+
+# More than the model's tail, since this is where a person reads the whole log,
+# but no more than `preview_text` keeps: it clips to its last 128 KiB anyway.
+LOG_BYTES = 128 * 1024
+
+
+def icon(job: Job) -> str:
+    if job.running:
+        return "⟳"
+    return "✗" if job.stopped or job.exit_code != 0 else "✓"
+
+
+def ordered(registry: JobRegistry) -> list[Job]:
+    """Running jobs first, since those are the ones you open this to act on."""
+    return sorted(registry.jobs.values(), key=lambda job: (not job.running, job.started_at))
+
+
+def row(job: Job, watched: str = "") -> str:
+    line = f"{icon(job)} {job.id} · {job.outcome()} · {format_duration(job.elapsed)}"
+    line += f" · {command_text(job.label())}"
+    if job.id == watched:
+        line += " · watching"
+    return line
+
+
+def log_size(job: Job) -> int:
+    try:
+        return job.output_path.stat().st_size
+    except OSError:
+        return -1
+
+
+def details(registry: JobRegistry, job: Job | None, *, code_theme: str, watched: str = "") -> list:
+    """The job's purpose, command, and state, then the tail of what it printed.
+
+    Nothing here moves with the clock, so an idle job never re-renders its log.
+    """
+    if job is None:
+        return [Text("Jobs appear here once the model runs a shell command.", style="dim")]
+    blocks: list = []
+    if job.purpose:
+        blocks.append(Text(command_text(job.purpose), style="bold"))
+    blocks.append(code_block(format_command(command_text(job.command)), "bash", code_theme))
+    started = time.strftime("%H:%M:%S", time.localtime(job.started_at))
+    state = f"started {started}"
+    if not job.running:
+        state = f"{job.outcome()} · {state} · took {format_duration(job.elapsed)}"
+    notes = [state]
+    if job.background:
+        notes.append("background")
+    if job.adopted:
+        notes.append("adopted from an earlier pcode")
+    if job.id == watched:
+        notes.append("watching in the preview")
+    blocks += [Text("  " + " · ".join(notes), style="dim"), Text("")]
+    if not job.output_path.exists():
+        return [*blocks, Text("The log has been removed.", style="dim")]
+    output, truncated = registry.read_output(job, max_bytes=LOG_BYTES)
+    output = preview_text(output, final=True)
+    if truncated:
+        blocks.append(Text(f"… earlier output is in {job.output_path}", style="dim"))
+    blocks.append(Text(output) if output else Text("(no output yet)", style="dim"))
+    # A one-line last block, so anchoring to it scrolls to the very end.
+    return [*blocks, Text("")]
+
+
+class JobBrowser:
+    """List jobs, follow the selected one's log, and stop or watch it."""
+
+    def __init__(
+        self,
+        registry: JobRegistry,
+        *,
+        stop: Callable[[Job], None],
+        watch: Callable[[Job | None], None],
+        watched: Callable[[], str],
+        rich_theme: Theme | None = None,
+        code_theme: str = "ansi_dark",
+        color_system: str | None = "truecolor",
+        key_prefix: str | None = None,
+        **app_options,
+    ) -> None:
+        self.registry = registry
+        self.stop = stop
+        self.watch = watch
+        self.watched = watched
+        self.code_theme = code_theme
+        self.items = ordered(registry)
+        self.selected = self.items[0].id if self.items else None
+        self.notice = ""
+        self._rendered: tuple | None = None
+        self._refreshing = False
+        self.list = TextArea(read_only=True, wrap_lines=False, scrollbar=True)
+        self.list.window.cursorline = Always()
+        self.detail = RichPane(theme=rich_theme, color_system=color_system)
+        self.list.buffer.on_cursor_position_changed += lambda _: self.select()
+        keys = KeyBindings()
+        self.detail.bind_scrolling(keys)
+        bind_list_paging(keys, self.list, has_focus(self.list))
+
+        @keys.add("escape", eager=True)
+        @keys.add("c-c")
+        @keys.add("enter")
+        def close(event):
+            event.app.exit(result=None)
+
+        self.prefix_keys = shortcuts = PrefixKeys(key_prefix)
+        shortcuts.set_help(
+            lambda: [
+                ("↑/↓", "Select job / scroll output"),
+                ("PgUp/PgDn", "Page"),
+                ("Ctrl+U/D", "Half page"),
+                ("Tab/Shift+Tab", "Change focus"),
+                ("Enter/Esc/Ctrl+C", "Close"),
+            ]
+        )
+
+        @shortcuts.add("w", "Watch in preview")
+        def toggle_watch(event):
+            job = self.current()
+            if job is not None and job.id == self.watched():
+                self.watch(None)
+                self.notice = f"stopped watching {job.id}"
+            elif job is None or not job.running:
+                self.notice = "only a running job can be watched"
+                return
+            else:
+                self.watch(job)
+                self.notice = f"watching {job.id} in the preview"
+            self.refresh()
+
+        @shortcuts.add("k", "Stop")
+        def stop_selected(event):
+            # Same key meaning as in /btw: stop the work, keep the record.
+            job = self.current()
+            if job is None or not job.running:
+                self.notice = "nothing running to stop"
+                return
+            self.stop(job)
+            self.notice = f"stopped {job.id}"
+            self.refresh()
+
+        keys.add("tab")(focus_next)
+        keys.add("s-tab")(focus_previous)
+
+        def header() -> str:
+            running = sum(job.running for job in self.items)
+            line = f"Jobs · {len(self.items)} this session · {running} running"
+            return line + (f" · {self.notice}" if self.notice else "")
+
+        wide = VSplit(
+            [
+                Frame(self.list, title="Jobs", width=Dimension(weight=2)),
+                Frame(self.detail, title="Output", width=Dimension(weight=3)),
+            ]
+        )
+        narrow = HSplit(
+            [
+                Frame(self.list, title="Jobs", height=lambda: list_pane_height(len(self.items))),
+                Frame(self.detail, title="Output"),
+            ]
+        )
+        body = DynamicContainer(
+            lambda: wide if get_app().output.get_size().columns >= 100 else narrow
+        )
+        root_container = HSplit(
+            [
+                Label(header),
+                body,
+                Label(shortcuts.summary),
+            ]
+        )
+        self.app = Application(
+            layout=Layout(popup_container(root_container, shortcuts), focused_element=self.list),
+            key_bindings=shortcuts.key_bindings(keys),
+            full_screen=True,
+            mouse_support=popup_mouse(shortcuts),
+            style=popup_style(app_options.pop("style", None)),
+            **app_options,
+        )
+        self.refresh()
+
+    def refresh(self) -> None:
+        """Re-read statuses and rebuild the list, keeping the selection."""
+        self.registry.refresh()
+        self.items = ordered(self.registry)
+        watched = self.watched()
+        lines = [row(job, watched) for job in self.items] or ["No jobs yet"]
+        index = next((i for i, job in enumerate(self.items) if job.id == self.selected), 0)
+        position = sum(len(line) + 1 for line in lines[:index])
+        self._refreshing = True
+        self.list.buffer.set_document(Document("\n".join(lines), position), bypass_readonly=True)
+        self._refreshing = False
+        self.select()
+
+    def current(self) -> Job | None:
+        return next((job for job in self.items if job.id == self.selected), None)
+
+    def select(self) -> None:
+        if self._refreshing:
+            return
+        index = self.list.document.cursor_position_row
+        if index < len(self.items):
+            self.selected = self.items[index].id
+        job = self.current()
+        watched = self.watched()
+        state = (job.id, job.outcome(), log_size(job), job.id == watched) if job else (None,)
+        if state == self._rendered:
+            return
+        switched = self._rendered is None or state[0] != self._rendered[0]
+        self._rendered = state
+        blocks = details(self.registry, job, code_theme=self.code_theme, watched=watched)
+        if switched:
+            # Open on the newest output: that is what a log is read for. The
+            # anchor is the log's last block, and the window clamps a scroll
+            # past the bottom, so this lands on its final line.
+            self.detail.set(blocks, anchor=len(blocks) - 1)
+        else:
+            self.detail.follow(blocks)
+
+    async def run(self) -> None:
+        async def follow():
+            while True:
+                await asyncio.sleep(REFRESH_SECONDS)
+                # Rows carry elapsed time, so the list moves even when no log does.
+                self.refresh()
+                self.app.invalidate()
+
+        def start():
+            self.app.create_background_task(follow())
+
+        await self.app.run_async(pre_run=start)

pcode/keymap.py

@@ -0,0 +1,215 @@
+"""User-owned prompt bindings, distinct from editable project preferences."""
+
+import json
+from collections.abc import Callable
+from dataclasses import replace
+from pathlib import Path
+
+from filelock import FileLock
+from prompt_toolkit.completion import CompleteEvent, Completion
+from prompt_toolkit.document import Document
+from prompt_toolkit.filters import Always
+
+from pcode.commands import CommandRegistry, SlashCompleter
+from pcode.preferences import config_dir, write_json
+from pcode.prefix_keys import PrefixKeys, Shortcut, validate_action_key
+
+# These names keep native actions addressable even after their keys are replaced.
+DEFAULT_ACTIONS = {
+    "s": "@send-mode",
+    "l": "@model",
+    "n": "@effort-up",
+    "p": "@effort-down",
+    "o": "@tasks",
+    "t": "@thinking",
+    "g": "@commands",
+    "^": "@previous-session",
+    "y": "@copy",
+}
+USAGE = "/bind [list | actions | KEY [TARGET] | reset [KEY]]; /unbind KEY disables a key"
+
+
+def bindings_path() -> Path:
+    return config_dir() / "bindings.json"
+
+
+def validate_target(target: str) -> None:
+    if not target or any(not char.isprintable() for char in target):
+        raise ValueError("A binding target must be a single-line slash command or named @action.")
+    if target.startswith("@"):
+        if target not in DEFAULT_ACTIONS.values():
+            raise ValueError(f"Unknown built-in action: {target}. Use /bind actions.")
+    elif not target.startswith("/") or target.split(maxsplit=1)[0] == "/":
+        raise ValueError("A binding target must start with / (command) or @ (built-in action).")
+
+
+def read_bindings() -> dict[str, str | None]:
+    path = bindings_path()
+    try:
+        data = json.loads(path.read_text())
+    except FileNotFoundError:
+        return {}
+    except ValueError:
+        raise ValueError(
+            f"Invalid bindings JSON: {path}. Repair it before editing bindings."
+        ) from None
+    if not isinstance(data, dict):
+        raise ValueError(f"Bindings must be a JSON object: {path}")
+    for key, target in data.items():
+        validate_action_key(key)
+        if target is not None:
+            if not isinstance(target, str):
+                raise ValueError(f"Binding {key!r} must be a command, @action, or null.")
+            validate_target(target)
+    return data
+
+
+def save_binding(key: str | None, target: str | None = None, *, reset: bool = False) -> dict:
+    path = bindings_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with FileLock(str(path) + ".lock", timeout=5):
+        data = read_bindings()
+        if reset:
+            if key is None:
+                data.clear()
+            else:
+                data.pop(key, None)
+        else:
+            validate_action_key(key)
+            if target is not None:
+                validate_target(target)
+            data[key] = target
+        write_json(path, data)
+    return data
+
+
+class PromptKeymap:
+    def __init__(
+        self,
+        shortcuts: PrefixKeys,
+        registry: CommandRegistry,
+        execute: Callable[[str], None],
+        report: Callable[[str], None],
+    ) -> None:
+        self.shortcuts = shortcuts
+        self.registry = registry
+        self.execute = execute
+        self.report = report
+        self.defaults = {shortcut.key: shortcut for shortcut in shortcuts.shortcuts}
+        self.actions = {DEFAULT_ACTIONS[key]: value for key, value in self.defaults.items()}
+        self.overrides: dict[str, str | None] = {}
+        try:
+            self.apply(read_bindings())
+        except (OSError, ValueError) as error:
+            report(f"Could not load keybindings: {error}")
+
+    def check_command(self, target: str) -> None:
+        validate_target(target)
+        if self.registry.resolve(target) is None:
+            raise ValueError(f"Command unavailable: {target.split(maxsplit=1)[0]}")
+
+    def invoke(self, target: str) -> None:
+        try:
+            # Re-resolve at keypress time: extensions and skills can disappear.
+            self.check_command(target)
+            self.execute(target)
+        except ValueError as error:
+            self.report(str(error))
+
+    def apply(self, overrides: dict[str, str | None]) -> None:
+        for key in set(self.defaults) | set(self.overrides) | set(overrides):
+            self.shortcuts.remove(key)
+        self.overrides = overrides
+        for key in dict.fromkeys([*self.defaults, *overrides]):
+            target = overrides.get(key, DEFAULT_ACTIONS.get(key))
+            if target is None:
+                continue
+            if target.startswith("@"):
+                self.shortcuts.set_shortcut(replace(self.actions[target], key=key))
+            else:
+                self.shortcuts.set_shortcut(
+                    Shortcut(key, target, lambda event, text=target: self.invoke(text), Always())
+                )
+
+    def describe(self, key: str) -> str:
+        target = self.overrides.get(key, DEFAULT_ACTIONS.get(key))
+        source = "custom" if key in self.overrides else "default"
+        if target is None:
+            return f"{key}: disabled" if key in self.overrides else f"{key}: unbound"
+        description = self.actions[target].label if target.startswith("@") else target
+        if target.startswith("/") and self.registry.find(target.split(maxsplit=1)[0]) is None:
+            description += " (unavailable)"
+        return f"{self.shortcuts.label(key)}: {target} — {description} [{source}]"
+
+    def manage(self, argument: str, *, unbind: bool = False) -> str:
+        parts = argument.strip().split(maxsplit=1)
+        if unbind:
+            if len(parts) != 1:
+                raise ValueError("Usage: /unbind KEY")
+            key = parts[0]
+            validate_action_key(key)
+            self.apply(save_binding(key, None))
+            return f"Disabled binding {key}. /bind reset {key} restores its default."
+        if not parts or parts == ["list"]:
+            return "Prompt keybindings:\n" + "\n".join(
+                self.describe(key) for key in dict.fromkeys([*self.defaults, *self.overrides])
+            )
+        if parts == ["actions"]:
+            return "Built-in actions:\n" + "\n".join(
+                f"{name}: {action.label}" for name, action in self.actions.items()
+            )
+        if parts[0] == "reset":
+            key = parts[1] if len(parts) == 2 else None
+            if key is not None:
+                validate_action_key(key)
+            self.apply(save_binding(key, reset=True))
+            return (
+                f"Restored default binding for {key}." if key else "Restored all default bindings."
+            )
+        key = parts[0]
+        validate_action_key(key)
+        if len(parts) == 1:
+            return self.describe(key)
+        target = parts[1].strip()
+        validate_target(target)
+        if target.startswith("/"):
+            self.check_command(target)
+        self.apply(save_binding(key, target))
+        return "Saved " + self.describe(key)
+
+    def action_label(self, default_key: str) -> str:
+        """Tell help/notifications where a native action moved, or that it is unbound."""
+        target = DEFAULT_ACTIONS.get(default_key)
+        for key in dict.fromkeys([*self.defaults, *self.overrides]):
+            if self.overrides.get(key, DEFAULT_ACTIONS.get(key)) == target:
+                return self.shortcuts.label(key)
+        return "unbound"
+
+    def complete(self, argument: str):
+        parts = argument.split(maxsplit=1)
+        keys = list(dict.fromkeys([*self.defaults, *self.overrides]))
+        if not any(char.isspace() for char in argument):
+            for word in ["list", "actions", "reset", *keys]:
+                if word.startswith(argument):
+                    yield Completion(word, start_position=-len(argument))
+            return
+        head = parts[0] if parts else ""
+        tail = parts[1] if len(parts) > 1 else ""
+        if head == "reset":
+            for key in keys:
+                if key.startswith(tail):
+                    yield Completion(key, start_position=-len(tail))
+        elif len(head) == 1:
+            for target, action in self.actions.items():
+                if target.startswith(tail):
+                    yield Completion(target, start_position=-len(tail), display_meta=action.label)
+            yield from (
+                SlashCompleter(self.registry).get_completions(
+                    Document(tail or "/"), CompleteEvent()
+                )
+                if tail
+                else (
+                    Completion(command.name, display_meta=command.description)
+                    for command in self.registry.commands
+                )
+            )

pcode/layout_speed.py

@@ -0,0 +1,103 @@
+"""Faster width/height division for prompt_toolkit splits.
+
+Every repaint (each spinner frame, each scrollback flush) re-lays out the whole
+bottom block. prompt_toolkit's ``VSplit._divide_widths`` and
+``HSplit._divide_heights`` grow the children one cell at a time through a
+weighted round-robin generator, re-summing the sizes on every step, so one
+split costs O(width × children) and the eight splits in pcode's layout were
+~45% of a repaint. Every split here uses the default weight, and for equal
+weights the round-robin is a plain cycle, which can be applied in whole
+rounds. Unequal weights keep the original path.
+"""
+
+from prompt_toolkit.layout.containers import HSplit, VSplit, WritePosition
+from prompt_toolkit.layout.dimension import Dimension, sum_layout_dimensions
+
+
+def divide(dimensions: list[Dimension], available: int, *, fill: bool = True) -> list[int] | None:
+    """Sizes for ``dimensions`` in ``available`` cells, exactly as prompt_toolkit divides them.
+
+    ``fill`` False stops at the preferred sizes, as ``_divide_heights`` does once
+    the application is done.
+    """
+    if not dimensions:
+        return []
+    weights = [d.weight for d in dimensions]
+    positive = [w for w in weights if w > 0]
+    if not positive or any(w != positive[0] for w in positive):
+        return None  # Caller falls back to the original algorithm.
+    total = sum_layout_dimensions(dimensions)
+    if total.min > available:
+        return None
+    sizes = [d.min for d in dimensions]
+    order = [i for i, w in enumerate(weights) if w > 0]
+    position = 0  # Where the round-robin cycle continues between the two passes.
+
+    def grow(limits: list[int], stop: int) -> None:
+        nonlocal position
+        remaining = stop - sum(sizes)
+        while remaining > 0:
+            open_items = [i for i in order if sizes[i] < limits[i]]
+            if not open_items:
+                return  # The original would spin forever here; it cannot happen.
+            headroom = min(limits[i] - sizes[i] for i in open_items)
+            rounds = min(headroom, remaining // len(open_items))
+            if rounds:
+                for i in open_items:
+                    sizes[i] += rounds
+                remaining -= rounds * len(open_items)
+                if remaining == 0:
+                    # The cycle stopped right after the last open item it
+                    # visited, which is the last open one counting round
+                    # from the current position.
+                    cycle = order[position:] + order[:position]
+                    last = max(cycle.index(i) for i in open_items)
+                    position = (position + last + 1) % len(order)
+                continue
+            # Fewer cells left than open items: hand them out one by one from
+            # the current position, skipping saturated items as the cycle does.
+            while remaining > 0:
+                i = order[position]
+                position = (position + 1) % len(order)
+                if sizes[i] < limits[i]:
+                    sizes[i] += 1
+                    remaining -= 1
+
+    grow([d.preferred for d in dimensions], min(available, total.preferred))
+    if fill:
+        grow([d.max for d in dimensions], min(available, total.max))
+    return sizes
+
+
+_original_divide_widths = VSplit._divide_widths
+_original_divide_heights = HSplit._divide_heights
+
+
+def _divide_widths(self: VSplit, width: int) -> list[int] | None:
+    children = self._all_children
+    if not children:
+        return []
+    dimensions = [c.preferred_width(width) for c in children]
+    sizes = divide(dimensions, width)
+    if sizes is None and sum_layout_dimensions(dimensions).min <= width:
+        return _original_divide_widths(self, width)
+    return sizes
+
+
+def _divide_heights(self: HSplit, write_position: WritePosition) -> list[int] | None:
+    from prompt_toolkit.application.current import get_app
+
+    if not self.children:
+        return []
+    width, height = write_position.width, write_position.height
+    dimensions = [c.preferred_height(width, height) for c in self._all_children]
+    sizes = divide(dimensions, height, fill=not get_app().is_done)
+    if sizes is None and sum_layout_dimensions(dimensions).min <= height:
+        return _original_divide_heights(self, write_position)
+    return sizes
+
+
+def install_fast_layout_division() -> None:
+    """Replace the per-cell division on every split; idempotent."""
+    VSplit._divide_widths = _divide_widths
+    HSplit._divide_heights = _divide_heights

pcode/links.py

@@ -0,0 +1,90 @@
+"""Collect URLs from a conversation and open them in the user's browser."""
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+
+# Markdown [label](url) first so the label survives; then bare URLs. Trailing
+# punctuation that prose attaches to a URL is not part of it.
+MARKDOWN_LINK = re.compile(r"\[([^\]\n]+)\]\((https?://[^\s)\\]+)\)")
+BARE_URL = re.compile(r"https?://[^\s<>\"'`\]\\]+")
+_TRAILING = ".,;:!?'\""
+
+
+@dataclass(frozen=True)
+class Link:
+    url: str
+    label: str = ""
+    source: str = ""  # "user", "assistant", or a tool name
+
+
+def _strip(url: str) -> str:
+    url = url.rstrip(_TRAILING)
+    # Balanced parentheses as in Wikipedia URLs stay; an unmatched close goes.
+    while url.endswith(")") and url.count("(") < url.count(")"):
+        url = url[:-1].rstrip(_TRAILING)
+    return url
+
+
+def remember_link(found: dict[str, Link], link: Link) -> None:
+    """Move repeated URLs to their latest position, retaining useful labels."""
+    previous = found.pop(link.url, None)
+    label = link.label or (previous.label if previous else "")
+    found[link.url] = Link(link.url, label, link.source)
+
+
+def extract_links(text: str, source: str = "") -> list[Link]:
+    """Return distinct URLs in last-seen order, oldest first."""
+    matches = [
+        (match.start(), Link(_strip(match.group(2)), match.group(1).strip(), source))
+        for match in MARKDOWN_LINK.finditer(text)
+    ]
+    # Preserve offsets while hiding Markdown links from the bare-URL pass.
+    remainder = MARKDOWN_LINK.sub(lambda match: " " * len(match.group(0)), text)
+    matches.extend(
+        (match.start(), Link(_strip(match.group(0)), "", source))
+        for match in BARE_URL.finditer(remainder)
+    )
+    found: dict[str, Link] = {}
+    for _, link in sorted(matches, key=lambda item: item[0]):
+        remember_link(found, link)
+    return list(found.values())
+
+
+def conversation_links(tree, *, include_tools: bool = True) -> list[Link]:
+    """Links on the active path, oldest first; filter before deduplicating URLs."""
+    found: dict[str, Link] = {}
+    for identity in tree.path(tree.active):
+        node = tree.nodes[identity]
+        # A compaction's summary restates links it already listed; a merged
+        # side answer is part of the conversation like any reply.
+        if node.kind == "compaction":
+            continue
+        links = node.links if include_tools else node.message_links
+        for link in links.values():
+            remember_link(found, link)
+    return list(found.values())
+
+
+def open_link(url: str) -> None:
+    """Hand the URL to the desktop without tying it to this terminal.
+
+    ``webbrowser`` is avoided on purpose: without a display it falls back to
+    text browsers such as lynx and takes over the terminal pcode is drawing.
+    """
+    if sys.platform == "win32":
+        os.startfile(url)  # type: ignore[attr-defined]
+        return
+    opener = "open" if sys.platform == "darwin" else "xdg-open"
+    if shutil.which(opener) is None:
+        raise RuntimeError(f"Cannot open links: `{opener}` is not on PATH.")
+    subprocess.Popen(
+        [opener, url],
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )