@neoline/hostbridge 2.0.4 → 2.0.5

package/src/server_control_mcp/transports/__init__.py

@@ -1,17 +1,13 @@
-"""Remote transport implementations used by HostBridge daemon services."""
+"""Async transport primitives used by HostBridge host runtimes."""
 
-from .base import ExecResult, ShellReadResult, TransferResult, Transport, TransportBusy, TransportCapabilities
-from .pty import PtyTransport
-from .ssh import SshConnectionConfig, SshTransport
+from .base import ExecResult, ShellReadResult, TransferResult, TransportCapabilities
+from .ssh import AsyncSshConnection, SshConnectionConfig
 
 __all__ = [
     "ExecResult",
-    "PtyTransport",
+    "AsyncSshConnection",
     "SshConnectionConfig",
-    "SshTransport",
     "ShellReadResult",
     "TransferResult",
-    "Transport",
-    "TransportBusy",
     "TransportCapabilities",
 ]

package/src/server_control_mcp/transports/base.py

@@ -2,17 +2,40 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable, Iterator
+import asyncio
+from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator, Awaitable, Iterable, Iterator, Mapping
 from dataclasses import dataclass
-from typing import Protocol
 
 
 class TransportError(RuntimeError):
     """Base error raised by a remote transport."""
 
 
-class TransportBusy(TransportError):
-    """Raised when an ordered transport already has an active operation."""
+ByteStream = AsyncIterable[bytes] | Iterable[bytes]
+
+
+async def iterate_byte_stream(chunks: ByteStream, *, label: str) -> AsyncGenerator[bytes, None]:
+    if isinstance(chunks, AsyncIterable):
+        async for chunk in chunks:
+            if not isinstance(chunk, bytes):
+                raise TypeError(f"{label} chunks must be bytes")
+            yield chunk
+        return
+    iterator = iter(chunks)
+    while True:
+        present, chunk = await asyncio.to_thread(_next_chunk, iterator)
+        if not present:
+            return
+        if not isinstance(chunk, bytes):
+            raise TypeError(f"{label} chunks must be bytes")
+        yield chunk
+
+
+def _next_chunk(iterator: Iterator[bytes]) -> tuple[bool, bytes]:
+    try:
+        return True, next(iterator)
+    except StopIteration:
+        return False, b""
 
 
 @dataclass(frozen=True, slots=True)
@@ -42,37 +65,36 @@ class ShellReadResult:
     alive: bool
 
 
-class Transport(Protocol):
-    capabilities: TransportCapabilities
-
-    def exec(
-        self,
-        command: str,
-        *,
-        stdin: Iterable[bytes] | None,
-        timeout: float,
-        output_limit: int,
-    ) -> ExecResult:
-        raise NotImplementedError
-
-    def upload(
-        self,
-        chunks: Iterable[bytes],
-        remote_path: str,
-        *,
-        mode: int,
-        expected_size: int | None,
-    ) -> TransferResult:
-        raise NotImplementedError
-
-    def download(self, remote_path: str, *, chunk_size: int) -> Iterator[bytes]:
-        raise NotImplementedError
-
-    def close(self) -> None:
-        raise NotImplementedError
-
-    def shell_write(self, data: bytes) -> None:
-        raise NotImplementedError
-
-    def shell_read(self, *, timeout: float, max_bytes: int) -> ShellReadResult:
-        raise NotImplementedError
+@dataclass(frozen=True, slots=True)
+class ShellTerminalResult:
+    exit_code: int | None
+    signal: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.exit_code is not None and (
+            not isinstance(self.exit_code, int) or isinstance(self.exit_code, bool) or not 0 <= self.exit_code <= 255
+        ):
+            raise ValueError("shell exit_code must be between 0 and 255 or null")
+        if self.signal is not None and (not isinstance(self.signal, str) or not self.signal.strip()):
+            raise ValueError("shell signal must be a non-empty string or null")
+        if self.exit_code is not None and self.signal is not None:
+            raise ValueError("shell terminal result cannot contain both exit_code and signal")
+
+    @classmethod
+    def from_mapping(cls, value: Mapping[str, object]) -> ShellTerminalResult:
+        return cls(value.get("exit_code"), value.get("signal"))  # type: ignore[arg-type]
+
+    def to_mapping(self) -> dict[str, object]:
+        return {"exit_code": self.exit_code, "signal": self.signal}
+
+
+class ShellAttachment:
+    def __init__(self, output: AsyncIterator[bytes], terminal: Awaitable[ShellTerminalResult]) -> None:
+        self._output = output
+        self._terminal = terminal
+
+    def __aiter__(self) -> AsyncIterator[bytes]:
+        return self._output
+
+    async def finish(self) -> ShellTerminalResult:
+        return await self._terminal