@neoline/hostbridge 2.0.2 → 2.0.4

package/src/server_control_mcp/transports/pty.py

@@ -20,6 +20,7 @@ from ..hosts import HostConfig
 from .base import ExecResult, ShellReadResult, TransferResult, TransportBusy, TransportCapabilities, TransportError
 
 _REMOTE_BASE64_DECODE = "{ base64 --decode 2>/dev/null || base64 -d 2>/dev/null || base64 -D; }"
+_REMOTE_BASE64_ENCODE = "{ base64 --wrap=0 2>/dev/null || base64 | tr -d '\\r\\n'; }"
 PTY_BASE64_LINE_LENGTH = 3072
 
 
@@ -82,6 +83,28 @@ def _marker_text(value: object) -> str:
     return value.group(0) if hasattr(value, "group") else str(value)
 
 
+def _private_temp_path(kind: str, token: str, name: str | None = None) -> str:
+    path = f"$HOME/.hostbridge/tmp/{kind}.{token}"
+    return f"{path}/{name}" if name is not None else path
+
+
+def _quote_private_temp_path(path: str) -> str:
+    prefix = "$HOME/"
+    if not path.startswith(prefix):
+        raise ValueError("private temporary path must be relative to $HOME")
+    return f'"$HOME"/{shlex.quote(path[len(prefix) :])}'
+
+
+def _prepare_private_temp_dir(path: str) -> str:
+    directory = _quote_private_temp_path(path)
+    return (
+        'umask 077; tmp_root="$HOME/.hostbridge/tmp"; '
+        '[ -n "${HOME:-}" ] && [ ! -L "$HOME/.hostbridge" ] && [ ! -L "$tmp_root" ] && '
+        'mkdir -p -- "$tmp_root" && chmod 700 "$HOME/.hostbridge" "$tmp_root" && '
+        f"mkdir -m 700 -- {directory}"
+    )
+
+
 class PtyTransport:
     capabilities = TransportCapabilities(
         separate_stderr=False,
@@ -167,8 +190,9 @@ class PtyTransport:
         finally:
             if stdin_path is not None and self.child.isalive():
                 with suppress(Exception):
+                    stdin_dir = stdin_path.rsplit("/", 1)[0]
                     self._exec_locked(
-                        f"trap - EXIT HUP INT TERM; rm -f -- {shlex.quote(stdin_path)} {shlex.quote(f'{stdin_path}.b64')}",
+                        f"trap - EXIT HUP INT TERM; rm -rf -- {_quote_private_temp_path(stdin_dir)}",
                         timeout=min(timeout, 10),
                         output_limit=1024,
                     )
@@ -176,19 +200,33 @@ class PtyTransport:
 
     def _stage_stdin_locked(self, chunks: Iterable[bytes], *, timeout: float) -> str:
         token = self._token_factory()
-        path = f"/tmp/hostbridge.stdin.{token}"
-        base64_path = f"{path}.b64"
+        temp_dir = _private_temp_path("stdin", token)
+        path = _private_temp_path("stdin", token, "stdin")
+        base64_path = _private_temp_path("stdin", token, "stdin.b64")
+        temp_dir_q = _quote_private_temp_path(temp_dir)
+        path_q = _quote_private_temp_path(path)
+        base64_path_q = _quote_private_temp_path(base64_path)
         heredoc = f"__{self._marker_prefix}_STDIN_{token}__"
+        ready_pattern = re.compile(rf"__{self._marker_prefix}_STDIN_READY_{re.escape(token)}__:(\d+)")
         done_pattern = re.compile(rf"__{self._marker_prefix}_STDIN_DONE_{re.escape(token)}__:(\d+)")
-        cleanup = f"rm -f -- {shlex.quote(path)} {shlex.quote(base64_path)}"
+        cleanup = f"rm -rf -- {temp_dir_q}"
         try:
-            self.child.send(f"trap {shlex.quote(cleanup)} EXIT HUP INT TERM; cat > {shlex.quote(path)} <<'{heredoc}'\n")
+            setup = _prepare_private_temp_dir(temp_dir)
+            self.child.sendline(
+                f"if {setup}; then status=0; else status=$?; fi; "
+                f"printf '__{self._marker_prefix}_STDIN_READY_{token}__:%s\n' \"$status\""
+            )
+            self.child.expect(ready_pattern, timeout=timeout)
+            ready_match = re.search(r":(\d+)", _marker_text(self.child.after))
+            if ready_match is None or int(ready_match.group(1)) != 0:
+                raise TransportError("failed to prepare private PTY stdin directory")
+            self.child.send(f"trap {shlex.quote(cleanup)} EXIT HUP INT TERM; cat > {path_q} <<'{heredoc}'\n")
             for encoded in _iter_base64(chunks):
                 self.child.send(encoded)
             self.child.send(
                 f"\n{heredoc}\n"
-                f'tmp={shlex.quote(base64_path)}; mv {shlex.quote(path)} "$tmp"; '
-                f'{{ {_REMOTE_BASE64_DECODE} < "$tmp"; }} > {shlex.quote(path)}; status=$?; rm -f "$tmp"; '
+                f'tmp={base64_path_q}; mv {path_q} "$tmp"; '
+                f'{{ {_REMOTE_BASE64_DECODE} < "$tmp"; }} > {path_q}; status=$?; rm -f "$tmp"; '
                 f"printf '\n__{self._marker_prefix}_STDIN_DONE_{token}__:%s\n' \"$status\"\n"
             )
             self.child.expect(done_pattern, timeout=timeout)
@@ -198,6 +236,8 @@ class PtyTransport:
                     self.child.send("\x03")
                 with suppress(Exception):
                     self.child.sendline(f"trap - EXIT HUP INT TERM; {cleanup}")
+                with suppress(Exception):
+                    self.child.close(force=True)
             raise
         match = re.search(r":(\d+)", _marker_text(self.child.after))
         if match is None or int(match.group(1)) != 0:
@@ -216,22 +256,54 @@ class PtyTransport:
         start_marker = f"__{self._marker_prefix}_START_{token}__"
         exit_pattern = re.compile(rf"__{self._marker_prefix}_EXIT_{re.escape(token)}__:(\d+)")
         encoded_command = base64.b64encode(command.encode("utf-8")).decode("ascii")
-        stdin_redirect = f" < {shlex.quote(stdin_path)}" if stdin_path is not None else ""
+        stdin_redirect = f" < {_quote_private_temp_path(stdin_path)}" if stdin_path is not None else ""
+        status_dir = _private_temp_path("exec", token)
+        status_path = _private_temp_path("exec", token, "status")
+        cleanup_dirs = [status_dir]
+        if stdin_path is not None:
+            cleanup_dirs.append(stdin_path.rsplit("/", 1)[0])
+        signal_cleanup = "rm -rf -- " + " ".join(_quote_private_temp_path(path) for path in cleanup_dirs)
+        remaining_trap = (
+            f"trap {shlex.quote('rm -rf -- ' + _quote_private_temp_path(cleanup_dirs[1]))} EXIT HUP INT TERM"
+            if len(cleanup_dirs) > 1
+            else "trap - EXIT HUP INT TERM"
+        )
+        status_path_q = _quote_private_temp_path(status_path)
+        status_dir_q = _quote_private_temp_path(status_dir)
+        setup = _prepare_private_temp_dir(status_dir)
         remote_line = (
+            f"if {setup}; then trap {shlex.quote(signal_cleanup)} EXIT HUP INT TERM; "
             f"__scm_cmd=$(printf %s {shlex.quote(encoded_command)} | {_REMOTE_BASE64_DECODE}); "
-            f"printf '\n{start_marker}\n'; "
-            f"{self.remote_shell} -lc \"$__scm_cmd\"{stdin_redirect}; "
-            "__scm_status=$?; "
-            f"printf '\n__{self._marker_prefix}_EXIT_{token}__:%s\n' \"$__scm_status\""
+            f"printf '\n{start_marker}'; "
+            f'{{ {self.remote_shell} -lc "$__scm_cmd"{stdin_redirect}; '
+            f'printf %s "$?" > {status_path_q}; }} 2>&1 | '
+            f"tail -c {output_limit} | {_REMOTE_BASE64_ENCODE}; "
+            f"__scm_status=$(cat {status_path_q} 2>/dev/null || printf 255); "
+            f"rm -rf -- {status_dir_q}; {remaining_trap}; "
+            f"printf '__{self._marker_prefix}_EXIT_{token}__:%s\n' \"$__scm_status\"; "
+            f"else printf '\n{start_marker}'; printf '__{self._marker_prefix}_EXIT_{token}__:255\n'; fi"
         )
         try:
             self.child.sendline(remote_line)
             self.child.expect(exit_pattern, timeout=timeout)
         except pexpect.TIMEOUT:
-            return ExecResult(None, self._output_after_marker(str(self.child.before), start_marker, output_limit), timed_out=True)
+            output = b""
+            with suppress(TransportError):
+                output = self._output_after_marker(str(self.child.before), start_marker, output_limit)
+            with suppress(Exception):
+                self.child.send("\x03")
+            with suppress(Exception):
+                self.child.close(force=True)
+            return ExecResult(None, output, timed_out=True)
         match = re.search(r":(\d+)", _marker_text(self.child.after))
         exit_code = int(match.group(1)) if match else None
-        return ExecResult(exit_code, self._output_after_marker(str(self.child.before), start_marker, output_limit))
+        try:
+            output = self._output_after_marker(str(self.child.before), start_marker, output_limit)
+        except TransportError:
+            with suppress(Exception):
+                self.child.close(force=True)
+            raise
+        return ExecResult(exit_code, output)
 
     @staticmethod
     def _output_after_marker(raw: str, marker: str, output_limit: int) -> bytes:
@@ -239,13 +311,12 @@ class PtyTransport:
         normalized = normalized.replace("\r\n", "\n").replace("\r", "\n")
         marker_index = normalized.rfind(marker)
         output = normalized[marker_index + len(marker) :] if marker_index >= 0 else normalized
-        cleaned = [
-            line
-            for line in output.split("\n")
-            if not line.startswith("printf '") and not re.search(r"__[A-Z]+_(?:START|EXIT)_", line)
-        ]
-        encoded = "\n".join(cleaned).strip("\n").encode("utf-8", errors="replace")
-        return encoded[-output_limit:]
+        try:
+            encoded = "".join(output.split()).encode("ascii")
+            decoded = base64.b64decode(encoded, validate=True)
+        except (UnicodeEncodeError, binascii.Error, ValueError) as exc:
+            raise TransportError("PTY command output contains invalid base64 framing") from exc
+        return decoded[-output_limit:]
 
     def upload(
         self,
@@ -263,9 +334,14 @@ class PtyTransport:
         if not self.operation_lock.acquire(blocking=False):
             raise TransportBusy("PTY transport already has an active operation")
         token = self._token_factory()
-        tmp_b64 = f"/tmp/hostbridge.upload.{token}.b64"
-        tmp_out = f"/tmp/hostbridge.upload.{token}.out"
+        temp_dir = _private_temp_path("upload", token)
+        tmp_b64 = _private_temp_path("upload", token, "payload.b64")
+        tmp_out = _private_temp_path("upload", token, "payload.out")
+        temp_dir_q = _quote_private_temp_path(temp_dir)
+        tmp_b64_q = _quote_private_temp_path(tmp_b64)
+        tmp_out_q = _quote_private_temp_path(tmp_out)
         heredoc = f"__{self._marker_prefix}_UPLOAD_{token}__"
+        ready_pattern = re.compile(rf"__{self._marker_prefix}_UPLOAD_READY_{re.escape(token)}__:(\d+)")
         done_pattern = re.compile(rf"__{self._marker_prefix}_UPLOAD_DONE_{re.escape(token)}__:(\d+)")
         digest = hashlib.sha256()
         transferred = 0
@@ -282,27 +358,32 @@ class PtyTransport:
         try:
             if not self.child.isalive():
                 raise TransportError("PTY transport is not alive")
-            self.child.send(f"cat > {shlex.quote(tmp_b64)} <<'{heredoc}'\n")
+            setup = _prepare_private_temp_dir(temp_dir)
+            self.child.sendline(
+                f"if {setup}; then status=0; else status=$?; fi; "
+                f"printf '__{self._marker_prefix}_UPLOAD_READY_{token}__:%s\n' \"$status\""
+            )
+            self.child.expect(ready_pattern, timeout=60)
+            ready_match = re.search(r":(\d+)", _marker_text(self.child.after))
+            if ready_match is None or int(ready_match.group(1)) != 0:
+                raise TransportError("failed to prepare private PTY upload directory")
+            self.child.send(f"cat > {tmp_b64_q} <<'{heredoc}'\n")
             for encoded in _iter_base64(counted_chunks()):
                 self.child.send(encoded)
-            self.child.send(
-                f"\n{heredoc}\nprintf '\n__{self._marker_prefix}_UPLOAD_DONE_{token}__:%s\n' \"$?\"\n"
-            )
+            self.child.send(f"\n{heredoc}\nprintf '\n__{self._marker_prefix}_UPLOAD_DONE_{token}__:%s\n' \"$?\"\n")
             self.child.expect(done_pattern, timeout=60)
             match = re.search(r":(\d+)", _marker_text(self.child.after))
             if match is None or int(match.group(1)) != 0:
                 raise TransportError("failed to stream PTY upload")
             if expected_size is not None and transferred != expected_size:
-                raise TransportError(
-                    f"upload size mismatch: expected {expected_size}, received {transferred}"
-                )
+                raise TransportError(f"upload size mismatch: expected {expected_size}, received {transferred}")
             target_q = shlex.quote(remote_path)
             finalize = (
                 "set -e; "
-                f"target={target_q}; tmp_b64={shlex.quote(tmp_b64)}; tmp_out={shlex.quote(tmp_out)}; "
+                f"target={target_q}; tmp_b64={tmp_b64_q}; tmp_out={tmp_out_q}; "
                 'mkdir -p "$(dirname "$target")"; '
                 f'{{ {_REMOTE_BASE64_DECODE} < "$tmp_b64"; }} > "$tmp_out"; '
-                f'chmod {format(mode, "04o")} "$tmp_out"; mv "$tmp_out" "$target"; rm -f "$tmp_b64"; '
+                f'chmod {format(mode, "04o")} "$tmp_out"; mv "$tmp_out" "$target"; rm -rf -- {temp_dir_q}; '
                 "if command -v sha256sum >/dev/null 2>&1; then sha=$(sha256sum \"$target\" | awk '{print $1}'); "
                 "else sha=$(shasum -a 256 \"$target\" | awk '{print $1}'); fi; "
                 'bytes=$(wc -c < "$target" | tr -d " "); printf "BYTES=%s\\nSHA256=%s\\n" "$bytes" "$sha"'
@@ -320,7 +401,7 @@ class PtyTransport:
             if self.child.isalive():
                 with suppress(Exception):
                     self._exec_locked(
-                        f"rm -f -- {shlex.quote(tmp_b64)} {shlex.quote(tmp_out)}",
+                        f"rm -rf -- {temp_dir_q}",
                         timeout=10,
                         output_limit=1024,
                     )

package/src/server_control_mcp/transports/ssh.py

@@ -4,15 +4,51 @@ from __future__ import annotations
 
 import asyncio
 import hashlib
+import threading
 import uuid
-from collections.abc import Iterable, Sequence
+from collections import deque
+from collections.abc import AsyncGenerator, Awaitable, Iterable, Iterator, Sequence
 from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TypeVar
 
 import asyncssh
 
-from .base import ExecResult, TransferResult, TransportCapabilities
+from .base import ExecResult, ShellReadResult, TransferResult, TransportCapabilities, TransportError
+
+T = TypeVar("T")
+
+
+class _CombinedOutputBuffer:
+    def __init__(self, limit: int) -> None:
+        self._limit = limit
+        self._segments: deque[tuple[bool, bytes]] = deque()
+        self._size = 0
+
+    def append(self, chunk: bytes, *, stderr: bool) -> None:
+        if not chunk:
+            return
+        self._segments.append((stderr, bytes(chunk)))
+        self._size += len(chunk)
+        excess = self._size - self._limit
+        while excess > 0:
+            segment_stderr, segment = self._segments[0]
+            if len(segment) <= excess:
+                self._segments.popleft()
+                self._size -= len(segment)
+                excess -= len(segment)
+            else:
+                self._segments[0] = (segment_stderr, segment[excess:])
+                self._size -= excess
+                excess = 0
+
+    def outputs(self) -> tuple[bytes, bytes]:
+        stdout = bytearray()
+        stderr = bytearray()
+        for is_stderr, segment in self._segments:
+            (stderr if is_stderr else stdout).extend(segment)
+        return bytes(stdout), bytes(stderr)
 
 
 @dataclass(frozen=True, slots=True)
@@ -21,10 +57,12 @@ class SshConnectionConfig:
     port: int = 22
     username: str | None = None
     client_keys: Sequence[str] = ()
-    known_hosts: str | None = None
+    known_hosts: str | None | tuple[()] = ()
+    tunnel: str | None = None
+    password: str | None = None
 
 
-class SshTransport:
+class _AsyncSshTransport:
     capabilities = TransportCapabilities(
         separate_stderr=True,
         native_binary_transfer=True,
@@ -35,7 +73,7 @@ class SshTransport:
         self._connection = connection
 
     @classmethod
-    async def connect(cls, config: SshConnectionConfig) -> SshTransport:
+    async def connect(cls, config: SshConnectionConfig, *, connect_timeout: float | None = None) -> _AsyncSshTransport:
         if not config.host.strip():
             raise ValueError("SSH host must not be empty")
         if not 1 <= config.port <= 65535:
@@ -46,6 +84,9 @@ class SshTransport:
             username=config.username,
             client_keys=list(config.client_keys),
             known_hosts=config.known_hosts,
+            tunnel=config.tunnel,
+            password=config.password,
+            connect_timeout=connect_timeout,
             encoding=None,
         )
         return cls(connection)
@@ -64,28 +105,76 @@ class SshTransport:
             raise ValueError("timeout must be positive")
         if output_limit <= 0:
             raise ValueError("output_limit must be positive")
-        process = await self._connection.create_process(command, encoding=None)
-        stdout_task = asyncio.create_task(self._read_stream(process.stdout, output_limit))
-        stderr_task = asyncio.create_task(self._read_stream(process.stderr, output_limit))
+        open_task: asyncio.Future[asyncssh.SSHClientProcess[bytes]] = asyncio.ensure_future(
+            self._connection.create_process(command, encoding=None)
+        )
+        try:
+            process = await asyncio.shield(open_task)
+        except asyncio.CancelledError:
+            self._connection.abort()
+            close_task = asyncio.create_task(self._connection.wait_closed())
+            while not close_task.done():
+                try:
+                    await asyncio.shield(close_task)
+                except asyncio.CancelledError:
+                    continue
+            if not open_task.done():
+                open_task.cancel()
+            await asyncio.gather(open_task, return_exceptions=True)
+            raise
+        output = _CombinedOutputBuffer(output_limit)
+        stdout_task = asyncio.create_task(self._read_stream(process.stdout, output, stderr=False))
+        stderr_task = asyncio.create_task(self._read_stream(process.stderr, output, stderr=True))
         input_task = asyncio.create_task(self._write_stdin(process, stdin))
+        wait_task = asyncio.create_task(process.wait_closed())
+        tasks = (stdout_task, stderr_task, input_task, wait_task)
         try:
-            await asyncio.wait_for(process.wait_closed(), timeout=timeout)
-            await input_task
-            stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
+            await asyncio.wait_for(asyncio.gather(asyncio.shield(wait_task), input_task), timeout=timeout)
+            await asyncio.gather(stdout_task, stderr_task)
+            stdout, stderr = output.outputs()
             return ExecResult(process.exit_status, stdout, stderr)
         except TimeoutError:
-            process.terminate()
-            with suppress(Exception):
-                await process.wait_closed()
-            for task in (stdout_task, stderr_task, input_task):
+            await self._abort_process(process, tasks)
+            stdout, stderr = output.outputs()
+            return ExecResult(None, stdout, stderr, timed_out=True)
+        except BaseException:
+            cleanup = asyncio.create_task(self._abort_process(process, tasks))
+            while not cleanup.done():
+                try:
+                    await asyncio.shield(cleanup)
+                except asyncio.CancelledError:
+                    continue
+            await cleanup
+            raise
+
+    @staticmethod
+    async def _abort_process(
+        process: asyncssh.SSHClientProcess[bytes],
+        tasks: tuple[asyncio.Task[None], asyncio.Task[None], asyncio.Task[None], asyncio.Task[None]],
+    ) -> None:
+        process.terminate()
+        process.close()
+        wait_task = tasks[-1]
+        try:
+            await asyncio.wait_for(asyncio.shield(wait_task), timeout=1)
+        except BaseException:
+            process.kill()
+            process.close()
+            with suppress(BaseException):
+                await asyncio.wait_for(asyncio.shield(wait_task), timeout=1)
+        for task in tasks:
+            if not task.done():
                 task.cancel()
-            await asyncio.gather(stdout_task, stderr_task, input_task, return_exceptions=True)
-            return ExecResult(None, b"", b"", timed_out=True)
+        await asyncio.gather(*tasks, return_exceptions=True)
 
     @staticmethod
     async def _write_stdin(process: asyncssh.SSHClientProcess[bytes], stdin: Iterable[bytes] | None) -> None:
         if stdin is not None:
-            for chunk in stdin:
+            iterator = iter(stdin)
+            while True:
+                present, chunk = await asyncio.to_thread(_next_chunk, iterator)
+                if not present:
+                    break
                 if not isinstance(chunk, bytes):
                     raise TypeError("stdin chunks must be bytes")
                 process.stdin.write(chunk)
@@ -93,16 +182,12 @@ class SshTransport:
         process.stdin.write_eof()
 
     @staticmethod
-    async def _read_stream(stream, output_limit: int) -> bytes:
-        output = bytearray()
+    async def _read_stream(stream, output: _CombinedOutputBuffer, *, stderr: bool) -> None:
         while True:
             chunk = await stream.read(64 * 1024)
             if not chunk:
                 break
-            output.extend(chunk)
-            if len(output) > output_limit:
-                del output[: len(output) - output_limit]
-        return bytes(output)
+            output.append(bytes(chunk), stderr=stderr)
 
     async def upload_file(
         self,
@@ -142,6 +227,57 @@ class SshTransport:
             sftp.exit()
         return TransferResult(transferred, digest.hexdigest())
 
+    async def upload(
+        self,
+        chunks: Iterable[bytes],
+        remote_path: str,
+        *,
+        mode: int,
+        expected_size: int | None,
+    ) -> TransferResult:
+        self._validate_remote_path(remote_path)
+        temporary = f"{remote_path}.hostbridge-{uuid.uuid4().hex}.tmp"
+        digest = hashlib.sha256()
+        transferred = 0
+        iterator = iter(chunks)
+        sftp = await self._connection.start_sftp_client()
+        try:
+            async with sftp.open(temporary, "wb", encoding=None) as remote_file:
+                while True:
+                    present, chunk = await asyncio.to_thread(_next_chunk, iterator)
+                    if not present:
+                        break
+                    if not isinstance(chunk, bytes):
+                        raise TypeError("upload chunks must be bytes")
+                    await remote_file.write(chunk)
+                    digest.update(chunk)
+                    transferred += len(chunk)
+            if expected_size is not None and transferred != expected_size:
+                raise TransportError(f"upload size mismatch: expected {expected_size}, received {transferred}")
+            await sftp.chmod(temporary, mode)
+            await sftp.rename(temporary, remote_path)
+        except BaseException:
+            with suppress(Exception):
+                await sftp.remove(temporary)
+            raise
+        finally:
+            sftp.exit()
+        return TransferResult(transferred, digest.hexdigest())
+
+    async def download(self, remote_path: str, *, chunk_size: int) -> AsyncGenerator[bytes, None]:
+        self._validate_chunk_size(chunk_size)
+        self._validate_remote_path(remote_path)
+        sftp = await self._connection.start_sftp_client()
+        try:
+            async with sftp.open(remote_path, "rb", encoding=None) as remote_file:
+                while True:
+                    raw_chunk = await remote_file.read(chunk_size)
+                    if not raw_chunk:
+                        break
+                    yield raw_chunk.encode("utf-8") if isinstance(raw_chunk, str) else bytes(raw_chunk)
+        finally:
+            sftp.exit()
+
     async def download_file(
         self,
         remote_path: str,
@@ -190,6 +326,154 @@ class SshTransport:
         if not isinstance(remote_path, str) or not remote_path.strip() or "\x00" in remote_path:
             raise ValueError("remote_path must be a non-empty path without NUL bytes")
 
+    async def shell_write(self, data: bytes) -> None:
+        if not isinstance(data, bytes):
+            raise TypeError("shell data must be bytes")
+        process = await self._ensure_shell()
+        process.stdin.write(data)
+        await process.stdin.drain()
+
+    async def shell_read(self, *, timeout: float, max_bytes: int) -> ShellReadResult:
+        if timeout < 0:
+            raise ValueError("timeout must be non-negative")
+        if max_bytes <= 0:
+            raise ValueError("max_bytes must be positive")
+        process = await self._ensure_shell()
+        try:
+            data = await asyncio.wait_for(process.stdout.read(max_bytes), timeout=timeout)
+        except TimeoutError:
+            data = b""
+        return ShellReadResult(bytes(data), process.exit_status is None and not self._connection.is_closed())
+
+    async def _ensure_shell(self) -> asyncssh.SSHClientProcess[bytes]:
+        shell = getattr(self, "_shell", None)
+        if shell is None or shell.exit_status is not None:
+            shell = await self._connection.create_process(term_type="xterm", encoding=None)
+            self._shell = shell
+        return shell
+
     async def close(self) -> None:
+        shell = getattr(self, "_shell", None)
+        if shell is not None:
+            shell.terminate()
+            shell.close()
+            with suppress(Exception):
+                await asyncio.wait_for(shell.wait_closed(), timeout=1)
         self._connection.close()
         await self._connection.wait_closed()
+
+
+def _next_chunk(iterator: Iterator[bytes]) -> tuple[bool, bytes]:
+    try:
+        return True, next(iterator)
+    except StopIteration:
+        return False, b""
+
+
+class _EventLoopThread:
+    def __init__(self) -> None:
+        self.loop = asyncio.new_event_loop()
+        self.thread = threading.Thread(target=self._run, name="hostbridge-ssh", daemon=True)
+        self.started = threading.Event()
+        self.thread.start()
+        self.started.wait()
+
+    def _run(self) -> None:
+        asyncio.set_event_loop(self.loop)
+        self.started.set()
+        self.loop.run_forever()
+        self.loop.run_until_complete(self.loop.shutdown_asyncgens())
+        self.loop.close()
+
+    def run(self, awaitable: Awaitable[T]) -> T:
+        if not self.thread.is_alive():
+            raise TransportError("SSH transport is closed")
+        return asyncio.run_coroutine_threadsafe(_await_value(awaitable), self.loop).result()
+
+    def stop(self) -> None:
+        if self.thread.is_alive():
+            self.loop.call_soon_threadsafe(self.loop.stop)
+            self.thread.join(timeout=2)
+
+
+class SshTransport:
+    capabilities = _AsyncSshTransport.capabilities
+
+    def __init__(self, core: _AsyncSshTransport, runner: _EventLoopThread) -> None:
+        self._core = core
+        self._runner = runner
+        self._close_lock = threading.Lock()
+        self._closed = False
+
+    @classmethod
+    def connect(cls, config: SshConnectionConfig, *, connect_timeout: float | None = None) -> SshTransport:
+        runner = _EventLoopThread()
+        try:
+            core = runner.run(_AsyncSshTransport.connect(config, connect_timeout=connect_timeout))
+        except BaseException:
+            runner.stop()
+            raise
+        return cls(core, runner)
+
+    def exec(
+        self,
+        command: str,
+        *,
+        stdin: Iterable[bytes] | None,
+        timeout: float,
+        output_limit: int,
+    ) -> ExecResult:
+        return self._run(self._core.exec(command, stdin=stdin, timeout=timeout, output_limit=output_limit))
+
+    def upload(
+        self,
+        chunks: Iterable[bytes],
+        remote_path: str,
+        *,
+        mode: int,
+        expected_size: int | None,
+    ) -> TransferResult:
+        return self._run(self._core.upload(chunks, remote_path, mode=mode, expected_size=expected_size))
+
+    def download(self, remote_path: str, *, chunk_size: int) -> Iterator[bytes]:
+        stream = self._core.download(remote_path, chunk_size=chunk_size)
+
+        def chunks() -> Iterator[bytes]:
+            try:
+                while True:
+                    try:
+                        yield self._run(stream.__anext__())
+                    except StopAsyncIteration:
+                        return
+            finally:
+                self._run(stream.aclose())
+
+        return chunks()
+
+    def shell_write(self, data: bytes) -> None:
+        self._run(self._core.shell_write(data))
+
+    def shell_read(self, *, timeout: float, max_bytes: int) -> ShellReadResult:
+        return self._run(self._core.shell_read(timeout=timeout, max_bytes=max_bytes))
+
+    def close(self) -> None:
+        with self._close_lock:
+            if self._closed:
+                return
+            self._closed = True
+            try:
+                self._runner.run(self._core.close())
+            finally:
+                self._runner.stop()
+
+    def _run(self, awaitable: Awaitable[T]) -> T:
+        try:
+            return self._runner.run(awaitable)
+        except (StopAsyncIteration, TypeError, ValueError, TransportError):
+            raise
+        except Exception as exc:
+            raise TransportError(str(exc) or exc.__class__.__name__) from exc
+
+
+async def _await_value(awaitable: Awaitable[T]) -> T:
+    return await awaitable