@neoline/hostbridge 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neoline/hostbridge",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "HostBridge MCP server for persistent allowlisted SSH and shell sessions.",
   "type": "module",
   "license": "MIT",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hostbridge"
-version = "2.0.0"
+version = "2.0.2"
 description = "HostBridge MCP server for persistent allowlisted SSH and shell sessions."
 readme = "README.md"
 requires-python = ">=3.11"

package/src/server_control_mcp/__init__.py

@@ -8,13 +8,14 @@ import sys
 from typing import NoReturn
 
 __all__ = ["__version__", "ensure_runtime"]
-__version__ = "2.0.0"
+__version__ = "2.0.2"
 
 # (import_name, pip_name) pairs for runtime dependency probing.
 _REQUIRED_DEPENDENCIES = (
     ("mcp", "mcp"),
     ("pexpect", "pexpect"),
     ("cryptography", "cryptography"),
+    ("asyncssh", "asyncssh"),
 )
 
 

package/src/server_control_mcp/client.py

@@ -146,8 +146,18 @@ class HostBridgeClient:
     def hello(self) -> dict[str, object]:
         return self.request("system.hello", {})
 
-    def open_session(self, host_id: str, *, owner: str | None = None) -> SessionInfo:
-        result = self.request("session.open", {"host_id": host_id, "owner": owner})
+    def open_session(
+        self,
+        host_id: str,
+        *,
+        owner: str | None = None,
+        timeout: float | None = None,
+    ) -> SessionInfo:
+        result = self.request(
+            "session.open",
+            {"host_id": host_id, "owner": owner},
+            timeout=timeout,
+        )
         return SessionInfo.from_dict(result)
 
     def exec(

package/src/server_control_mcp/config.py

@@ -9,6 +9,8 @@ import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 
+from .secrets import SCHEME, encrypt_secret
+
 SCHEMA_VERSION = 1
 _HOST_ID = re.compile(r"^[A-Za-z0-9_.-]+$")
 _CONNECTION_STYLES = {"script", "ssh", "command"}
@@ -83,8 +85,19 @@ def _validate_secrets(value: object, source: Path | str, index: int) -> None:
     for name, secret in value.items():
         if not isinstance(name, str):
             raise ValueError(f"{source}.hosts[{index}].secrets contains an invalid name")
-        encrypted = isinstance(secret, str) and secret.startswith("gAAAA")
-        environment_ref = isinstance(secret, dict) and set(secret) == {"env"} and isinstance(secret.get("env"), str)
+        encrypted = (
+            isinstance(secret, dict)
+            and set(secret) == {"scheme", "ciphertext"}
+            and secret.get("scheme") == SCHEME
+            and isinstance(secret.get("ciphertext"), str)
+            and bool(secret.get("ciphertext"))
+        )
+        environment_ref = (
+            isinstance(secret, dict)
+            and set(secret) == {"env"}
+            and isinstance(secret.get("env"), str)
+            and bool(secret.get("env"))
+        )
         if not encrypted and not environment_ref:
             raise ValueError(f"{source}.hosts[{index}] contains plaintext secret {name!r}")
 
@@ -116,6 +129,12 @@ def migrate_config(source: Path | str, destination: Path | str) -> ConfigDocumen
             raise ValueError(f"{source_path} contains a non-object host")
         host = dict(raw_host)
         host.setdefault("transport", "auto")
+        secrets = host.get("secrets")
+        if isinstance(secrets, dict):
+            host["secrets"] = {
+                name: encrypt_secret(secret) if isinstance(secret, str) else secret
+                for name, secret in secrets.items()
+            }
         migrated_hosts.append(host)
     payload = validate_v1_config(
         {"schema_version": SCHEMA_VERSION, "hosts": migrated_hosts},

package/src/server_control_mcp/doctor.py

@@ -60,7 +60,7 @@ def _version_diagnostic() -> DiagnosticResult:
         "npm": npm.get("version"),
         "python": pyproject.get("project", {}).get("version"),
     }
-    status = "pass" if len(set(versions.values())) == 1 and __version__ == "2.0.0" else "fail"
+    status = "pass" if len(set(versions.values())) == 1 and __version__ == "2.0.2" else "fail"
     return DiagnosticResult("version", status, "version sources agree" if status == "pass" else "version drift detected", versions)
 
 

package/src/server_control_mcp/mock_ssh.py

@@ -7,7 +7,9 @@ import re
 import shlex
 import sys
 import tempfile
+import threading
 import time
+from contextlib import suppress
 from dataclasses import dataclass, field
 from functools import partial
 from pathlib import Path
@@ -31,6 +33,7 @@ STDIN_READING_COMMANDS = [
     re.compile(r"(?:^|\s)dd\s+.*\bof="),
     re.compile(r"(?:^|\s)scp(?:\s+\S+)*\s+-[A-Za-z]*(?:t|f)[A-Za-z]*(?:\s|$)"),
 ]
+MAX_IDLE_BACKEND_SESSIONS = 4
 
 
 def _to_bytes(chunk: str | bytes) -> bytes:
@@ -39,6 +42,10 @@ def _to_bytes(chunk: str | bytes) -> bytes:
     return chunk.encode("utf-8")
 
 
+def _command_reads_stdin(command: str | None) -> bool:
+    return bool(command and any(pattern.search(command) for pattern in STDIN_READING_COMMANDS))
+
+
 class HostBridgeSSHServer(asyncssh.SSHServer):
     def __init__(self, authorized_public_key: str) -> None:
         self._authorized_public_key = authorized_public_key.strip()
@@ -63,22 +70,26 @@ class HostBridgeSSHProcess:
         self._timeout = timeout
         self._output_limit = output_limit
 
-    async def __call__(self, process: asyncssh.SSHServerProcess[str]) -> None:
+    async def __call__(self, process: asyncssh.SSHServerProcess[bytes]) -> None:
         session_id = self._session_factory.open()
+        reusable = False
         try:
-            await self._run(process, session_id)
+            reusable = await self._run(process, session_id)
+        except asyncio.CancelledError:
+            self._set_exit_status(process, 255)
+            return
         finally:
-            self._session_factory.close(session_id)
+            self._session_factory.close(session_id, reusable=reusable)
 
-    async def _run(self, process: asyncssh.SSHServerProcess[str], session_id: str) -> None:
+    async def _run(self, process: asyncssh.SSHServerProcess[bytes], session_id: str) -> bool:
         command = process.command
         if not command:
             await self._run_shell(process, session_id)
-            return
+            return False
 
         loop = asyncio.get_running_loop()
         try:
-            stdin_data = await self._read_exec_stdin(process)
+            stdin_data = await self._read_exec_stdin(process, command)
             result = await loop.run_in_executor(
                 None,
                 lambda: self._client.exec(
@@ -91,27 +102,39 @@ class HostBridgeSSHProcess:
                 ),
             )
             if result.stdout:
-                output = result.stdout.decode("utf-8", errors="replace")
-                process.stdout.write(output)
-                if not output.endswith("\n"):
-                    process.stdout.write("\n")
+                process.stdout.write(result.stdout)
             if result.stderr:
-                process.stderr.write(result.stderr.decode("utf-8", errors="replace"))
-            process.exit(124 if result.timed_out else int(result.exit_code or 0))
+                process.stderr.write(result.stderr)
+            self._set_exit_status(process, 124 if result.timed_out else int(result.exit_code or 0))
+            return not result.timed_out
         except Exception as exc:
             print(f"hostbridge mock-ssh exec failed: {exc}", file=sys.stderr, flush=True)
-            process.stderr.write(f"hostbridge mock-ssh error: {exc}\n")
-            process.exit(1)
+            with suppress(Exception):
+                process.stderr.write(f"hostbridge mock-ssh error: {exc}\n".encode("utf-8", errors="replace"))
+            status = 124 if isinstance(exc, HostBridgeError) and exc.code == "timeout" else 1
+            self._set_exit_status(process, status)
+            return False
 
-    async def _read_exec_stdin(self, process: asyncssh.SSHServerProcess[str]) -> bytes | None:
+    @staticmethod
+    def _set_exit_status(process: asyncssh.SSHServerProcess[bytes], status: int) -> None:
+        with suppress(Exception):
+            process.exit(status)
+
+    async def _read_exec_stdin(self, process: asyncssh.SSHServerProcess[bytes], command: str) -> bytes | None:
+        waits_for_eof = _command_reads_stdin(command)
         if process.stdin.at_eof():
-            return b""
+            return b"" if waits_for_eof else None
         try:
-            first_chunk = await asyncio.wait_for(process.stdin.read(4096), timeout=EXEC_STDIN_PROBE_TIMEOUT)
+            first_chunk = await asyncio.wait_for(
+                process.stdin.read(4096),
+                timeout=self._timeout if waits_for_eof else EXEC_STDIN_PROBE_TIMEOUT,
+            )
         except TimeoutError:
+            if waits_for_eof:
+                raise HostBridgeError("timeout", "timed out waiting for mock-ssh exec stdin") from None
             return None
         if not first_chunk:
-            return b""
+            return b"" if waits_for_eof else None
 
         first_chunk_bytes = _to_bytes(first_chunk)
         total = len(first_chunk_bytes)
@@ -129,7 +152,7 @@ class HostBridgeSSHProcess:
             chunks.append(chunk_bytes)
         return b"".join(chunks)
 
-    async def _run_shell(self, process: asyncssh.SSHServerProcess[str], session_id: str) -> None:
+    async def _run_shell(self, process: asyncssh.SSHServerProcess[bytes], session_id: str) -> None:
         loop = asyncio.get_running_loop()
         stop = asyncio.Event()
         input_done = asyncio.Event()
@@ -167,7 +190,7 @@ class HostBridgeSSHProcess:
                     )
                     if result.data:
                         idle_after_input = 0
