@neoline/hostbridge 1.4.4 → 2.0.1

package/src/server_control_mcp/daemon.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import base64
+import binascii
+import hashlib
 import json
 import os
-import signal
 import socket
 import subprocess
 import sys
@@ -12,30 +14,29 @@ from contextlib import suppress
 from dataclasses import asdict
 from pathlib import Path
 from socketserver import StreamRequestHandler, ThreadingMixIn, UnixStreamServer
-from typing import Any
-from urllib.parse import parse_qs, urlparse
 
+from .client import HostBridgeClient, HostBridgeError
+from .config import load_v1_config
 from .hosts import HostRegistry, load_hosts
-from .manager import (
-    DEFAULT_COMMAND_TIMEOUT,
-    DEFAULT_CONNECT_TIMEOUT,
-    DEFAULT_MAX_TRANSFER_BYTES,
-    PolicyDeniedError,
-    RemoteCommandError,
-    SessionManager,
-    _new_token,
-)
 from .policy import build_audit_sink, load_policy
+from .protocol import (
+    PROTOCOL_VERSION,
+    BinaryFrame,
+    ErrorInfo,
+    FrameFlags,
+    FrameSequenceValidator,
+    ProtocolError,
+    Request,
+    Response,
+    encode_frame,
+    read_frame,
+)
+from .runtime import runtime_paths
+from .services import HostBridgeServices, ServiceError
+from .transports.pty import PtyTransport
 
-DEFAULT_DAEMON_DIR = Path("~/.hostbridge")
-DEFAULT_SOCKET_FILE = DEFAULT_DAEMON_DIR / "daemon.sock"
-PID_FILE = DEFAULT_DAEMON_DIR / "daemon.pid"
-LOG_FILE = DEFAULT_DAEMON_DIR / "daemon.log"
-
-_ERROR_CODES = {
-    PolicyDeniedError: "denied",
-    RemoteCommandError: "remote_error",
-}
+MAX_V1_CONTROL_LINE_BYTES = 4 * 1024 * 1024
+DEFAULT_CONNECT_TIMEOUT = 30
 
 
 class ThreadingUnixRPCServer(ThreadingMixIn, UnixStreamServer):
@@ -43,268 +44,372 @@ class ThreadingUnixRPCServer(ThreadingMixIn, UnixStreamServer):
     allow_reuse_address = True
 
 
-def _ok(**payload: object) -> dict[str, object]:
-    return {"ok": True, **payload}
-
-
-def _error_code(exc: Exception) -> str:
-    for exc_type, code in _ERROR_CODES.items():
-        if isinstance(exc, exc_type):
-            return code
-    text = str(exc).lower()
-    if "unknown host" in text or "unknown session" in text or "unknown task" in text:
-        return "not_found"
-    return "internal"
-
-
-def _status_for_error(exc: Exception) -> int:
-    code = _error_code(exc)
-    if code == "not_found":
-        return 404
-    if code in {"denied", "remote_error"}:
-        return 409
-    return 500
+def _required_param(params: dict[str, object], name: str) -> str:
+    value = params.get(name)
+    if not isinstance(value, str) or not value.strip():
+        raise ServiceError("invalid_request", f"{name} must be a non-empty string")
+    return value
 
 
-def _error(exc: Exception) -> dict[str, object]:
-    return {"ok": False, "status": _status_for_error(exc), "error": str(exc), "error_code": _error_code(exc)}
+def _optional_owner(params: dict[str, object]) -> str | None:
+    owner = params.get("owner")
+    if owner is not None and not isinstance(owner, str):
+        raise ServiceError("invalid_request", "owner must be a string or null")
+    return owner
 
 
-class HostBridgeDaemonHandler(StreamRequestHandler):
-    """One JSON request per line, one JSON response per line over a Unix socket."""
+def _decode_inline_stdin(value: object) -> list[bytes] | None:
+    if value is None:
+        return None
+    if not isinstance(value, dict) or value.get("encoding") != "base64" or not isinstance(value.get("data"), str):
+        raise ServiceError("invalid_request", "stdin must contain base64 data")
+    try:
+        return [base64.b64decode(value["data"], validate=True)]
+    except (binascii.Error, ValueError) as exc:
+        raise ServiceError("invalid_request", "stdin contains invalid base64") from exc
+
+
+def _encoded_bytes(value: bytes) -> dict[str, str]:
+    return {"encoding": "base64", "data": base64.b64encode(value).decode("ascii")}
+
+
+class HostBridgeV1Dispatcher:
+    def __init__(self, services: HostBridgeServices) -> None:
+        self.services = services
+        self.handlers = {
+            "system.hello": self.system_hello,
+            "system.health": self.system_health,
+            "system.shutdown": self.system_shutdown,
+            "host.list": self.host_list,
+            "session.open": self.session_open,
+            "session.list": self.session_list,
+            "session.close": self.session_close,
+            "session.close_all": self.session_close_all,
+            "exec.start": self.exec_start,
+            "task.start": self.task_start,
+            "task.status": self.task_status,
+            "task.cancel": self.task_cancel,
+            "file.write_text": self.file_write_text,
+            "file.read_text": self.file_read_text,
+            "shell.write": self.shell_write,
+            "shell.read": self.shell_read,
+        }
+
+    def dispatch(self, request: Request) -> Response:
+        handler = self.handlers.get(request.method)
+        if handler is None:
+            return Response.failure(
+                request.request_id,
+                ErrorInfo("not_found", f"unknown method {request.method}"),
+            )
+        try:
+            return Response.success(request.request_id, handler(request.params))
+        except ServiceError as exc:
+            return Response.failure(
+                request.request_id,
+                ErrorInfo(exc.code, str(exc), retryable=exc.retryable, details=exc.details),
+            )
+        except (TypeError, ValueError) as exc:
+            return Response.failure(request.request_id, ErrorInfo("invalid_request", str(exc)))
+        except Exception:
+            return Response.failure(
+                request.request_id, ErrorInfo("internal", "internal HostBridge error", retryable=True)
+            )
 
