@neoline/hostbridge 2.0.4 → 2.0.5

package/src/server_control_mcp/protocol.py

@@ -1,363 +0,0 @@
-"""Versioned wire models for the HostBridge daemon protocol."""
-
-from __future__ import annotations
-
-import json
-import struct
-import threading
-import uuid
-from dataclasses import dataclass, field
-from enum import IntFlag
-from typing import Any, BinaryIO
-
-PROTOCOL_VERSION = 1
-MAX_FRAME_BYTES = 1024 * 1024
-MAX_STREAM_ID_BYTES = 4096
-_FRAME_MAGIC = b"HBV1"
-_FRAME_HEADER = struct.Struct("!4sBBHIII")
-
-
-class ProtocolError(ValueError):
-    """Raised when a wire message does not conform to protocol v1."""
-
-
-class FrameFlags(IntFlag):
-    DATA = 1
-    EOF = 2
-    CANCEL = 4
-
-
-@dataclass(frozen=True, slots=True)
-class BinaryFrame:
-    stream_id: str
-    sequence: int
-    flags: FrameFlags
-    payload: bytes = b""
-
-
-def encode_frame(frame: BinaryFrame) -> bytes:
-    stream_id = _required_text(frame.stream_id, "stream_id").encode("utf-8")
-    if len(stream_id) > MAX_STREAM_ID_BYTES:
-        raise ProtocolError(f"stream_id exceeds {MAX_STREAM_ID_BYTES} bytes")
-    if not isinstance(frame.sequence, int) or isinstance(frame.sequence, bool) or frame.sequence < 0:
-        raise ProtocolError("sequence must be a non-negative integer")
-    if frame.sequence > 0xFFFFFFFF:
-        raise ProtocolError("sequence exceeds frame limit")
-    if not isinstance(frame.flags, FrameFlags) or not frame.flags:
-        raise ProtocolError("flags must contain a supported frame flag")
-    if int(frame.flags) & ~int(FrameFlags.DATA | FrameFlags.EOF | FrameFlags.CANCEL):
-        raise ProtocolError("flags contain an unsupported frame flag")
-    if not isinstance(frame.payload, bytes):
-        raise ProtocolError("frame payload must be bytes")
-    if len(frame.payload) > MAX_FRAME_BYTES:
-        raise ProtocolError(f"frame payload exceeds {MAX_FRAME_BYTES} bytes")
-    header = _FRAME_HEADER.pack(
-        _FRAME_MAGIC,
-        PROTOCOL_VERSION,
-        int(frame.flags),
-        0,
-        frame.sequence,
-        len(stream_id),
-        len(frame.payload),
-    )
-    return header + stream_id + frame.payload
-
-
-def decode_frame(data: bytes) -> tuple[BinaryFrame, bytes]:
-    if not isinstance(data, bytes):
-        raise ProtocolError("frame data must be bytes")
-    sequence, flags, stream_id_length, payload_length = _decode_header(data)
-    frame_length = _FRAME_HEADER.size + stream_id_length + payload_length
-    if len(data) < frame_length:
-        raise ProtocolError("incomplete frame payload")
-    stream_id_start = _FRAME_HEADER.size
-    payload_start = stream_id_start + stream_id_length
-    try:
-        stream_id = data[stream_id_start:payload_start].decode("utf-8")
-    except UnicodeDecodeError as exc:
-        raise ProtocolError("stream_id must be valid UTF-8") from exc
-    payload = data[payload_start:frame_length]
-    return BinaryFrame(_required_text(stream_id, "stream_id"), sequence, flags, payload), data[frame_length:]
-
-
-def _decode_header(data: bytes) -> tuple[int, FrameFlags, int, int]:
-    if len(data) < _FRAME_HEADER.size:
-        raise ProtocolError("incomplete frame header")
-    magic, protocol, raw_flags, reserved, sequence, stream_id_length, payload_length = _FRAME_HEADER.unpack_from(data)
-    if magic != _FRAME_MAGIC:
-        raise ProtocolError("invalid frame magic")
-    if protocol != PROTOCOL_VERSION:
-        raise ProtocolError(f"unsupported protocol: {protocol!r}")
-    if reserved != 0:
-        raise ProtocolError("reserved frame bits must be zero")
-    if stream_id_length > MAX_STREAM_ID_BYTES:
-        raise ProtocolError(f"stream_id exceeds {MAX_STREAM_ID_BYTES} bytes")
-    if payload_length > MAX_FRAME_BYTES:
-        raise ProtocolError(f"frame payload exceeds {MAX_FRAME_BYTES} bytes")
-    try:
-        flags = FrameFlags(raw_flags)
-    except ValueError as exc:
-        raise ProtocolError("flags contain an unsupported frame flag") from exc
-    if not flags or int(flags) & ~int(FrameFlags.DATA | FrameFlags.EOF | FrameFlags.CANCEL):
-        raise ProtocolError("flags contain an unsupported frame flag")
-    return sequence, flags, stream_id_length, payload_length
-
-
-def _read_exact(stream: BinaryIO, size: int) -> bytes:
-    chunks = bytearray()
-    while len(chunks) < size:
-        chunk = stream.read(size - len(chunks))
-        if not chunk:
-            raise ProtocolError("incomplete frame")
-        chunks.extend(chunk)
-    return bytes(chunks)
-
-
-def read_frame(stream: BinaryIO) -> BinaryFrame:
-    header = _read_exact(stream, _FRAME_HEADER.size)
-    _, _, stream_id_length, payload_length = _decode_header(header)
-    body = _read_exact(stream, stream_id_length + payload_length)
-    frame, remainder = decode_frame(header + body)
-    if remainder:
-        raise ProtocolError("frame reader consumed trailing bytes")
-    return frame
-
-
-class StreamWindow:
-    """Thread-safe credit window used to apply stream backpressure."""
-
-    def __init__(self, initial_credit: int):
-        if not isinstance(initial_credit, int) or isinstance(initial_credit, bool) or initial_credit < 0:
-            raise ValueError("initial_credit must be a non-negative integer")
-        self._credit = initial_credit
-        self._closed = False
-        self._condition = threading.Condition()
-
-    def acquire_nowait(self) -> bool:
-        with self._condition:
-            if self._closed or self._credit == 0:
-                return False
-            self._credit -= 1
-            return True
-
-    def acquire(self, timeout: float | None = None) -> bool:
-        with self._condition:
-            ready = self._condition.wait_for(lambda: self._closed or self._credit > 0, timeout=timeout)
-            if not ready or self._closed:
-                return False
-            self._credit -= 1
-            return True
-
-    def ack(self, count: int = 1) -> None:
-        if not isinstance(count, int) or isinstance(count, bool) or count <= 0:
-            raise ValueError("count must be a positive integer")
-        with self._condition:
-            if self._closed:
-                return
-            self._credit += count
-            self._condition.notify_all()
-
-    def close(self) -> None:
-        with self._condition:
-            self._closed = True
-            self._condition.notify_all()
-
-
-class FrameSequenceValidator:
-    """Reject missing or repeated frames independently for each stream."""
-
-    def __init__(self) -> None:
-        self._next_by_stream: dict[str, int] = {}
-
-    def accept(self, frame: BinaryFrame) -> None:
-        expected = self._next_by_stream.get(frame.stream_id, 0)
-        if frame.sequence != expected:
-            raise ProtocolError(f"stream {frame.stream_id!r} expected sequence {expected}, received {frame.sequence}")
-        self._next_by_stream[frame.stream_id] = expected + 1
-
-
-def _parse_object(payload: str) -> dict[str, Any]:
-    try:
-        value = json.loads(payload)
-    except (json.JSONDecodeError, TypeError) as exc:
-        raise ProtocolError("invalid JSON object") from exc
-    if not isinstance(value, dict):
-        raise ProtocolError("message must be a JSON object")
-    return value
-
-
-def _required_text(value: object, field: str) -> str:
-    if not isinstance(value, str) or not value.strip():
-        raise ProtocolError(f"{field} must be a non-empty string")
-    return value
-
-
-def _protocol(value: dict[str, Any]) -> int:
-    protocol = value.get("protocol")
-    if protocol != PROTOCOL_VERSION:
-        raise ProtocolError(f"unsupported protocol: {protocol!r}")
-    return PROTOCOL_VERSION
-
-
-def _object(value: object, field_name: str) -> dict[str, object]:
-    if not isinstance(value, dict):
-        raise ProtocolError(f"{field_name} must be a JSON object")
-    return value
-
-
-@dataclass(frozen=True, slots=True)
-class ErrorInfo:
-    code: str
-    message: str
-    retryable: bool = False
-    details: dict[str, object] = field(default_factory=dict)
-
-    @classmethod
-    def from_dict(cls, value: object) -> ErrorInfo:
-        data = _object(value, "error")
-        retryable = data.get("retryable", False)
-        if not isinstance(retryable, bool):
-            raise ProtocolError("error.retryable must be a boolean")
-        return cls(
-            code=_required_text(data.get("code"), "error.code"),
-            message=_required_text(data.get("message"), "error.message"),
-            retryable=retryable,
-            details=_object(data.get("details", {}), "error.details"),
-        )
-
-    def to_dict(self) -> dict[str, object]:
-        return {
-            "code": self.code,
-            "message": self.message,
-            "retryable": self.retryable,
-            "details": self.details,
-        }
-
-
-@dataclass(frozen=True, slots=True)
-class Request:
-    protocol: int
-    request_id: str
-    method: str
-    params: dict[str, object]
-
-    @classmethod
-    def new(
-        cls,
-        method: str,
-        params: dict[str, object],
-        *,
-        request_id: str | None = None,
-    ) -> Request:
-        return cls(
-            protocol=PROTOCOL_VERSION,
-            request_id=_required_text(request_id or uuid.uuid4().hex, "request_id"),
-            method=_required_text(method, "method"),
-            params=dict(params),
-        )
-
-    @classmethod
-    def from_json(cls, payload: str) -> Request:
-        value = _parse_object(payload)
-        return cls(
-            protocol=_protocol(value),
-            request_id=_required_text(value.get("request_id"), "request_id"),
-            method=_required_text(value.get("method"), "method"),
-            params=_object(value.get("params"), "params"),
-        )
-
-    def to_json(self) -> str:
-        return json.dumps(
-            {
-                "protocol": self.protocol,
-                "request_id": self.request_id,
-                "method": self.method,
-                "params": self.params,
-            },
-            ensure_ascii=False,
-            separators=(",", ":"),
-        )
-
-
-@dataclass(frozen=True, slots=True)
-class Response:
-    protocol: int
-    request_id: str
-    ok: bool
-    result: dict[str, object] = field(default_factory=dict)
-    error: ErrorInfo | None = None
-
-    @classmethod
-    def success(cls, request_id: str, result: dict[str, object]) -> Response:
-        return cls(PROTOCOL_VERSION, _required_text(request_id, "request_id"), True, dict(result))
-
-    @classmethod
-    def failure(cls, request_id: str, error: ErrorInfo) -> Response:
-        return cls(PROTOCOL_VERSION, _required_text(request_id, "request_id"), False, {}, error)
-
-    @classmethod
-    def from_json(cls, payload: str) -> Response:
-        value = _parse_object(payload)
-        ok = value.get("ok")
-        if not isinstance(ok, bool):
-            raise ProtocolError("ok must be a boolean")
-        request_id = _required_text(value.get("request_id"), "request_id")
-        protocol = _protocol(value)
-        if ok:
-            if value.get("error") is not None:
-                raise ProtocolError("successful response must not contain error")
-            return cls(protocol, request_id, True, _object(value.get("result", {}), "result"))
-        if value.get("result") not in (None, {}):
-            raise ProtocolError("failed response must not contain result")
-        return cls(protocol, request_id, False, {}, ErrorInfo.from_dict(value.get("error")))
-
-    def to_json(self) -> str:
-        payload: dict[str, object] = {
-            "protocol": self.protocol,
-            "request_id": self.request_id,
-            "ok": self.ok,
-        }
-        if self.ok:
-            payload["result"] = self.result
-        elif self.error is not None:
-            payload["error"] = self.error.to_dict()
-        return json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
-
-
-@dataclass(frozen=True, slots=True)
-class Event:
-    protocol: int
-    request_id: str
-    stream_id: str
-    sequence: int
-    event: str
-    data: dict[str, object] = field(default_factory=dict)
-
-    @classmethod
-    def from_json(cls, payload: str) -> Event:
-        value = _parse_object(payload)
-        sequence = value.get("sequence")
-        if not isinstance(sequence, int) or isinstance(sequence, bool) or sequence < 0:
-            raise ProtocolError("sequence must be a non-negative integer")
-        return cls(
-            protocol=_protocol(value),
-            request_id=_required_text(value.get("request_id"), "request_id"),
-            stream_id=_required_text(value.get("stream_id"), "stream_id"),
-            sequence=sequence,
-            event=_required_text(value.get("event"), "event"),
-            data=_object(value.get("data", {}), "data"),
-        )
-
-    def to_json(self) -> str:
-        return json.dumps(
-            {
-                "protocol": self.protocol,
-                "request_id": self.request_id,
-                "stream_id": self.stream_id,
-                "sequence": self.sequence,
-                "event": self.event,
-                "data": self.data,
-            },
-            ensure_ascii=False,
-            separators=(",", ":"),
-        )