-                        process.stdout.write(result.data.decode("utf-8", errors="replace"))
+                        process.stdout.write(result.data)
                     elif input_done.is_set():
                         idle_after_input += 1
                         if idle_after_input >= 5:
@@ -178,7 +201,8 @@ class HostBridgeSSHProcess:
                         break
             except Exception as exc:
                 print(f"hostbridge mock-ssh shell failed: {exc}", file=sys.stderr, flush=True)
-                process.stderr.write(f"hostbridge mock-ssh shell error: {exc}\n")
+                with suppress(Exception):
+                    process.stderr.write(f"hostbridge mock-ssh shell error: {exc}\n".encode("utf-8", errors="replace"))
                 stop.set()
 
         tasks = [asyncio.create_task(pump_input()), asyncio.create_task(pump_output())]
@@ -186,7 +210,7 @@ class HostBridgeSSHProcess:
         for task in tasks:
             task.cancel()
         await asyncio.gather(*tasks, return_exceptions=True)
-        process.exit(0)
+        self._set_exit_status(process, 0)
 
 
 @dataclass
@@ -211,14 +235,74 @@ class HostBridgeSessionFactory:
         self._client = client
         self._host_id = host_id
         self._connect_timeout = connect_timeout
+        self._lock = threading.Lock()
+        self._idle: list[str] = []
+        self._leased: set[str] = set()
+        self._shutdown = False
 
     def open(self) -> str:
-        session = self._client.open_session(self._host_id, owner="mock-ssh")
-        return session.session_id
-
-    def close(self, session_id: str) -> None:
-        with _suppress_error():
-            self._client.close_session(session_id, owner="mock-ssh", force=True)
+        with self._lock:
+            if self._shutdown:
+                raise RuntimeError("mock-ssh session factory is shut down")
+            if self._idle:
+                session_id = self._idle.pop()
+                self._leased.add(session_id)
+                return session_id
+        session = self._client.open_session(
+            self._host_id,
+            owner="mock-ssh",
+            timeout=self._connect_timeout + 5,
+        )
+        session_id = session.session_id
+        with self._lock:
+            if not self._shutdown:
+                self._leased.add(session_id)
+                return session_id
+        self._close_backend(session_id)
+        raise RuntimeError("mock-ssh session factory is shut down")
+
+    def close(self, session_id: str, *, reusable: bool = True) -> None:
+        should_close = False
+        with self._lock:
+            if session_id not in self._leased:
+                return
+            self._leased.remove(session_id)
+            if reusable and not self._shutdown and len(self._idle) < MAX_IDLE_BACKEND_SESSIONS:
+                self._idle.append(session_id)
+            else:
+                should_close = True
+        if not should_close:
+            return
+        self._close_backend(session_id)
+
+    def shutdown(self) -> None:
+        with self._lock:
+            self._shutdown = True
+            session_ids = [*self._idle, *self._leased]
+            self._idle.clear()
+            self._leased.clear()
+        for session_id in session_ids:
+            self._close_backend(session_id)
+
+    def _close_backend(self, session_id: str) -> None:
+        last_error: Exception | None = None
+        for attempt in range(2):
+            try:
+                self._client.close_session(session_id, owner="mock-ssh", force=True)
+                return
+            except HostBridgeError as exc:
+                if exc.code == "not_found":
+                    return
+                last_error = exc
+            except Exception as exc:
+                last_error = exc
+            if attempt == 0:
+                time.sleep(0.05)
+        print(
+            f"hostbridge mock-ssh failed to close backend session {session_id}: {last_error}",
+            file=sys.stderr,
+            flush=True,
+        )
 
 
 class HostBridgeSFTPServer(asyncssh.SFTPServer):