-    manager: SessionManager
-    registry: HostRegistry
+    def system_hello(self, params: dict[str, object]) -> dict[str, object]:
+        return {
+            "service": "hostbridge",
+            "protocol": PROTOCOL_VERSION,
+            "capabilities": ["sessions", "exec", "explicit_stdin"],
+        }
+
+    def system_health(self, params: dict[str, object]) -> dict[str, object]:
+        return {"status": "ok", "protocol": PROTOCOL_VERSION}
+
+    def system_shutdown(self, params: dict[str, object]) -> dict[str, object]:
+        self.services.stop_idle_reaper()
+        return self.services.close_all()
+
+    def host_list(self, params: dict[str, object]) -> dict[str, object]:
+        return {"hosts": self.services.hosts.describe()}
+
+    def session_open(self, params: dict[str, object]) -> dict[str, object]:
+        session = self.services.open_session(_required_param(params, "host_id"), owner=_optional_owner(params))
+        return session.describe()
+
+    def session_list(self, params: dict[str, object]) -> dict[str, object]:
+        return {"sessions": self.services.list_sessions()}
+
+    def session_close(self, params: dict[str, object]) -> dict[str, object]:
+        force = params.get("force", False)
+        if not isinstance(force, bool):
+            raise ServiceError("invalid_request", "force must be a boolean")
+        session_id = _required_param(params, "session_id")
+        self.services.close_session(session_id, owner=_optional_owner(params), force=force)
+        return {"session_id": session_id, "closed": True}
+
+    def session_close_all(self, params: dict[str, object]) -> dict[str, object]:
+        return self.services.close_all()
+
+    def exec_start(self, params: dict[str, object]) -> dict[str, object]:
+        timeout = params.get("timeout", 60)
+        output_limit = params.get("output_limit", 1_000_000)
+        if not isinstance(timeout, int | float) or isinstance(timeout, bool) or timeout <= 0:
+            raise ServiceError("invalid_request", "timeout must be positive")
+        if not isinstance(output_limit, int) or isinstance(output_limit, bool) or output_limit <= 0:
+            raise ServiceError("invalid_request", "output_limit must be a positive integer")
+        result = self.services.exec(
+            _required_param(params, "session_id"),
+            _required_param(params, "command"),
+            stdin=_decode_inline_stdin(params.get("stdin")),
+            timeout=float(timeout),
+            output_limit=output_limit,
+            owner=_optional_owner(params),
+        )
+        return {
+            "session_id": result.session_id,
+            "exit_code": result.exit_code,
+            "stdout": _encoded_bytes(result.stdout),
+            "stderr": _encoded_bytes(result.stderr),
+            "timed_out": result.timed_out,
+        }
+
+    def task_start(self, params: dict[str, object]) -> dict[str, object]:
+        task = self.services.start_task(
+            _required_param(params, "session_id"),
+            _required_param(params, "command"),
+            owner=_optional_owner(params),
+        )
+        return asdict(task)
+
+    def task_status(self, params: dict[str, object]) -> dict[str, object]:
+        tail_lines = params.get("tail_lines", 80)
+        if not isinstance(tail_lines, int) or isinstance(tail_lines, bool):
+            raise ServiceError("invalid_request", "tail_lines must be an integer")
+        return self.services.task_status(
+            _required_param(params, "session_id"),
+            _required_param(params, "task_id"),
+            owner=_optional_owner(params),
+            tail_lines=tail_lines,
+        )
+
+    def task_cancel(self, params: dict[str, object]) -> dict[str, object]:
+        return self.services.cancel_task(
+            _required_param(params, "session_id"),
+            _required_param(params, "task_id"),
+            owner=_optional_owner(params),
+        )
+
+    def file_write_text(self, params: dict[str, object]) -> dict[str, object]:
+        content = params.get("content")
+        mode = params.get("mode", 0o644)
+        max_bytes = params.get("max_bytes", 4 * 1024 * 1024)
+        if not isinstance(content, str):
+            raise ServiceError("invalid_request", "content must be a string")
+        if not isinstance(mode, int) or isinstance(mode, bool):
+            raise ServiceError("invalid_request", "mode must be an integer")
+        if not isinstance(max_bytes, int) or isinstance(max_bytes, bool) or max_bytes <= 0:
+            raise ServiceError("invalid_request", "max_bytes must be a positive integer")
+        result = self.services.write_text(
+            _required_param(params, "session_id"),
+            _required_param(params, "remote_path"),
+            content,
+            mode=mode,
+            max_bytes=max_bytes,
+            owner=_optional_owner(params),
+        )
+        return {"bytes_transferred": result.bytes_transferred, "sha256": result.sha256}
+
+    def file_read_text(self, params: dict[str, object]) -> dict[str, object]:
+        max_bytes = params.get("max_bytes", 4 * 1024 * 1024)
+        if not isinstance(max_bytes, int) or isinstance(max_bytes, bool) or max_bytes <= 0:
+            raise ServiceError("invalid_request", "max_bytes must be a positive integer")
+        content = self.services.read_text(
+            _required_param(params, "session_id"),
+            _required_param(params, "remote_path"),
+            max_bytes=max_bytes,
+            owner=_optional_owner(params),
+        )
+        return {"content": content, "bytes_transferred": len(content.encode("utf-8"))}
+
+    def shell_write(self, params: dict[str, object]) -> dict[str, object]:
+        chunks = _decode_inline_stdin(params.get("data"))
+        if chunks is None:
+            raise ServiceError("invalid_request", "data must contain base64 bytes")
+        written = self.services.shell_write(
+            _required_param(params, "session_id"),
+            b"".join(chunks),
+            owner=_optional_owner(params),
+        )
+        return {"written": written}
+
+    def shell_read(self, params: dict[str, object]) -> dict[str, object]:
+        timeout = params.get("timeout", 0.2)
+        max_bytes = params.get("max_bytes", 4096)
+        if not isinstance(timeout, int | float) or isinstance(timeout, bool) or timeout < 0:
+            raise ServiceError("invalid_request", "timeout must be non-negative")
+        if not isinstance(max_bytes, int) or isinstance(max_bytes, bool) or max_bytes <= 0:
+            raise ServiceError("invalid_request", "max_bytes must be a positive integer")
+        result = self.services.shell_read(
+            _required_param(params, "session_id"),
+            timeout=float(timeout),
+            max_bytes=max_bytes,
+            owner=_optional_owner(params),
+        )
+        return {"data": _encoded_bytes(result.data), "alive": result.alive}
+
+
+class HostBridgeV1Handler(StreamRequestHandler):
+    dispatcher: HostBridgeV1Dispatcher
 
     def handle(self) -> None:
-        for raw_line in self.rfile:
+        while raw_line := self.rfile.readline(MAX_V1_CONTROL_LINE_BYTES + 1):
+            request_id = "invalid"
             try:
-                request = json.loads(raw_line.decode("utf-8"))
-                if not isinstance(request, dict):
-                    raise ValueError("request must be a JSON object")
-                response = self.dispatch(request)
-            except Exception as exc:
-                response = _error(exc)
-            self.wfile.write(json.dumps(response, ensure_ascii=False).encode("utf-8") + b"\n")
+                if len(raw_line) > MAX_V1_CONTROL_LINE_BYTES:
+                    raise ProtocolError("request exceeds the control limit")
+                request = Request.from_json(raw_line.decode("utf-8"))
+                request_id = request.request_id
+                if request.method == "transfer.upload":
+                    response = self._handle_upload(request)
+                elif request.method == "transfer.download":
+                    self._handle_download(request)
+                    continue
+                else:
+                    response = self.dispatcher.dispatch(request)
+            except ServiceError as exc:
+                response = Response.failure(
+                    request_id,
+                    ErrorInfo(exc.code, str(exc), retryable=exc.retryable, details=exc.details),
+                )
+            except (ProtocolError, UnicodeDecodeError) as exc:
+                response = Response.failure(request_id, ErrorInfo("invalid_request", str(exc)))
+            self.wfile.write(response.to_json().encode("utf-8") + b"\n")
             self.wfile.flush()