package/src/server_control_mcp/remote_tunnel_agent.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-import shlex
-
-REMOTE_TUNNEL_AGENT = r"""
-import base64
-import os
-import socket
-import sys
-import termios
-import threading
-
-host, port, prefix = sys.argv[1], int(sys.argv[2]), sys.argv[3]
-prefix_bytes = prefix.encode("ascii")
-write_lock = threading.Lock()
-downstream_sequence = 0
-upstream_sequence = 0
-terminal_attributes = None
-connection = None
-receiver_error = []
-
-
-def emit(kind, payload=b"", status=None):
-    global downstream_sequence
-    status_text = "-" if status is None else str(status)
-    encoded = base64.b64encode(payload).decode("ascii")
-    with write_lock:
-        line = "%s:V1:D:%d:%s:%s:%s" % (
-            prefix,
-            downstream_sequence,
-            kind,
-            status_text,
-            encoded,
-        )
-        downstream_sequence += 1
-        print(line, flush=True)
-
-
-def disable_echo():
-    global terminal_attributes
-    if not os.isatty(sys.stdin.fileno()):
-        return
-    terminal_attributes = termios.tcgetattr(sys.stdin.fileno())
-    updated = list(terminal_attributes)
-    updated[3] &= ~termios.ECHO
-    termios.tcsetattr(sys.stdin.fileno(), termios.TCSANOW, updated)
-
-
-def restore_terminal():
-    if terminal_attributes is not None:
-        termios.tcsetattr(sys.stdin.fileno(), termios.TCSANOW, terminal_attributes)
-
-
-def decode_upstream(raw_line):
-    global upstream_sequence
-    line = raw_line.rstrip(b"\r\n")
-    marker = prefix_bytes + b":V"
-    offset = line.find(marker)
-    if offset < 0:
-        return None
-    fields = line[offset:].split(b":", 6)
-    if len(fields) != 7:
-        raise ValueError("malformed upstream frame")
-    frame_prefix, version, direction, sequence, kind, status, payload = fields
-    if frame_prefix != prefix_bytes or version != b"V1" or direction != b"U":
-        raise ValueError("invalid upstream frame header")
-    if int(sequence) != upstream_sequence:
-        raise ValueError("unexpected upstream frame sequence")
-    upstream_sequence += 1
-    if status != b"-":
-        raise ValueError("upstream frame must not contain status")
-    kind_text = kind.decode("ascii")
-    if kind_text not in {"DATA", "EOF"}:
-        raise ValueError("invalid upstream frame kind")
-    decoded = base64.b64decode(payload, validate=True)
-    if kind_text == "EOF" and decoded:
-        raise ValueError("upstream EOF must not contain payload")
-    return kind_text, decoded
-
-
-def receive():
-    try:
-        while True:
-            data = connection.recv(16 * 1024)
-            if not data:
-                emit("EOF")
-                return
-            emit("DATA", data)
-    except Exception as exc:
-        receiver_error.append(exc)
-        emit("ERROR", str(exc).encode("utf-8", errors="replace"))
-
-
-status = 0
-try:
-    disable_echo()
-    connection = socket.create_connection((host, port), timeout=15)
-    connection.settimeout(None)
-    emit("READY")
-    receiver = threading.Thread(target=receive, daemon=True)
-    receiver.start()
-    saw_upstream_eof = False
-    for raw_line in sys.stdin.buffer:
-        frame = decode_upstream(raw_line)
-        if frame is None:
-            continue
-        kind, payload = frame
-        if kind == "DATA":
-            connection.sendall(payload)
-        else:
-            connection.shutdown(socket.SHUT_WR)
-            saw_upstream_eof = True
-            break
-    if not saw_upstream_eof:
-        raise EOFError("upstream tunnel closed without EOF frame")
-    receiver.join()
-    if receiver_error:
-        status = 1
-except Exception as exc:
-    status = 1
-    emit("ERROR", str(exc).encode("utf-8", errors="replace"))
-finally:
-    if connection is not None:
-        try:
-            connection.close()
-        except Exception:
-            status = 1
-    try:
-        restore_terminal()
-    except Exception as exc:
-        status = 1
-        emit("ERROR", str(exc).encode("utf-8", errors="replace"))
-    emit("CLOSED", status=status)
-
-raise SystemExit(status)
-"""
-
-
-def build_remote_tunnel_command(dest_host: str, dest_port: int, prefix: str) -> bytes:
-    command = (
-        f"python3 -u -c {shlex.quote(REMOTE_TUNNEL_AGENT)} {shlex.quote(dest_host)} {dest_port} {shlex.quote(prefix)}\n"
-    )
-    return command.encode("utf-8")