@@ -476,17 +560,19 @@ print(json.dumps(items))
         except HostBridgeError as exc:
             raise self._sftp_error(exc) from exc
         output = result.stdout.decode("utf-8", errors="replace")
+        stderr = result.stderr.decode("utf-8", errors="replace")
         if result.timed_out:
             print(f"hostbridge mock-ssh sftp command timed out: {command}", file=sys.stderr, flush=True)
             raise asyncssh.SFTPFailure("remote command timed out")
         if result.exit_code not in (0, None):
+            error_output = "\n".join(part for part in (output, stderr) if part).strip()
             error = self._sftp_error(
-                HostBridgeError("remote_error", output or f"remote command exited {result.exit_code}")
+                HostBridgeError("remote_error", error_output or f"remote command exited {result.exit_code}")
             )
             if isinstance(error, asyncssh.SFTPNoSuchFile):
                 raise error
             print(
-                f"hostbridge mock-ssh sftp command failed exit={result.exit_code}: {command}\n{output}",
+                f"hostbridge mock-ssh sftp command failed exit={result.exit_code}: {command}\n{error_output}",
                 file=sys.stderr,
                 flush=True,
             )
@@ -568,6 +654,7 @@ async def create_server_on_available_port(
                 process_factory=process_factory,
                 sftp_factory=sftp_factory,
                 allow_scp=True,
+                encoding=None,
             )
             return server, int(candidate)
         except OSError as exc:
@@ -718,8 +805,11 @@ async def serve_mock_ssh(
         print(f"ssh config: {installed_config_path}", flush=True)
     print(f"identity file: {client_key_path}", flush=True)
     print("supports SSH exec, shell, SFTP, and SCP; press Ctrl-C to stop", flush=True)
-    await server.wait_closed()
-    return 0
+    try:
+        await server.wait_closed()
+        return 0
+    finally:
+        session_factory.shutdown()
 
 
 def run_mock_ssh(**kwargs: object) -> int:

package/src/server_control_mcp/secrets.py

@@ -43,6 +43,14 @@ def encrypt_secret(value: str) -> dict[str, str]:
 def decrypt_secret(payload: Any) -> str:
     if not isinstance(payload, dict):
         raise ValueError("encrypted secret must be an object")
+    if set(payload) == {"env"}:
+        variable = payload.get("env")
+        if not isinstance(variable, str) or not variable:
+            raise ValueError("secret environment variable name must not be empty")
+        value = os.environ.get(variable)
+        if value is None:
+            raise ValueError(f"secret environment variable is not set: {variable}")
+        return value
     if payload.get("scheme") != SCHEME:
         raise ValueError(f"unsupported secret scheme: {payload.get('scheme')}")
     ciphertext = payload.get("ciphertext")

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; }"
+PTY_BASE64_LINE_LENGTH = 3072
 
 
 class ChildProcess(Protocol):
@@ -60,6 +61,10 @@ def _default_child_factory(command: str, args: list[str], timeout: int | float)
 
 
 def _iter_base64(chunks: Iterable[bytes]) -> Iterator[str]:
+    def split_line(encoded: str) -> Iterator[str]:
+        for offset in range(0, len(encoded), PTY_BASE64_LINE_LENGTH):
+            yield encoded[offset : offset + PTY_BASE64_LINE_LENGTH]
+
     remainder = b""
     for chunk in chunks:
         if not isinstance(chunk, bytes):
@@ -67,10 +72,10 @@ def _iter_base64(chunks: Iterable[bytes]) -> Iterator[str]:
         data = remainder + chunk
         complete = len(data) - (len(data) % 3)
         if complete:
-            yield base64.b64encode(data[:complete]).decode("ascii")
+            yield from split_line(base64.b64encode(data[:complete]).decode("ascii"))
         remainder = data[complete:]
     if remainder:
-        yield base64.b64encode(remainder).decode("ascii")
+        yield from split_line(base64.b64encode(remainder).decode("ascii"))
 
 
 def _marker_text(value: object) -> str:
@@ -158,13 +163,12 @@ class PtyTransport:
                 raise TransportError("PTY transport is not alive")
             if stdin is not None:
                 stdin_path = self._stage_stdin_locked(stdin, timeout=timeout)