-
-    def dispatch(self, request: dict[str, Any]) -> dict[str, object]:
-        method = str(request.get("method", "GET")).upper()
-        path = str(request.get("path", "/"))
-        body = request.get("body", {})
-        if body is None:
-            body = {}
-        if not isinstance(body, dict):
-            raise ValueError("request body must be a JSON object")
+            if request_id != "invalid" and request.method == "system.shutdown":
+                threading.Thread(target=self.server.shutdown, daemon=True).start()
+
+    def _handle_upload(self, request: Request) -> Response:
+        params = request.params
+        stream_id = _required_param(params, "stream_id")
+        expected_size = params.get("expected_size")
+        mode = params.get("mode", 0o644)
+        if not isinstance(expected_size, int) or isinstance(expected_size, bool) or expected_size < 0:
+            raise ServiceError("invalid_request", "expected_size must be a non-negative integer")
+        if not isinstance(mode, int) or isinstance(mode, bool):
+            raise ServiceError("invalid_request", "mode must be an integer")
+        validator = FrameSequenceValidator()
+
+        def chunks():
+            while True:
+                frame = read_frame(self.rfile)
+                validator.accept(frame)
+                if frame.stream_id != stream_id:
+                    raise ServiceError("invalid_request", "upload frame stream_id does not match")
+                if frame.flags & FrameFlags.CANCEL:
+                    raise ServiceError("cancelled", "upload cancelled")
+                if frame.flags & FrameFlags.DATA:
+                    yield frame.payload
+                if frame.flags & FrameFlags.EOF:
+                    return
+
+        result = self.dispatcher.services.upload(
+            _required_param(params, "session_id"),
+            chunks(),
+            _required_param(params, "remote_path"),
+            mode=mode,
+            expected_size=expected_size,
+            expected_sha256=None,
+            owner=_optional_owner(params),
+        )
+        return Response.success(
+            request.request_id,
+            {"bytes_transferred": result.bytes_transferred, "sha256": result.sha256},
+        )
+
+    def _handle_download(self, request: Request) -> None:
+        params = request.params
+        stream_id = _required_param(params, "stream_id")
+        chunk_size = params.get("chunk_size", 256 * 1024)
+        if not isinstance(chunk_size, int) or isinstance(chunk_size, bool) or not 4096 <= chunk_size <= 1024 * 1024:
+            raise ServiceError("invalid_request", "chunk_size must be between 4096 and 1048576 bytes")
+        response = Response.success(request.request_id, {"stream_id": stream_id})
+        self.wfile.write(response.to_json().encode("utf-8") + b"\n")
+        self.wfile.flush()
+        digest = hashlib.sha256()
+        transferred = 0
+        sequence = 0
         try:
-            return self._dispatch(method, path, body)
-        except Exception as exc:
-            return _error(exc)
-
-    def _dispatch(self, method: str, path: str, body: dict[str, Any]) -> dict[str, object]:
-        parsed = urlparse(path)
-        if method == "GET" and parsed.path == "/health":
-            return _ok(service="hostbridge-daemon", transport="unix-jsonl")
-        if method == "GET" and parsed.path == "/hosts":
-            return _ok(hosts=self.registry.describe())
-        if method == "POST" and parsed.path == "/hosts/reload":
-            registry = _reload_handler_hosts(self)
-            return _ok(hosts=registry.describe())
-        if method == "GET" and parsed.path == "/sessions":
-            return _ok(sessions=self.manager.list_sessions())
-        if method == "POST" and parsed.path == "/sessions":
-            token = body.get("token")
-            token_factory = (lambda: str(token)) if token else None
-            session = self.manager.open_session(
-                str(body.get("host_id", "")),
-                connect_timeout=int(body.get("connect_timeout", DEFAULT_CONNECT_TIMEOUT)),
-                owner_agent_id=_optional_str(body.get("owner_agent_id")),
-                **({"token_factory": token_factory} if token_factory else {}),
-            )
-            descriptor = next(item for item in self.manager.list_sessions() if item["session_id"] == session.id)
-            return _ok(session=descriptor)
-        if method == "POST" and parsed.path == "/sessions/close_all":
-            return _ok(**self.manager.close_all_sessions())
-        if method == "POST" and parsed.path == "/shutdown":
-            threading.Thread(target=self.server.shutdown, daemon=True).start()
-            return _ok(shutting_down=True)
-
-        parts = parsed.path.strip("/").split("/")
-        if len(parts) == 3 and parts[0] == "sessions" and parts[2] == "commands" and method == "POST":
-            token = body.get("token")
-            token_factory = (lambda: str(token)) if token else _new_token
-            command_result = self.manager.run_command(
-                parts[1],
-                str(body.get("command", "")),
-                timeout=int(body.get("timeout", DEFAULT_COMMAND_TIMEOUT)),
-                owner_agent_id=_optional_str(body.get("owner_agent_id")),
-                token_factory=token_factory,
-            )
-            return _ok(result=asdict(command_result))
-        if len(parts) == 3 and parts[0] == "sessions" and parts[2] == "tasks" and method == "POST":
-            task = self.manager.start_task(
-                parts[1],
-                str(body.get("command", "")),
-                owner_agent_id=_optional_str(body.get("owner_agent_id")),
-            )
-            return _ok(task=asdict(task))
-        if len(parts) == 4 and parts[0] == "sessions" and parts[2] == "tasks" and method == "GET":
-            query = parse_qs(parsed.query)
-            owner_agent_id = _optional_str(body.get("owner_agent_id") or query.get("owner_agent_id", [None])[0])
-            return _ok(
-                status=self.manager.task_status(
-                    parts[1],
-                    parts[3],
-                    tail_lines=int(query.get("tail_lines", [80])[0]),
-                    owner_agent_id=owner_agent_id,
-                )
+            chunks = self.dispatcher.services.download(
+                _required_param(params, "session_id"),
+                _required_param(params, "remote_path"),
+                chunk_size=chunk_size,
+                owner=_optional_owner(params),
             )
-        if len(parts) == 4 and parts[0] == "sessions" and parts[2] == "tasks" and method == "DELETE":
-            return _ok(**self.manager.stop_task(parts[1], parts[3], owner_agent_id=_optional_str(body.get("owner_agent_id")), force=bool(body.get("force"))))
-        if len(parts) == 3 and parts[0] == "sessions" and parts[2] == "files" and method == "POST":
-            action = str(body.get("action", ""))
-            owner = _optional_str(body.get("owner_agent_id"))
-            token = body.get("token")
-            token_factory = (lambda: str(token)) if token else None
-            token_factory = token_factory or _new_token
-            if action == "write_text":
-                return _ok(
-                    transfer=self.manager.file_write_text(
-                        parts[1],
-                        str(body.get("remote_path", "")),
-                        str(body.get("content", "")),
-                        mode=str(body.get("mode", "0644")),
-                        max_bytes=int(body.get("max_bytes", DEFAULT_MAX_TRANSFER_BYTES)),
-                        owner_agent_id=owner,
-                        token_factory=token_factory,
-                    )
-                )
-            if action == "read_text":
-                return _ok(
-                    transfer=self.manager.file_read_text(
-                        parts[1],
-                        str(body.get("remote_path", "")),
-                        max_bytes=int(body.get("max_bytes", DEFAULT_MAX_TRANSFER_BYTES)),
-                        owner_agent_id=owner,
-                        token_factory=token_factory,
-                    )
-                )
-            if action == "upload":
-                return _ok(
-                    transfer=self.manager.file_upload(
-                        parts[1],
-                        str(body.get("local_path", "")),
-                        str(body.get("remote_path", "")),
-                        mode=str(body.get("mode", "0644")),
-                        max_bytes=int(body.get("max_bytes", DEFAULT_MAX_TRANSFER_BYTES)),
-                        owner_agent_id=owner,
-                        token_factory=token_factory,
-                    )
-                )
-            if action == "download":
-                return _ok(
-                    transfer=self.manager.file_download(
-                        parts[1],
-                        str(body.get("remote_path", "")),
-                        str(body.get("local_path", "")),
-                        max_bytes=int(body.get("max_bytes", DEFAULT_MAX_TRANSFER_BYTES)),
-                        owner_agent_id=owner,
-                        token_factory=token_factory,
-                    )
-                )
-            return {"ok": False, "status": 400, "error": "unknown file action", "error_code": "bad_request"}
-        if len(parts) == 3 and parts[0] == "sessions" and parts[2] == "write" and method == "POST":
-            result = self.manager.write(parts[1], str(body.get("text", "")), owner_agent_id=_optional_str(body.get("owner_agent_id")))
-            return _ok(**result)
-        if len(parts) == 3 and parts[0] == "sessions" and parts[2] == "read" and method == "POST":
-            result = self.manager.read(
-                parts[1],
-                timeout=float(body.get("timeout", 1.0)),
-                max_chars=int(body.get("max_chars", 20000)),
-                owner_agent_id=_optional_str(body.get("owner_agent_id")),
-            )
-            return _ok(**result)
-        if len(parts) == 2 and parts[0] == "sessions" and method == "DELETE":
-            query = parse_qs(parsed.query)
-            force = bool(body.get("force")) or query.get("force", [""])[0].lower() in {"1", "true", "yes"}
-            return _ok(
-                **self.manager.close_session(
-                    parts[1],
-                    owner_agent_id=_optional_str(body.get("owner_agent_id")),
-                    force=force,
-                )
-            )
-        return {"ok": False, "status": 404, "error": "not found", "error_code": "not_found"}
-
-
-def _optional_str(value: object) -> str | None:
-    if value is None:
-        return None
-    text = str(value).strip()
-    return text or None
-
-
-def _reload_handler_hosts(handler: HostBridgeDaemonHandler) -> HostRegistry:
-    registry = HostRegistry(load_hosts())
-    handler.manager.hosts = registry
-    type(handler).registry = registry
-    return registry
+            for chunk in chunks:
+                digest.update(chunk)
+                transferred += len(chunk)
+                self.wfile.write(encode_frame(BinaryFrame(stream_id, sequence, FrameFlags.DATA, chunk)))
+                self.wfile.flush()
+                sequence += 1
+            metadata = json.dumps(
+                {"bytes_transferred": transferred, "sha256": digest.hexdigest()},
+                separators=(",", ":"),
+            ).encode("utf-8")
+            self.wfile.write(encode_frame(BinaryFrame(stream_id, sequence, FrameFlags.EOF, metadata)))
+            self.wfile.flush()
+        except ServiceError as exc:
+            metadata = json.dumps({"code": exc.code, "message": str(exc)}, separators=(",", ":")).encode("utf-8")
+            self.wfile.write(encode_frame(BinaryFrame(stream_id, sequence, FrameFlags.CANCEL, metadata)))
+            self.wfile.flush()
 
 
-def make_handler(manager: SessionManager, registry: HostRegistry | None = None) -> type[HostBridgeDaemonHandler]:
-    class Handler(HostBridgeDaemonHandler):
+def make_v1_handler(dispatcher: HostBridgeV1Dispatcher) -> type[HostBridgeV1Handler]:
+    class Handler(HostBridgeV1Handler):
         pass
 
-    Handler.manager = manager
-    Handler.registry = registry or manager.hosts
+    Handler.dispatcher = dispatcher
     return Handler
 
 
-def _max_sessions_per_host_from_env() -> int:
-    raw = os.environ.get("HOSTBRIDGE_MAX_SESSIONS_PER_HOST", "0")
-    with suppress(ValueError):
-        return max(0, int(raw))
-    return 0
-
-
-def build_manager(config_path: Path | str | None = None) -> SessionManager:
+def build_v1_services(
+    config_path: Path | str | None = None,
+    *,
+    connect_timeout: int = DEFAULT_CONNECT_TIMEOUT,
+) -> HostBridgeServices:
+    if config_path is not None:
+        load_v1_config(config_path)
     registry = HostRegistry(load_hosts(config_path))
     policy = load_policy()
-    manager = SessionManager(
+
+    def transport_factory(host):
+        return PtyTransport.connect(host, connect_timeout=connect_timeout)
+
+    services = HostBridgeServices(
         registry,
+        transport_factory=transport_factory,
         policy=policy,
         audit_sink=build_audit_sink(policy),
-        max_sessions_per_host=_max_sessions_per_host_from_env(),
     )
-    manager.start_idle_reaper()
-    return manager
+    if policy.enabled and policy.idle_timeout_seconds > 0:
+        services.start_idle_reaper(timeout=policy.idle_timeout_seconds)
+    return services
 
 
 def daemon_dir(path: Path | str | None = None) -> Path:
-    configured = path or os.environ.get("HOSTBRIDGE_DAEMON_DIR")
-    if configured:
-        return Path(configured).expanduser()
-    socket_override = os.environ.get("HOSTBRIDGE_DAEMON_SOCKET")
-    if socket_override:
-        return Path(socket_override).expanduser().parent
-    configured = DEFAULT_DAEMON_DIR
-    return Path(configured).expanduser()
+    return Path(path).expanduser() if path is not None else runtime_paths().directory
 
 
 def socket_path(path: Path | str | None = None) -> Path:
-    configured = path or os.environ.get("HOSTBRIDGE_DAEMON_SOCKET")
-    if configured:
-        return Path(configured).expanduser()
-    configured = daemon_dir() / "daemon.sock"
-    return Path(configured).expanduser()
+    return runtime_paths(path).socket
 
 
 def pid_file() -> Path:
-    return daemon_dir() / "daemon.pid"
+    return runtime_paths().pid
 
 
 def log_file() -> Path:
-    return daemon_dir() / "daemon.log"
+    return runtime_paths().log
 
 
 def _prepare_socket_path(path: Path) -> None:
@@ -329,18 +434,25 @@ def _socket_accepts_connections(path: Path) -> bool:
         return False
 
 
-def run_daemon(*, socket_file: Path | str | None = None) -> int:
-    manager = build_manager()
+def run_daemon(
+    *,
+    socket_file: Path | str | None = None,
+    config_path: Path | str | None = None,
+) -> int:
+    services = build_v1_services(config_path)
     path = socket_path(socket_file)
     _prepare_socket_path(path)
-    server = ThreadingUnixRPCServer(str(path), make_handler(manager))
+    server = ThreadingUnixRPCServer(
+        str(path),
+        make_v1_handler(HostBridgeV1Dispatcher(services)),
+    )
     pid_file().write_text(str(os.getpid()), encoding="utf-8")
     try:
         print(f"hostbridge daemon listening on unix://{path}", flush=True)
         server.serve_forever()
     finally:
-        manager.close_all_sessions()
-        manager.stop_idle_reaper()
+        services.close_all()
+        services.stop_idle_reaper()
         server.server_close()
         with suppress(FileNotFoundError):
             path.unlink()
@@ -355,50 +467,18 @@ def daemon_endpoint() -> str:
 
 def is_running(*, socket_file: Path | str | None = None) -> bool:
     try:
-        health = request_json("GET", "/health", timeout=1.0, socket_file=socket_file)
-        return health.get("ok") is True and health.get("service") == "hostbridge-daemon"
-    except Exception:
+        hello = HostBridgeClient(socket_file, default_timeout=1.0).hello()
+        return hello.get("service") == "hostbridge" and hello.get("protocol") == PROTOCOL_VERSION
+    except HostBridgeError:
         return False
 
 
-def request_json(
-    method: str,
-    path: str,
-    payload: dict[str, object] | None = None,
+def start_background(
     *,
-    timeout: float = 5.0,
     socket_file: Path | str | None = None,
-) -> dict[str, object]:
-    request = {"method": method.upper(), "path": path, "body": payload or {}}
-    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
-        client.settimeout(timeout)
-        client.connect(str(socket_path(socket_file)))
-        client.sendall(json.dumps(request, ensure_ascii=False).encode("utf-8") + b"\n")
-        response = _recv_json_line(client)
-    if not isinstance(response, dict):
-        raise RuntimeError("daemon returned non-object JSON")
-    return response
-
-
-def _recv_json_line(client: socket.socket) -> dict[str, object]:
-    chunks: list[bytes] = []
-    while True:
-        chunk = client.recv(65536)
-        if not chunk:
-            break
-        chunks.append(chunk)
-        if b"\n" in chunk:
-            break
-    line = b"".join(chunks).split(b"\n", 1)[0]
-    if not line:
-        return {}
-    decoded = json.loads(line.decode("utf-8"))
-    if not isinstance(decoded, dict):
-        raise RuntimeError("daemon returned non-object JSON")
-    return decoded
-
-
-def start_background(*, socket_file: Path | str | None = None, quiet: bool = False) -> int:
+    config_path: Path | str | None = None,
+    quiet: bool = False,
+) -> int:
     path = socket_path(socket_file)
     if is_running(socket_file=path):
         if not quiet:
@@ -407,15 +487,19 @@ def start_background(*, socket_file: Path | str | None = None, quiet: bool = Fal
     path.parent.mkdir(parents=True, exist_ok=True)
     with suppress(OSError):
         path.parent.chmod(0o700)
-    log_handle = log_file().open("a", encoding="utf-8")
-    process = subprocess.Popen(
-        [sys.executable, "-m", "server_control_mcp", "daemon", "start", "--foreground", "--socket", str(path)],
-        stdin=subprocess.DEVNULL,
-        stdout=log_handle,
-        stderr=log_handle,
-        start_new_session=True,
-        env=os.environ.copy(),
-    )
+    command = [sys.executable, "-m", "server_control_mcp", "daemon"]
+    if config_path is not None:
+        command.extend(["--config", str(config_path)])
+    command.extend(["start", "--foreground", "--socket", str(path)])
+    with log_file().open("a", encoding="utf-8") as log_handle:
+        process = subprocess.Popen(
+            command,
+            stdin=subprocess.DEVNULL,
+            stdout=log_handle,
+            stderr=log_handle,
+            start_new_session=True,
+            env=os.environ.copy(),
+        )
     pid_file().write_text(str(process.pid), encoding="utf-8")
     deadline = time.time() + 5
     while time.time() < deadline:
@@ -423,6 +507,8 @@ def start_background(*, socket_file: Path | str | None = None, quiet: bool = Fal
             if not quiet:
                 print(f"hostbridge daemon started at unix://{path} (pid {process.pid})")
             return 0
+        if process.poll() is not None:
+            break
         time.sleep(0.1)
     if not quiet:
         print(f"hostbridge daemon failed to start; see {log_file()}", file=sys.stderr)
@@ -432,13 +518,8 @@ def start_background(*, socket_file: Path | str | None = None, quiet: bool = Fal
 def stop_background(*, socket_file: Path | str | None = None) -> int:
     path = socket_path(socket_file)
     if is_running(socket_file=path):
-        request_json("POST", "/shutdown", timeout=2.0, socket_file=path)
+        HostBridgeClient(path, default_timeout=2.0).request("system.shutdown", {})
         print("hostbridge daemon stopped")
         return 0
-    if pid_file().exists():
-        with suppress(Exception):
-            os.kill(int(pid_file().read_text(encoding="utf-8").strip()), signal.SIGTERM)
-            print("hostbridge daemon process signaled")
-            return 0
     print("hostbridge daemon is not running")
     return 0