shikiru-cli 0.2.0__py3-none-any.whl

shikiru/tmux/client.py

@@ -0,0 +1,637 @@
+"""The only tmux gateway: argv lists through `SubprocessRunner`, exact `=` targets."""
+
+from __future__ import annotations
+
+import asyncio
+import shlex
+import uuid
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
+
+from shikiru.errors import CommandFailed
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from shikiru.process import ProcessResult, SubprocessRunner
+
+_TMUX_BIN = "tmux"
+_UNKNOWN_ENVIRONMENT_VARIABLE_PREFIX = "unknown variable: "
+_SOCKET_FLAG = "-L"
+_CONFIG_FLAG = "-f"
+_COMMAND_TIMEOUT_SECONDS = 5.0
+_END_OF_OPTIONS = "--"
+_COMMAND_SEPARATOR = ";"
+TMUX_ENV_COMMAND = "env"
+TMUX_ENV_UNSET_OPTION = "-u"
+TMUX_ENV_UNSET_OPTION_ARGUMENT_COUNT = 2
+ENV_VARIABLE_ASSIGNMENT_SEPARATOR = "="
+_SESSION_SEPARATOR = ":"
+_HORIZONTAL_AXIS = "h"
+_FLAG_TRUE = "1"
+_PRIVATE_SOCKET_SUFFIX_LENGTH = 8
+_PREFIX_MODIFIER_LABELS = {"C": "Ctrl", "M": "Alt", "S": "Shift"}
+_SPACE_KEY_NAME = "Space"
+_TMUX_KEY_SEPARATOR = "-"
+_KEY_LABEL_SEPARATOR = "+"
+_PREFIX_OPTION = "prefix"
+_DETACH_CLIENT_COMMAND = "detach-client"
+_LIST_CLIENTS_COMMAND = "list-clients"
+_NO_CLIENTS = "no clients"
+_CLIENT_FIELD_SEPARATOR = "\t"
+_DETACHED_FLAG = "-d"
+_BEFORE_FLAG = "-b"
+_RESIZE_HEIGHT_FLAG = "-y"
+_LAYOUT_OPTION = "-t"
+_IF_SHELL_COMMAND = "if-shell"
+_ATTACHED_CLIENTS_FORMAT = "#{>:#{session_attached},0}"
+_ATTACH_REFUSAL_MESSAGE = (
+    "A terminal is already attached to Shikiru session {session!r}. Detach it first, then retry."
+)
+_ATTACH_REFUSAL_COMMAND = "; "
+_ATTACH_COMMAND = "attach-session"
+_SWITCH_CLIENT_COMMAND = "switch-client"
+_RUN_SHELL_COMMAND = "run-shell"
+_FAILED_SHELL_COMMAND = "exit 1"
+
+FORMAT_PANE_ID = "#{pane_id}"
+FORMAT_PANE_PID = "#{pane_pid}"
+FORMAT_PANE_DEAD = "#{pane_dead}"
+FORMAT_WINDOW_ID = "#{window_id}"
+FORMAT_WINDOW_NAME = "#{window_name}"
+FORMAT_WINDOW_INDEX = "#{window_index}"
+_TMUX_FORMAT_HASH = "#"
+_TMUX_FORMAT_OPEN_BRACE = "{"
+FORMAT_PANE_START_COMMAND = "#{pane_start_command}"
+FORMAT_SOCKET_PATH = "#{socket_path}"
+FORMAT_SESSION_NAME = "#{session_name}"
+FORMAT_CLIENT_TTY = "#{client_tty}"
+FORMAT_CLIENT_SESSION = "#{client_session}"
+FORMAT_CLIENT_PANE_ID = "#{pane_id}"
+FORMAT_SESSION_ID = "#{session_id}"
+SESSION_ID_NAME_SEPARATOR = "\t"
+SESSION_ID_LOOKUP_FORMAT = f"{FORMAT_SESSION_ID}{SESSION_ID_NAME_SEPARATOR}{FORMAT_SESSION_NAME}"
+NATIVE_SESSION_ID_PREFIX = "$"
+HOME_PANE_OPTION = "@shk_home"
+HOME_PANE_OPTION_VALUE = "1"
+LAYOUT_PANE_OPTION = "@shk_layout_pane"
+FORMAT_LAYOUT_PANE = f"#{{{LAYOUT_PANE_OPTION}}}"
+PANE_DEAD_FLAG = _FLAG_TRUE
+SYSTEM_LAYOUT_PANE = "system"
+NO_SERVER_RUNNING = "no server running on "
+ERROR_CONNECTING = "error connecting to "
+SOCKET_MISSING = "(No such file or directory)"
+
+SplitAxis = Literal["h", "v"]
+
+
+def private_socket_name(prefix: str) -> str:
+    """Return a unique socket name short enough for the OS socket path limit."""
+    return f"{prefix}{uuid.uuid4().hex[:_PRIVATE_SOCKET_SUFFIX_LENGTH]}"
+
+
+def exact_target(name: str) -> str:
+    """Build the exact-match target (`=<name>`) tmux uses for a session, window or pane name."""
+    return f"={name}"
+
+
+def _escape_pane_title_formats(title: str) -> str:
+    escaped: list[str] = []
+    index = 0
+    while index < len(title):
+        if title[index] != _TMUX_FORMAT_HASH:
+            escaped.append(title[index])
+            index += 1
+            continue
+        run_end = index
+        while run_end < len(title) and title[run_end] == _TMUX_FORMAT_HASH:
+            run_end += 1
+        hash_run = title[index:run_end]
+        if run_end < len(title) and title[run_end] == _TMUX_FORMAT_OPEN_BRACE:
+            escaped.append(hash_run + hash_run)
+        else:
+            escaped.append(hash_run)
+        index = run_end
+    return "".join(escaped)
+
+
+def tmux_key_label(key: str) -> str:
+    """Format a tmux key such as `C-b` for an operator-facing hint."""
+    parts = key.split(_TMUX_KEY_SEPARATOR)
+    modifiers = parts[:-1]
+    if any(modifier not in _PREFIX_MODIFIER_LABELS for modifier in modifiers):
+        return key
+    name = parts[-1]
+    key_name = (
+        name.upper() if len(name) == 1 else _SPACE_KEY_NAME if name == _SPACE_KEY_NAME else name
+    )
+    return _KEY_LABEL_SEPARATOR.join(
+        (*(_PREFIX_MODIFIER_LABELS[modifier] for modifier in modifiers), key_name)
+    )
+
+
+def _session_scoped(target: str) -> str:
+    return target if _SESSION_SEPARATOR in target else f"{target}{_SESSION_SEPARATOR}"
+
+
+def _command_args(command: Sequence[str] | None) -> list[str]:
+    if command is None:
+        return []
+    return [_END_OF_OPTIONS, *command]
+
+
+def new_session_command(
+    name: str,
+    *,
+    cwd: Path,
+    env: Mapping[str, str],
+    window_name: str,
+    size: tuple[int, int],
+    command: Sequence[str] | None = None,
+) -> tuple[str, ...]:
+    """Build the `new-session` argv for a detached session sized `size`, printing its pane id."""
+    columns, rows = size
+    args = [
+        "new-session",
+        "-d",
+        "-x",
+        str(columns),
+        "-y",
+        str(rows),
+        "-P",
+        "-F",
+        FORMAT_PANE_ID,
+        "-s",
+        name,
+        "-c",
+        str(cwd),
+        "-n",
+        window_name,
+    ]
+    for key, value in env.items():
+        args += ["-e", f"{key}={value}"]
+    args += _command_args(command)
+    return tuple(args)
+
+
+def new_window_command(
+    target_session: str,
+    *,
+    name: str,
+    cwd: Path | None = None,
+    command: Sequence[str] | None = None,
+    detached: bool = False,
+) -> tuple[str, ...]:
+    """Build the `new-window` argv for `name` in `target_session`; it prints its base pane id."""
+    args = ["new-window", "-P", "-F", FORMAT_PANE_ID, "-t", target_session, "-n", name]
+    if detached:
+        args.append(_DETACHED_FLAG)
+    if cwd is not None:
+        args += ["-c", str(cwd)]
+    args += _command_args(command)
+    return tuple(args)
+
+
+def session_option_commands(target: str, options: Mapping[str, str]) -> list[tuple[str, ...]]:
+    """Build one `set-option` per entry of `options`, scoped to session `target`."""
+    return [
+        ("set-option", "-t", _session_scoped(target), name, value)
+        for name, value in options.items()
+    ]
+
+
+def window_option_commands(target: str, options: Mapping[str, str]) -> list[tuple[str, ...]]:
+    """Build one window `set-option` per entry of `options`; `target` may also be a pane."""
+    return [("set-option", "-w", "-t", target, name, value) for name, value in options.items()]
+
+
+def pane_option_commands(target: str, options: Mapping[str, str]) -> list[tuple[str, ...]]:
+    """Build one pane `set-option` per entry of `options`, scoped to pane `target`."""
+    return [("set-option", "-p", "-t", target, name, value) for name, value in options.items()]
+
+
+def rename_window_command(target: str, name: str) -> tuple[str, ...]:
+    """Build the argv that renames window `target` to `name`."""
+    return ("rename-window", "-t", target, name)
+
+
+def pane_title_command(target: str, title: str) -> tuple[str, ...]:
+    """Build the argv that titles pane `target` without changing the active pane."""
+    return ("select-pane", "-t", target, "-T", _escape_pane_title_formats(title))
+
+
+class Tmux:
+    """Small, intention-revealing wrapper over the tmux CLI for one server (socket)."""
+
+    def __init__(
+        self,
+        runner: SubprocessRunner,
+        *,
+        socket: str | None = None,
+        env: Mapping[str, str] | None = None,
+        config_file: Path | None = None,
+    ) -> None:
+        """Use `runner` for every call, scoped to `socket` when one is given.
+
+        A `config_file` replaces the user's tmux configuration when this client starts a server.
+        """
+        self._runner = runner
+        self._socket = socket
+        self._config_file = config_file
+        self._env = env
+
+    async def new_session(
+        self,
+        name: str,
+        *,
+        cwd: Path,
+        env: Mapping[str, str],
+        window_name: str,
+        size: tuple[int, int],
+        command: Sequence[str] | None = None,
+    ) -> str:
+        """Create a detached session `name` sized `size` until a client attaches.
+
+        Returns the id of its first (base) pane.
+        """
+        result = await self._run(
+            *new_session_command(
+                name, cwd=cwd, env=env, window_name=window_name, size=size, command=command
+            )
+        )
+        return result.stdout.strip()
+
+    async def batch(self, commands: Sequence[Sequence[str]]) -> ProcessResult:
+        """Run `commands` in one tmux process, joined by tmux's `;` separator.
+
+        tmux stops at the first command that fails: the call raises `CommandFailed` as a single
+        command would, and the commands after it do not run. The result is the whole process's,
+        so a `new-session` in the batch prints its pane id there.
+        """
+        if not commands:
+            message = "a tmux batch needs at least one command"
+            raise ValueError(message)
+        args: list[str] = []
+        for index, command in enumerate(commands):
+            if index:
+                args.append(_COMMAND_SEPARATOR)
+            args.extend(command)
+        return await self._run(*args)
+
+    async def target_exists(self, target: str) -> bool:
+        """Return whether `target` (a session or a window, exactly) exists.
+
+        `has-session` reports on either: it errors with "can't find window" for a missing
+        window target just as it does with "can't find session" for a missing session one.
+        """
+        result = await self._run("has-session", "-t", target, check=False)
+        return result.returncode == 0
+
+    async def show_session_environment(self, target: str, name: str) -> str | None:
+        """Read session environment variable `name`, or `None` if unset or removed.
+
+        `show-environment` exits 0 and prints `-<name>` (no `=`) for a variable that was
+        *removed* from the session (e.g. via `set-environment -r`); an `unknown variable` error
+        also means unset. Other command failures remain visible.
+        """
+        result = await self._run("show-environment", "-t", target, name, check=False)
+        if result.returncode != 0:
+            if result.stderr.strip() == f"{_UNKNOWN_ENVIRONMENT_VARIABLE_PREFIX}{name}":
+                return None
+            raise CommandFailed(result.argv, result.returncode, result.stderr)
+        _, separator, value = result.stdout.strip().partition("=")
+        if not separator:
+            return None
+        return value
+
+    async def current_prefix(self, target: str) -> str:
+        """Return the effective prefix key for session `target`."""
+        result = await self._run(
+            "show-options", "-Aqv", "-t", _session_scoped(target), _PREFIX_OPTION
+        )
+        prefix = result.stdout.strip()
+        if not prefix:
+            message = "tmux returned an empty prefix key"
+            raise ValueError(message)
+        return prefix
+
+    async def client_for_pane(self, session_target: str, pane_target: str) -> str | None:
+        """Return tmux's input-selected client when it still shows `pane_target`."""
+        if not await self.pane_exists(pane_target):
+            return None
+        session_name = await self.display(pane_target, FORMAT_SESSION_NAME)
+        if exact_target(session_name) != session_target:
+            return None
+        clients = await self.list_clients(
+            session_target,
+            _CLIENT_FIELD_SEPARATOR.join(
+                (FORMAT_CLIENT_TTY, FORMAT_CLIENT_SESSION, FORMAT_CLIENT_PANE_ID)
+            ),
+        )
+        if not clients:
+            return None
+        selected_client = await self.display(pane_target, FORMAT_CLIENT_TTY)
+        for line in clients:
+            client_tty, client_session, client_pane = line.split(_CLIENT_FIELD_SEPARATOR)
+            if (
+                client_session == session_name
+                and client_pane == pane_target
+                and client_tty == selected_client
+            ):
+                return client_tty
+        return None
+
+    async def detach_client_for_pane(self, session_target: str, pane_target: str) -> bool:
+        """Detach the input-selected client after revalidating its pane and session."""
+        client_target = await self.client_for_pane(session_target, pane_target)
+        if client_target is None:
+            return False
+        if await self.client_for_pane(session_target, pane_target) != client_target:
+            return False
+        await self.detach_client(client_target)
+        return True
+
+    async def list_clients(self, target: str, fmt: str) -> list[str]:
+        """List client formats for `target`, returning no rows when it has no clients."""
+        result = await self._run(_LIST_CLIENTS_COMMAND, "-t", target, "-F", fmt, check=False)
+        if result.returncode == 0:
+            return result.stdout.splitlines()
+        if result.stderr.strip() == _NO_CLIENTS:
+            return []
+        raise CommandFailed(result.argv, result.returncode, result.stderr)
+
+    async def session_client_panes(self, name: str) -> list[str]:
+        """Return the panes shown by live clients in session `name`."""
+        if name not in await self.list_sessions():
+            return []
+        return await self.list_clients(exact_target(name), FORMAT_CLIENT_PANE_ID)
+
+    def guarded_client_argv(self, name: str, *, switch: bool) -> tuple[str, ...]:
+        """Build a client transition guarded by tmux's live attached-client count."""
+        target = exact_target(name)
+        session_target = f"{target}{_SESSION_SEPARATOR}"
+        refusal = _ATTACH_REFUSAL_COMMAND.join(
+            (
+                shlex.join(
+                    (
+                        "display-message",
+                        "-p",
+                        "-l",
+                        _ATTACH_REFUSAL_MESSAGE.format(session=name),
+                    )
+                ),
+                shlex.join((_RUN_SHELL_COMMAND, _FAILED_SHELL_COMMAND)),
+            )
+        )
+        operation = _SWITCH_CLIENT_COMMAND if switch else _ATTACH_COMMAND
+        transition = shlex.join((operation, "-t", target))
+        argv = [_TMUX_BIN]
+        if self._socket is not None:
+            argv += [_SOCKET_FLAG, self._socket]
+        if self._config_file is not None:
+            argv += [_CONFIG_FLAG, str(self._config_file)]
+        argv += [
+            _IF_SHELL_COMMAND,
+            "-F",
+            "-t",
+            session_target,
+            _ATTACHED_CLIENTS_FORMAT,
+            refusal,
+            transition,
+        ]
+        return tuple(argv)
+
+    async def detach_client(self, target: str) -> None:
+        """Detach only the explicitly named tmux client `target`."""
+        await self._run(_DETACH_CLIENT_COMMAND, "-t", target)
+
+    async def set_session_option(self, target: str, name: str, value: str) -> None:
+        """Set session option `name` on `target`.
+
+        `set-option` takes a target-pane, so a session-only `target` (no `:window` part) is
+        qualified with a trailing `:` to mean that session's current window; tmux still applies
+        a non-pane, non-window option at session scope.
+        """
+        await self.batch(session_option_commands(target, {name: value}))
+
+    async def set_window_option(self, target: str, name: str, value: str) -> None:
+        """Set window option `name` on `target`."""
+        await self.batch(window_option_commands(target, {name: value}))
+
+    async def set_pane_option(self, target: str, name: str, value: str) -> None:
+        """Set pane option `name` on `target`."""
+        await self.batch(pane_option_commands(target, {name: value}))
+
+    async def rename_window(self, target: str, name: str) -> None:
+        """Rename window `target` to `name`."""
+        await self._run(*rename_window_command(target, name))
+
+    async def set_pane_title(self, target: str, title: str) -> None:
+        """Set pane `target`'s title without changing the active pane."""
+        await self._run(*pane_title_command(target, title))
+
+    async def select_pane(self, target: str) -> None:
+        """Select the window containing pane `target`, then make that pane active."""
+        await self._run("select-window", "-t", target)
+        await self._run("select-pane", "-t", target)
+
+    async def select_window(self, target: str) -> None:
+        """Select an existing window target."""
+        await self._run("select-window", "-t", target)
+
+    async def new_window(
+        self,
+        target_session: str,
+        *,
+        name: str,
+        cwd: Path | None = None,
+        command: Sequence[str] | None = None,
+        detached: bool = False,
+    ) -> str:
+        """Create a window named `name` in `target_session`, returning its base pane id."""
+        result = await self._run(
+            *new_window_command(
+                target_session, name=name, cwd=cwd, command=command, detached=detached
+            )
+        )
+        return result.stdout.strip()
+
+    async def kill_window(self, target: str) -> None:
+        """Kill window `target`."""
+        await self._run("kill-window", "-t", target)
+
+    async def move_window(self, source: str, target: str) -> None:
+        """Move a window to an explicit target without replacing an existing window."""
+        await self._run("move-window", "-s", source, "-t", target)
+
+    async def swap_windows(self, source: str, target: str) -> None:
+        """Exchange two windows' positions without changing their identities."""
+        await self._run("swap-window", "-s", source, "-t", target)
+
+    async def kill_session(self, target: str) -> None:
+        """Kill session `target`."""
+        await self._run("kill-session", "-t", target)
+
+    async def kill_server(self) -> None:
+        """Stop this server and remove the socket file tmux leaves; no-op without a server."""
+        located = await self._run("display-message", "-p", FORMAT_SOCKET_PATH, check=False)
+        if located.returncode != 0:
+            return
+        await self._run("kill-server")
+        await asyncio.to_thread(Path(located.stdout.strip()).unlink, missing_ok=True)
+
+    async def display_message(self, target: str, message: str) -> None:
+        """Display `message` in the status line for `target`."""
+        await self._run("display-message", "-t", target, message)
+
+    async def split_window(
+        self,
+        target: str,
+        *,
+        axis: SplitAxis,
+        size_pct: int,
+        cwd: Path | None = None,
+        detached: bool = False,
+        before: bool = False,
+    ) -> str:
+        """Split pane `target`, returning the new pane's id sized `size_pct`% of `target`."""
+        axis_flag = "-h" if axis == _HORIZONTAL_AXIS else "-v"
+        args = [
+            "split-window",
+            axis_flag,
+            "-P",
+            "-F",
+            FORMAT_PANE_ID,
+            "-l",
+            f"{size_pct}%",
+            "-t",
+            target,
+        ]
+        if detached:
+            args.append(_DETACHED_FLAG)
+        if before:
+            args.append(_BEFORE_FLAG)
+        if cwd is not None:
+            args += ["-c", str(cwd)]
+        result = await self._run(*args)
+        return result.stdout.strip()
+
+    async def select_layout(self, target: str, layout: str) -> None:
+        """Apply tmux's named layout to `target` without rebuilding its panes."""
+        await self._run("select-layout", _LAYOUT_OPTION, target, layout)
+
+    async def resize_pane_height(self, target: str, height: int) -> None:
+        """Set pane `target` to an exact number of rows."""
+        await self._run("resize-pane", _RESIZE_HEIGHT_FLAG, str(height), "-t", target)
+
+    async def respawn_pane(
+        self,
+        target: str,
+        argv: Sequence[str],
+        *,
+        env: Mapping[str, str | None],
+        cwd: Path,
+    ) -> None:
+        """Restart pane `target`'s process, killing any survivor first."""
+        args = ["respawn-pane", "-k", "-t", target, "-c", str(cwd)]
+        command = [TMUX_ENV_COMMAND]
+        for key, value in env.items():
+            if value is None:
+                command += [TMUX_ENV_UNSET_OPTION, key]
+        for key, value in env.items():
+            if value is not None:
+                command.append(f"{key}={value}")
+        args += [_END_OF_OPTIONS, *command, *argv]
+        await self._run(*args)
+
+    async def is_pane_dead(self, target: str) -> bool:
+        """Return whether pane `target`'s process has exited (kept alive by `remain-on-exit`)."""
+        if not await self.pane_exists(target):
+            return True
+        result = await self.display(target, FORMAT_PANE_DEAD)
+        return result == _FLAG_TRUE
+
+    async def list_panes(self, target: str, fmt: str) -> list[str]:
+        """List every pane of `target`, one formatted line per pane."""
+        result = await self._run("list-panes", "-t", target, "-F", fmt)
+        return result.stdout.splitlines()
+
+    async def list_session_panes(self, target: str, fmt: str) -> list[str]:
+        """List every pane across every window of session `target`."""
+        result = await self._run("list-panes", "-s", "-t", target, "-F", fmt)
+        return result.stdout.splitlines()
+
+    async def list_session_windows(
+        self, target: str, *, row_format: str = FORMAT_WINDOW_ID
+    ) -> list[str]:
+        """List one `row_format` line per window of `target`, without selecting a window."""
+        result = await self._run("list-windows", "-t", target, "-F", row_format)
+        return result.stdout.splitlines()
+
+    async def list_sessions(self) -> list[str]:
+        """List session names, returning an empty list when this server is absent."""
+        result = await self._run("list-sessions", "-F", FORMAT_SESSION_NAME, check=False)
+        if result.returncode == 0:
+            return result.stdout.splitlines()
+        error = result.stderr.strip()
+        if error.startswith(NO_SERVER_RUNNING) or (
+            error.startswith(ERROR_CONNECTING) and error.endswith(SOCKET_MISSING)
+        ):
+            return []
+        raise CommandFailed(result.argv, result.returncode, result.stderr)
+
+    async def session_id(self, name: str) -> str:
+        """Return the native ID of the exact session named `name`."""
+        result = await self._run("list-sessions", "-F", SESSION_ID_LOOKUP_FORMAT, check=False)
+        if result.returncode != 0:
+            raise CommandFailed(result.argv, result.returncode, result.stderr)
+        session_ids: list[str] = []
+        for row in result.stdout.splitlines():
+            session_id, separator, session_name = row.partition(SESSION_ID_NAME_SEPARATOR)
+            if separator and session_name == name:
+                session_ids.append(session_id)
+        if len(session_ids) != 1:
+            message = f"tmux did not return one native session ID for {name!r}"
+            raise ValueError(message)
+        session_id = session_ids[0]
+        if not session_id.startswith(NATIVE_SESSION_ID_PREFIX) or not session_id[1:].isdecimal():
+            message = f"tmux returned an invalid native session ID: {session_id!r}"
+            raise ValueError(message)
+        return session_id
+
+    async def pane_exists(self, target: str) -> bool:
+        """Return whether an exact pane target exists."""
+        result = await self._run(
+            "display-message", "-p", "-t", target, "-F", FORMAT_PANE_ID, check=False
+        )
+        return result.returncode == 0 and result.stdout.strip() == target
+
+    async def window_id(self, target: str) -> str:
+        """Return the stable window id for pane or window target `target`."""
+        return await self.display(target, FORMAT_WINDOW_ID)
+
+    async def display(self, target: str, fmt: str) -> str:
+        """Evaluate format `fmt` in the context of `target` and return it, trimmed."""
+        result = await self._run("display-message", "-p", "-t", target, "-F", fmt)
+        return result.stdout.strip()
+
+    async def bind_key(self, key: str, *command: str, table: str = "prefix") -> None:
+        """Bind `key` in key table `table` to run `command` (a single tmux command line)."""
+        await self._run("bind-key", "-T", table, key, *command)
+
+    async def _run(
+        self, *args: str, input_text: str | None = None, check: bool = True
+    ) -> ProcessResult:
+        argv = [_TMUX_BIN]
+        if self._socket is not None:
+            argv += [_SOCKET_FLAG, self._socket]
+        if self._config_file is not None:
+            argv += [_CONFIG_FLAG, str(self._config_file)]
+        argv += list(args)
+        return await self._runner.run(
+            argv,
+            timeout=_COMMAND_TIMEOUT_SECONDS,
+            env=self._env,
+            input_text=input_text,
+            check=check,
+        )