-                command = f"{command} < {shlex.quote(stdin_path)}"
-            return self._exec_locked(command, timeout=timeout, output_limit=output_limit)
+            return self._exec_locked(command, timeout=timeout, output_limit=output_limit, stdin_path=stdin_path)
         finally:
             if stdin_path is not None and self.child.isalive():
                 with suppress(Exception):
                     self._exec_locked(
-                        f"rm -f -- {shlex.quote(stdin_path)}",
+                        f"trap - EXIT HUP INT TERM; rm -f -- {shlex.quote(stdin_path)} {shlex.quote(f'{stdin_path}.b64')}",
                         timeout=min(timeout, 10),
                         output_limit=1024,
                     )
@@ -173,32 +177,50 @@ 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"
         heredoc = f"__{self._marker_prefix}_STDIN_{token}__"
         done_pattern = re.compile(rf"__{self._marker_prefix}_STDIN_DONE_{re.escape(token)}__:(\d+)")
-        self.child.send(f"cat > {shlex.quote(path)} <<'{heredoc}'\n")
-        for encoded in _iter_base64(chunks):
-            self.child.send(encoded)
-        self.child.send(
-            f"\n{heredoc}\n"
-            f"tmp={shlex.quote(path)}.b64; mv {shlex.quote(path)} \"$tmp\"; "
-            f"{{ {_REMOTE_BASE64_DECODE} < \"$tmp\"; }} > {shlex.quote(path)}; status=$?; rm -f \"$tmp\"; "
-            f"printf '\n__{self._marker_prefix}_STDIN_DONE_{token}__:%s\n' \"$status\"\n"
-        )
-        self.child.expect(done_pattern, timeout=timeout)
+        cleanup = f"rm -f -- {shlex.quote(path)} {shlex.quote(base64_path)}"
+        try:
+            self.child.send(f"trap {shlex.quote(cleanup)} EXIT HUP INT TERM; cat > {shlex.quote(path)} <<'{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"printf '\n__{self._marker_prefix}_STDIN_DONE_{token}__:%s\n' \"$status\"\n"
+            )
+            self.child.expect(done_pattern, timeout=timeout)
+        except BaseException:
+            if self.child.isalive():
+                with suppress(Exception):
+                    self.child.send("\x03")
+                with suppress(Exception):
+                    self.child.sendline(f"trap - EXIT HUP INT TERM; {cleanup}")
+            raise
         match = re.search(r":(\d+)", _marker_text(self.child.after))
         if match is None or int(match.group(1)) != 0:
             raise TransportError("failed to stage PTY stdin")
         return path
 
-    def _exec_locked(self, command: str, *, timeout: float, output_limit: int) -> ExecResult:
+    def _exec_locked(
+        self,
+        command: str,
+        *,
+        timeout: float,
+        output_limit: int,
+        stdin_path: str | None = None,
+    ) -> ExecResult:
         token = self._token_factory()
         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 ""
         remote_line = (
             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\"; "
+            f"{self.remote_shell} -lc \"$__scm_cmd\"{stdin_redirect}; "
             "__scm_status=$?; "
             f"printf '\n__{self._marker_prefix}_EXIT_{token}__:%s\n' \"$__scm_status\""
         )
@@ -321,13 +343,20 @@ class PtyTransport:
                     raise TransportError("PTY transport is not alive")
                 remote_q = shlex.quote(remote_path)
                 metadata = (
-                    f"target={remote_q}; bytes=$(wc -c < \"$target\" | tr -d ' '); "
+                    f"target={remote_q}; "
+                    'if [ ! -e "$target" ] && [ ! -L "$target" ]; then printf "__HB_FILE_NOT_FOUND__\\n"; exit 44; fi; '
+                    'if [ ! -r "$target" ]; then printf "__HB_PERMISSION_DENIED__\\n"; exit 45; fi; '
+                    "bytes=$(wc -c < \"$target\" | tr -d ' '); "
                     "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; "
                     'printf "BYTES=%s\\nSHA256=%s\\n" "$bytes" "$sha"'
                 )
                 result = self._exec_locked(metadata, timeout=60, output_limit=4096)
                 if result.timed_out or result.exit_code != 0:
+                    if b"__HB_FILE_NOT_FOUND__" in result.stdout:
+                        raise TransportError(f"remote file not found: {remote_path}")
+                    if b"__HB_PERMISSION_DENIED__" in result.stdout:
+                        raise TransportError(f"permission denied reading remote file: {remote_path}")
                     raise TransportError(f"failed to inspect remote file {remote_path}")
                 fields = self._metadata_fields(result.stdout)
                 byte_count = int(fields.get("BYTES", "0"))