iotsploit-mcp 0.0.6__tar.gz

iotsploit_mcp-0.0.6/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.3
+Name: iotsploit-mcp
+Version: 0.0.6
+Summary: IoTSploit MCP runtime (FastMCP stdio server + WebSocket bridge), framework-free outer ring.
+License: GPL-3.0-or-later
+Keywords: iot,security,mcp,model-context-protocol,pentest
+Author: IoTSploit Team
+Author-email: support@iotsploit.org
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Hardware
+Requires-Dist: iotsploit-core (>=0.0.6,<0.0.7)
+Requires-Dist: mcp (>=1.9.4,<2.0.0)
+Requires-Dist: nest-asyncio (>=1.6.0,<2.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: websockets (>=12.0,<13.0)
+Project-URL: Documentation, https://www.iotsploit.org/
+Project-URL: Homepage, https://www.iotsploit.org/
+Project-URL: Repository, https://github.com/TKXB/iotsploit
+Description-Content-Type: text/markdown
+
+# iotsploit-mcp
+
+`iotsploit-mcp` 是 IoTSploit 的 MCP 运行时组件（execution plane / outer ring），包含：
+
+- FastMCP **stdio server**（提供 MCP tools）
+- WebSocket **bridge**（给上层 UI/Django consumer 通过 `ws://host:9998` 访问）
+
+## 命令
+
+- 默认启动 WebSocket bridge（等价于 `ws`）：
+
+```bash
+iotsploit-mcp
+```
+
+- 显式启动 WebSocket bridge：
+
+```bash
+iotsploit-mcp ws --host 0.0.0.0 --port 9998
+```
+
+- 只启动 stdio FastMCP server（一般由 bridge 拉起）：
+
+```bash
+iotsploit-mcp stdio
+```
+
+## 环境变量
+
+- `IOTSPLOIT_DJANGO_API_BASE_URL`：Django HTTP API base URL（默认 `http://127.0.0.1:8888`）
+- `IOTSPLOIT_DJANGO_API_TOKEN`：可选 Bearer token
+- `IOTSPLOIT_DJANGO_API_TIMEOUT_S`：可选超时（秒）
+- `IOTSPLOIT_DEVICE_PLUGINS_DIR`：device driver 插件目录
+- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR`：exploit 插件目录
+
+
+

iotsploit_mcp-0.0.6/README.md

@@ -0,0 +1,36 @@
+# iotsploit-mcp
+
+`iotsploit-mcp` 是 IoTSploit 的 MCP 运行时组件（execution plane / outer ring），包含：
+
+- FastMCP **stdio server**（提供 MCP tools）
+- WebSocket **bridge**（给上层 UI/Django consumer 通过 `ws://host:9998` 访问）
+
+## 命令
+
+- 默认启动 WebSocket bridge（等价于 `ws`）：
+
+```bash
+iotsploit-mcp
+```
+
+- 显式启动 WebSocket bridge：
+
+```bash
+iotsploit-mcp ws --host 0.0.0.0 --port 9998
+```
+
+- 只启动 stdio FastMCP server（一般由 bridge 拉起）：
+
+```bash
+iotsploit-mcp stdio
+```
+
+## 环境变量
+
+- `IOTSPLOIT_DJANGO_API_BASE_URL`：Django HTTP API base URL（默认 `http://127.0.0.1:8888`）
+- `IOTSPLOIT_DJANGO_API_TOKEN`：可选 Bearer token
+- `IOTSPLOIT_DJANGO_API_TIMEOUT_S`：可选超时（秒）
+- `IOTSPLOIT_DEVICE_PLUGINS_DIR`：device driver 插件目录
+- `IOTSPLOIT_EXPLOIT_PLUGINS_DIR`：exploit 插件目录
+
+

iotsploit_mcp-0.0.6/pyproject.toml

@@ -0,0 +1,39 @@
+[tool.poetry]
+name = "iotsploit-mcp"
+version = "0.0.6"
+description = "IoTSploit MCP runtime (FastMCP stdio server + WebSocket bridge), framework-free outer ring."
+authors = ["IoTSploit Team <support@iotsploit.org>"]
+readme = "README.md"
+license = "GPL-3.0-or-later"
+homepage = "https://www.iotsploit.org/"
+repository = "https://github.com/TKXB/iotsploit"
+documentation = "https://www.iotsploit.org/"
+keywords = ["iot", "security", "mcp", "model-context-protocol", "pentest"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Topic :: Security",
+    "Topic :: System :: Hardware",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+packages = [{ include = "iotsploit_mcp", from = "src" }]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4.0"
+mcp = "^1.9.4"
+websockets = "^12.0"
+requests = "^2.31.0"
+nest-asyncio = "^1.6.0"
+iotsploit-core = "^0.0.6"
+
+[tool.poetry.scripts]
+iotsploit-mcp = "iotsploit_mcp.cli:main"
+
+[build-system]
+requires = ["poetry-core>=1.8.0"]
+build-backend = "poetry.core.masonry.api"

iotsploit_mcp-0.0.6/src/iotsploit_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""MCP entrypoint package (framework-free outer ring).
+
+This package wires `iotsploit_core` with adapters that talk to external services
+(e.g. iotsploit_django HTTP API) without importing Django at runtime.
+"""
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/__main__.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from iotsploit_mcp.cli import main
+
+if __name__ == "__main__":
+    main()
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/adapters/__init__.py

@@ -0,0 +1,3 @@
+"""Adapters for `iotsploit_mcp`."""
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/adapters/http_driver_state_repo.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import requests
+
+
+@dataclass(frozen=True)
+class DjangoHttpApiConfig:
+    base_url: str
+    timeout_s: float = 5.0
+    bearer_token: str | None = None
+
+
+class HttpDriverStateRepository:
+    """DriverStateRepository over iotsploit_django HTTP API.
+
+    Django endpoints (mounted under `/api/`):
+    - GET  /api/get_driver_states/
+    - POST /api/enable_driver/
+    - POST /api/disable_driver/
+    """
+
+    def __init__(self, *, base_url: str, timeout_s: float = 5.0, bearer_token: str | None = None) -> None:
+        base_url = (base_url or "").strip().rstrip("/")
+        if not base_url:
+            raise ValueError("base_url is required for HttpDriverStateRepository")
+        self._cfg = DjangoHttpApiConfig(base_url=base_url, timeout_s=float(timeout_s), bearer_token=bearer_token)
+        self._session = requests.Session()
+
+    @staticmethod
+    def from_env() -> "HttpDriverStateRepository":
+        base_url = os.getenv("IOTSPLOIT_DJANGO_API_BASE_URL", "http://127.0.0.1:8888")
+        timeout_s = float(os.getenv("IOTSPLOIT_DJANGO_API_TIMEOUT_S", "5.0"))
+        bearer_token = os.getenv("IOTSPLOIT_DJANGO_API_TOKEN") or None
+        return HttpDriverStateRepository(base_url=base_url, timeout_s=timeout_s, bearer_token=bearer_token)
+
+    def _headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {"Accept": "application/json"}
+        if self._cfg.bearer_token:
+            headers["Authorization"] = f"Bearer {self._cfg.bearer_token}"
+        return headers
+
+    def _url(self, path: str) -> str:
+        path = path if path.startswith("/") else f"/{path}"
+        return f"{self._cfg.base_url}{path}"
+
+    @staticmethod
+    def _raise_for_bad_response(resp: requests.Response, *, context: str) -> None:
+        if 200 <= resp.status_code < 300:
+            return
+        raise RuntimeError(f"{context} failed: HTTP {resp.status_code}: {resp.text[:500]}")
+
+    def list_enabled(self) -> dict[str, bool]:
+        resp = self._session.get(
+            self._url("/api/get_driver_states/"),
+            headers=self._headers(),
+            timeout=self._cfg.timeout_s,
+        )
+        self._raise_for_bad_response(resp, context="GET /api/get_driver_states/")
+
+        payload: dict[str, Any] = resp.json()
+        if payload.get("status") not in (None, "success"):
+            raise RuntimeError(f"GET /api/get_driver_states/ returned error: {payload!r}")
+
+        drivers = payload.get("drivers") or {}
+        if not isinstance(drivers, dict):
+            raise RuntimeError(f"Unexpected drivers payload: {drivers!r}")
+
+        out: dict[str, bool] = {}
+        for name, state in drivers.items():
+            if isinstance(state, dict):
+                out[str(name)] = bool(state.get("enabled", True))
+            else:
+                out[str(name)] = bool(state)
+        return out
+
+    def get_enabled(self, driver_name: str) -> bool | None:
+        if not driver_name:
+            return None
+        states = self.list_enabled()
+        return states.get(driver_name)
+
+    def set_enabled(self, driver_name: str, enabled: bool, description: str | None = None) -> None:
+        if not driver_name:
+            raise ValueError("driver_name is required")
+
+        endpoint = "/api/enable_driver/" if enabled else "/api/disable_driver/"
+        body: dict[str, Any] = {"driver_name": driver_name}
+        if description is not None:
+            body["description"] = description
+
+        resp = self._session.post(
+            self._url(endpoint),
+            headers={**self._headers(), "Content-Type": "application/json"},
+            json=body,
+            timeout=self._cfg.timeout_s,
+        )
+        self._raise_for_bad_response(resp, context=f"POST {endpoint}")
+
+        payload: dict[str, Any] = resp.json()
+        if payload.get("status") not in (None, "success"):
+            raise RuntimeError(f"POST {endpoint} returned error: {payload!r}")
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/adapters/http_plugin_group_repo.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import requests
+
+from iotsploit_core.domain.execution_plan import GroupStepSpec, PluginGroupSpec, PluginStepSpec
+from iotsploit_core.ports.plugin_repo import PluginGroupRepository
+
+
+@dataclass(frozen=True)
+class DjangoHttpApiConfig:
+    base_url: str
+    timeout_s: float = 5.0
+    bearer_token: str | None = None
+
+
+class HttpPluginGroupRepository(PluginGroupRepository):
+    """PluginGroupRepository over iotsploit_django HTTP API (SSOT).
+
+    Endpoints:
+    - GET /api/plugin_groups/enabled/
+    - GET /api/plugin_groups/<name>/
+    """
+
+    def __init__(self, *, base_url: str, timeout_s: float = 5.0, bearer_token: str | None = None) -> None:
+        base_url = (base_url or "").strip().rstrip("/")
+        if not base_url:
+            raise ValueError("base_url is required for HttpPluginGroupRepository")
+        self._cfg = DjangoHttpApiConfig(base_url=base_url, timeout_s=float(timeout_s), bearer_token=bearer_token)
+        self._session = requests.Session()
+
+    @staticmethod
+    def from_env() -> "HttpPluginGroupRepository":
+        base_url = os.getenv("IOTSPLOIT_DJANGO_API_BASE_URL", "http://127.0.0.1:8888")
+        timeout_s = float(os.getenv("IOTSPLOIT_DJANGO_API_TIMEOUT_S", "5.0"))
+        bearer_token = os.getenv("IOTSPLOIT_DJANGO_API_TOKEN") or None
+        return HttpPluginGroupRepository(base_url=base_url, timeout_s=timeout_s, bearer_token=bearer_token)
+
+    def _headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {"Accept": "application/json"}
+        if self._cfg.bearer_token:
+            headers["Authorization"] = f"Bearer {self._cfg.bearer_token}"
+        return headers
+
+    def _url(self, path: str) -> str:
+        path = path if path.startswith("/") else f"/{path}"
+        return f"{self._cfg.base_url}{path}"
+
+    @staticmethod
+    def _raise_for_bad_response(resp: requests.Response, *, context: str) -> None:
+        if 200 <= resp.status_code < 300:
+            return
+        raise RuntimeError(f"{context} failed: HTTP {resp.status_code}: {resp.text[:500]}")
+
+    @staticmethod
+    def _to_spec(payload: dict[str, Any]) -> PluginGroupSpec:
+        plugin_steps: list[PluginStepSpec] = []
+        for s in payload.get("plugin_steps") or []:
+            if not isinstance(s, dict):
+                continue
+            plugin_steps.append(
+                PluginStepSpec(
+                    sequence=int(s.get("sequence", 100)),
+                    plugin_name=str(s.get("plugin_name") or ""),
+                    ignore_fail=bool(s.get("ignore_fail", False)),
+                )
+            )
+
+        group_steps: list[GroupStepSpec] = []
+        for s in payload.get("group_steps") or []:
+            if not isinstance(s, dict):
+                continue
+            group_steps.append(
+                GroupStepSpec(
+                    sequence=int(s.get("sequence", 100)),
+                    group_name=str(s.get("group_name") or ""),
+                    ignore_fail=bool(s.get("ignore_fail", False)),
+                    force_exec=bool(s.get("force_exec", False)),
+                )
+            )
+
+        return PluginGroupSpec(
+            name=str(payload.get("name") or ""),
+            enabled=bool(payload.get("enabled", True)),
+            plugin_steps=plugin_steps,
+            group_steps=group_steps,
+        )
+
+    def list_enabled_groups(self) -> list[PluginGroupSpec]:
+        resp = self._session.get(
+            self._url("/api/plugin_groups/enabled/"),
+            headers=self._headers(),
+            timeout=self._cfg.timeout_s,
+        )
+        self._raise_for_bad_response(resp, context="GET /api/plugin_groups/enabled/")
+        payload: dict[str, Any] = resp.json()
+        if payload.get("status") not in (None, "success"):
+            raise RuntimeError(f"GET /api/plugin_groups/enabled/ returned error: {payload!r}")
+
+        items = payload.get("groups") or []
+        if not isinstance(items, list):
+            raise RuntimeError(f"Unexpected groups payload: {items!r}")
+        out: list[PluginGroupSpec] = []
+        for it in items:
+            if not isinstance(it, dict):
+                continue
+            spec = self._to_spec(it)
+            if spec.name:
+                out.append(spec)
+        return out
+
+    def get_group(self, name: str) -> PluginGroupSpec | None:
+        if not name:
+            return None
+        resp = self._session.get(
+            self._url(f"/api/plugin_groups/{name}/"),
+            headers=self._headers(),
+            timeout=self._cfg.timeout_s,
+        )
+        if resp.status_code == 404:
+            return None
+        self._raise_for_bad_response(resp, context=f"GET /api/plugin_groups/{name}/")
+        payload: dict[str, Any] = resp.json()
+        if payload.get("status") not in (None, "success"):
+            raise RuntimeError(f"GET /api/plugin_groups/{name}/ returned error: {payload!r}")
+        g = payload.get("group")
+        if not isinstance(g, dict):
+            return None
+        spec = self._to_spec(g)
+        return spec if spec.name else None
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/adapters/http_plugin_meta_repo.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import requests
+
+from iotsploit_core.domain.plugin import PluginMeta
+from iotsploit_core.ports.plugin_repo import PluginMetaRepository
+
+
+@dataclass(frozen=True)
+class DjangoHttpApiConfig:
+    base_url: str
+    timeout_s: float = 5.0
+    bearer_token: str | None = None
+
+
+class HttpPluginMetaRepository(PluginMetaRepository):
+    """PluginMetaRepository over iotsploit_django HTTP API (SSOT).
+
+    Endpoints:
+    - GET  /api/plugins/exploits/enabled/
+    - POST /api/plugins/exploits/discovered/   (optional discovery report; must NOT override enabled/disabled)
+    """
+
+    def __init__(self, *, base_url: str, timeout_s: float = 5.0, bearer_token: str | None = None) -> None:
+        base_url = (base_url or "").strip().rstrip("/")
+        if not base_url:
+            raise ValueError("base_url is required for HttpPluginMetaRepository")
+        self._cfg = DjangoHttpApiConfig(base_url=base_url, timeout_s=float(timeout_s), bearer_token=bearer_token)
+        self._session = requests.Session()
+
+    @staticmethod
+    def from_env() -> "HttpPluginMetaRepository":
+        base_url = os.getenv("IOTSPLOIT_DJANGO_API_BASE_URL", "http://127.0.0.1:8888")
+        timeout_s = float(os.getenv("IOTSPLOIT_DJANGO_API_TIMEOUT_S", "5.0"))
+        bearer_token = os.getenv("IOTSPLOIT_DJANGO_API_TOKEN") or None
+        return HttpPluginMetaRepository(base_url=base_url, timeout_s=timeout_s, bearer_token=bearer_token)
+
+    def _headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {"Accept": "application/json"}
+        if self._cfg.bearer_token:
+            headers["Authorization"] = f"Bearer {self._cfg.bearer_token}"
+        return headers
+
+    def _url(self, path: str) -> str:
+        path = path if path.startswith("/") else f"/{path}"
+        return f"{self._cfg.base_url}{path}"
+
+    @staticmethod
+    def _raise_for_bad_response(resp: requests.Response, *, context: str) -> None:
+        if 200 <= resp.status_code < 300:
+            return
+        raise RuntimeError(f"{context} failed: HTTP {resp.status_code}: {resp.text[:500]}")
+
+    def upsert(self, meta: PluginMeta) -> None:
+        # Optional discovery report: do not treat as SSOT write for enabled/disabled.
+        body = {
+            "plugins": [
+                {
+                    "name": meta.name,
+                    "module_path": meta.module_path,
+                    "description": meta.description,
+                    "author": meta.author,
+                    "license": meta.license,
+                    "parameters": meta.parameters or {},
+                }
+            ]
+        }
+        resp = self._session.post(
+            self._url("/api/plugins/exploits/discovered/"),
+            headers={**self._headers(), "Content-Type": "application/json"},
+            json=body,
+            timeout=self._cfg.timeout_s,
+        )
+        self._raise_for_bad_response(resp, context="POST /api/plugins/exploits/discovered/")
+
+    def list_enabled(self) -> list[PluginMeta]:
+        resp = self._session.get(
+            self._url("/api/plugins/exploits/enabled/"),
+            headers=self._headers(),
+            timeout=self._cfg.timeout_s,
+        )
+        self._raise_for_bad_response(resp, context="GET /api/plugins/exploits/enabled/")
+        payload: dict[str, Any] = resp.json()
+        if payload.get("status") not in (None, "success"):
+            raise RuntimeError(f"GET /api/plugins/exploits/enabled/ returned error: {payload!r}")
+
+        items = payload.get("plugins") or []
+        if not isinstance(items, list):
+            raise RuntimeError(f"Unexpected plugins payload: {items!r}")
+
+        metas: list[PluginMeta] = []
+        for it in items:
+            if not isinstance(it, dict):
+                continue
+            metas.append(
+                PluginMeta(
+                    name=str(it.get("name") or ""),
+                    module_path=str(it.get("module_path") or ""),
+                    enabled=bool(it.get("enabled", True)),
+                    description=str(it.get("description") or ""),
+                    author=str(it.get("author") or ""),
+                    license=str(it.get("license") or ""),
+                    parameters=it.get("parameters") if isinstance(it.get("parameters"), dict) else None,
+                )
+            )
+        return [m for m in metas if m.name and m.module_path]
+
+    def disable_missing(self, names: set[str]) -> int:
+        # SSOT note: do NOT disable globally based on a single MCP node's filesystem.
+        # In multi-node deployments, a plugin may exist on another node.
+        return 0
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/adapters/task_runner_local.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any
+
+from iotsploit_core.ports.task_runner import TaskRunner
+
+
+class LocalTaskRunner(TaskRunner):
+    """最小可用 TaskRunner：用于 MCP 进程内满足依赖。
+
+    当前 MCP 主要走 `execute_plugin_async`（直接 await），不会依赖 Celery。
+    这里实现 submit 仅用于兼容 `ExploitPluginManager` 的构造函数签名与返回结构。
+    """
+
+    def submit(
+        self,
+        plugin_name: str,
+        target: dict | None,
+        parameters: dict,
+        *,
+        context: dict | None = None,
+    ) -> dict[str, Any]:
+        return {
+            "execution_type": "in_process",
+            "plugin_name": plugin_name,
+            "target": target,
+            "parameters": parameters,
+            "context": context,
+        }
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/cli.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="iotsploit-mcp")
+    sub = p.add_subparsers(dest="cmd")
+
+    ws = sub.add_parser("ws", help="Start WebSocket bridge (default)")
+    ws.add_argument("--host", default="0.0.0.0")
+    ws.add_argument("--port", type=int, default=9998)
+
+    sub.add_parser("stdio", help="Start FastMCP stdio server (usually started by bridge)")
+    return p
+
+
+async def _run_ws(host: str, port: int) -> None:
+    from iotsploit_mcp.websocket_bridge_simple import SATMCPWebSocketBridge
+
+    bridge = SATMCPWebSocketBridge(host=host, port=port)
+    await bridge.start_server()
+
+
+async def _run_stdio() -> None:
+    import nest_asyncio
+
+    nest_asyncio.apply()
+
+    from iotsploit_mcp.sat_fastmcp import run_stdio_async
+
+    await run_stdio_async()
+
+
+def main(argv: list[str] | None = None) -> None:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    p = _build_parser()
+    args = p.parse_args(argv)
+
+    cmd = args.cmd or "ws"  # default: ws
+    if cmd == "ws":
+        asyncio.run(_run_ws(host=args.host, port=args.port))
+        return
+    if cmd == "stdio":
+        asyncio.run(_run_stdio())
+        return
+
+    p.error(f"Unknown cmd: {cmd}")
+
+
+if __name__ == "__main__":
+    main()
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/composition_root.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from iotsploit_core.core.device_manager import DeviceDriverManager
+from iotsploit_core.core.exploit_manager import ExploitPluginManager
+
+from iotsploit_mcp.adapters.http_driver_state_repo import HttpDriverStateRepository
+from iotsploit_mcp.adapters.http_plugin_group_repo import HttpPluginGroupRepository
+from iotsploit_mcp.adapters.http_plugin_meta_repo import HttpPluginMetaRepository
+from iotsploit_mcp.adapters.task_runner_local import LocalTaskRunner
+
+
+def _default_exploit_plugins_dir() -> Path:
+    env = os.getenv("IOTSPLOIT_EXPLOIT_PLUGINS_DIR") or os.getenv("SAT_EXPLOIT_PLUGINS_DIR")
+    if env:
+        return Path(env)
+    return Path.cwd() / "plugins" / "exploits"
+
+
+def build_device_manager(
+    *,
+    plugins_dir: str | Path | None = None,
+    usb_config_file: str | Path | None = None,
+    django_api_base_url: Optional[str] = None,
+) -> DeviceDriverManager:
+    """Build a framework-free DeviceDriverManager for MCP runtime.
+
+    Driver states are sourced from iotsploit_django HTTP API (single source of truth).
+    """
+
+    repo = (
+        HttpDriverStateRepository.from_env()
+        if django_api_base_url is None
+        else HttpDriverStateRepository(base_url=django_api_base_url)
+    )
+
+    # Fail fast so we don't start with wrong/unknown driver states.
+    _ = repo.list_enabled()
+
+    return DeviceDriverManager(
+        driver_state_repo=repo,
+        plugins_dir=plugins_dir,
+        usb_config_file=usb_config_file,
+    )
+
+
+def build_exploit_manager(*, django_api_base_url: Optional[str] = None, plugins_dir: str | Path | None = None) -> ExploitPluginManager:
+    """Build ExploitPluginManager for MCP runtime.
+
+    SSOT mode: enabled plugins and group specs come from Django over HTTP.
+    Discovery reporting (upsert) is allowed but MUST NOT override enabled/disabled decisions.
+    """
+    plugin_repo = (
+        HttpPluginMetaRepository.from_env()
+        if django_api_base_url is None
+        else HttpPluginMetaRepository(base_url=django_api_base_url)
+    )
+    group_repo = (
+        HttpPluginGroupRepository.from_env()
+        if django_api_base_url is None
+        else HttpPluginGroupRepository(base_url=django_api_base_url)
+    )
+
+    # Fail fast: ensure Django API reachable & returns a well-formed payload.
+    _ = plugin_repo.list_enabled()
+    _ = group_repo.list_enabled_groups()
+
+    return ExploitPluginManager(
+        plugin_repo=plugin_repo,
+        group_repo=group_repo,
+        task_runner=LocalTaskRunner(),
+        plugins_dir=Path(plugins_dir) if plugins_dir is not None else _default_exploit_plugins_dir(),
+    )
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/sat_fastmcp.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+SAT FastMCP Server (stdio)
+
+Execution plane: MCP tools call iotsploit-core usecases. All enabled/disabled states
+are sourced from Django SSOT over HTTP APIs.
+"""
+
+import asyncio
+import json
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+from iotsploit_mcp.tools.xlogger_mcp import xlog_mcp
+
+# sat_fastmcp runs as a subprocess; allow optional file logging.
+logger = xlog_mcp.get_logger(
+    "sat_fastmcp",
+    # enable via env IOTSPLOIT_MCP_LOG_TO_FILE=1 (and optionally IOTSPLOIT_MCP_LOG_FILE / IOTSPLOIT_MCP_LOG_DIR)
+)
+
+
+mcp = FastMCP("sat-toolkit")
+
+
+# Lazy-loaded managers (initialized on first use to avoid startup order issues)
+_device_manager = None
+_exploit_manager = None
+_init_attempted = False
+
+
+def _ensure_managers_initialized() -> tuple:
+    """Lazily initialize device/exploit managers on first use.
+    
+    Returns (device_manager, exploit_manager). Either may be None if Django API is unavailable.
+    """
+    global _device_manager, _exploit_manager, _init_attempted
+    
+    if _init_attempted:
+        return _device_manager, _exploit_manager
+    
+    _init_attempted = True
+    try:
+        from iotsploit_mcp.composition_root import build_device_manager, build_exploit_manager
+
+        _device_manager = build_device_manager()
+        _exploit_manager = build_exploit_manager()
+        logger.info("SAT MCP components initialized (SSOT via Django HTTP API)")
+    except Exception as e:
+        logger.error("SAT MCP components failed to initialize: %s", e)
+        logger.info("Will retry on next tool call...")
+        _init_attempted = False  # Allow retry on next call
+    
+    return _device_manager, _exploit_manager
+
+
+def get_device_manager():
+    """Get device manager, initializing if needed."""
+    dm, _ = _ensure_managers_initialized()
+    return dm
+
+
+def get_exploit_manager():
+    """Get exploit manager, initializing if needed."""
+    _, em = _ensure_managers_initialized()
+    return em
+
+
+@mcp.tool()
+async def scan_devices(driver_name: str = "all") -> str:
+    """Scan for available devices."""
+    try:
+        device_manager = get_device_manager()
+        if not device_manager:
+            return "Device manager not available. Ensure Django API is running at IOTSPLOIT_DJANGO_API_BASE_URL"
+
+        logger.info("Scanning devices (driver: %s)", driver_name)
+
+        if driver_name == "all":
+            enabled_drivers = [
+                driver for driver in device_manager.list_drivers() if device_manager.is_driver_enabled(driver)
+            ]
+
+            if not enabled_drivers:
+                return "No enabled device drivers found"
+
+            all_results = []
+            for driver in enabled_drivers:
+                try:
+                    result = device_manager.scan_devices(driver)
+                    if result.get("status") != "success":
+                        all_results.append(f"Driver '{driver}': {result.get('message', 'Scan failed')}")
+                        continue
+                    devices = result.get("devices", [])
+                    device_list = [
+                        f"  - {getattr(device, 'name', 'Unknown')}: {getattr(device, 'device_type', 'Unknown')}"
+                        for device in devices
+                    ]
+                    if device_list:
+                        all_results.append(f"Driver '{driver}':\n" + "\n".join(device_list))
+                    else:
+                        all_results.append(f"Driver '{driver}': No devices found")
+                except Exception as e:
+                    all_results.append(f"Driver '{driver}': Error - {str(e)}")
+
+            return "\n\n".join(all_results) if all_results else "No devices found"
+
+        result = device_manager.scan_devices(driver_name)
+        if result.get("status") != "success":
+            return f"Scan failed: {result.get('message', 'Unknown error')}"
+        devices = result.get("devices", [])
+        if devices:
+            device_list = [f"- {getattr(device, 'name', 'Unknown')}: {getattr(device, 'device_type', 'Unknown')}" for device in devices]
+            return f"Found {len(devices)} devices:\n" + "\n".join(device_list)
+        return f"No devices found using driver '{driver_name}'"
+
+    except Exception as e:
+        logger.error("Error scanning devices: %s", e)
+        return f"Error scanning devices: {str(e)}"
+
+
+@mcp.tool()
+async def get_system_status() -> str:
+    """Get overall system status."""
+    try:
+        logger.info("Getting system status")
+        device_manager = get_device_manager()
+        exploit_manager = get_exploit_manager()
+        status = {
+            "timestamp": asyncio.get_event_loop().time(),
+            "device_manager_available": device_manager is not None,
+            "exploit_manager_available": exploit_manager is not None,
+        }
+        if device_manager:
+            enabled_drivers = [
+                driver for driver in device_manager.list_drivers() if device_manager.is_driver_enabled(driver)
+            ]
+            status["enabled_drivers"] = len(enabled_drivers)
+            status["total_drivers"] = len(device_manager.list_drivers())
+        if exploit_manager:
+            status["enabled_exploit_plugins"] = len(exploit_manager.list_plugins())
+        return json.dumps(status, indent=2)
+    except Exception as e:
+        logger.error("Error getting system status: %s", e)
+        return f"Error getting system status: {str(e)}"
+
+
+@mcp.tool()
+async def read_serial_port(
+    port: str = "/dev/ttyUSB0",
+    baudrate: int = 115200,
+    timeout: int = 300,
+    auto_interact: bool = True,
+) -> str:
+    """Read and analyze serial port output using exploit plugin system (SSOT mode)."""
+    try:
+        exploit_manager = get_exploit_manager()
+        if not exploit_manager:
+            return json.dumps({"success": False, "error": "Exploit manager not available. Ensure Django API is running."}, indent=2)
+
+        parameters = {
+            "port": port,
+            "baudrate": baudrate,
+            "timeout": timeout,
+            "auto_interact": auto_interact,
+            "analyze_output": True,
+        }
+
+        plugin_name = os.getenv("IOTSPLOIT_SERIAL_READER_PLUGIN_NAME", "Picocom Serial Reader")
+        logger.info("Executing exploit plugin '%s' for serial port %s", plugin_name, port)
+        result = await exploit_manager.execute_plugin_async(plugin_name, target=None, parameters=parameters)
+
+        if result is None:
+            return json.dumps(
+                {
+                    "success": False,
+                    "error": f"Plugin '{plugin_name}' not found or disabled in Django SSOT",
+                    "available_enabled_plugins": exploit_manager.list_plugins(),
+                },
+                indent=2,
+            )
+
+        if getattr(result, "status", False):
+            analysis_data = (result.data or {}).get("analysis", {}) if hasattr(result, "data") else {}
+            report = (result.data or {}).get("report", "No report generated") if hasattr(result, "data") else "No report generated"
+            return json.dumps(
+                {
+                    "success": True,
+                    "message": getattr(result, "message", ""),
+                    "analysis": {
+                        "device_type": analysis_data.get("device_type", "unknown"),
+                        "confidence": analysis_data.get("confidence", 0.0),
+                        "login_detected": analysis_data.get("login_detected", False),
+                        "shell_type": analysis_data.get("shell_type", "unknown"),
+                        "output_lines": analysis_data.get("output_lines_count", 0),
+                        "detected_patterns": analysis_data.get("detected_patterns", []),
+                    },
+                    "report": report,
+                    "sample_output": analysis_data.get("raw_output_sample", []),
+                },
+                indent=2,
+            )
+
+        return json.dumps(
+            {
+                "success": False,
+                "error": getattr(result, "message", "Serial reading failed"),
+                "data": getattr(result, "data", None),
+            },
+            indent=2,
+        )
+
+    except Exception as e:
+        logger.error("Error reading serial port: %s", e)
+        return json.dumps({"success": False, "error": f"Error reading serial port: {str(e)}"}, indent=2)
+
+
+@mcp.tool()
+async def list_serial_ports() -> str:
+    """List available serial ports on the system."""
+    try:
+        logger.info("Listing serial ports")
+        import serial.tools.list_ports
+
+        ports = serial.tools.list_ports.comports()
+        port_list = []
+        for port in ports:
+            port_list.append(
+                {
+                    "device": port.device,
+                    "description": port.description,
+                    "manufacturer": getattr(port, "manufacturer", "Unknown"),
+                    "product": getattr(port, "product", "Unknown"),
+                    "vid": getattr(port, "vid", None),
+                    "pid": getattr(port, "pid", None),
+                }
+            )
+
+        if not port_list:
+            return "No serial ports found on the system"
+        return json.dumps({"success": True, "ports": port_list}, indent=2)
+    except Exception as e:
+        logger.error("Error listing serial ports: %s", e)
+        return f"Error listing serial ports: {str(e)}"
+
+
+async def run_stdio_async() -> None:
+    """Run FastMCP stdio server (used by CLI and bridge)."""
+    logger.info("Starting SAT FastMCP Server (stdio)")
+    await mcp.run_stdio_async()
+
+
+if __name__ == "__main__":
+    import nest_asyncio
+
+    nest_asyncio.apply()
+    asyncio.run(run_stdio_async())

iotsploit_mcp-0.0.6/src/iotsploit_mcp/tools/__init__.py

@@ -0,0 +1,5 @@
+"""
+iotsploit_mcp.tools
+"""
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/tools/xlogger_mcp.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional
+
+
+@dataclass(frozen=True)
+class _MCPLogConfig:
+    fmt: str = "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
+    datefmt: str = "%Y-%m-%d %H:%M:%S"
+    default_level: int = logging.INFO
+    default_log_dir: str = "/tmp/sat_logs"
+
+
+def _env_bool(name: str, default: bool = False) -> bool:
+    v = os.getenv(name)
+    if v is None:
+        return default
+    return v.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+
+def _env_level(default: int) -> int:
+    v = (os.getenv("IOTSPLOIT_MCP_LOG_LEVEL") or "").strip().upper()
+    if not v:
+        return default
+    return getattr(logging, v, default)
+
+
+def _safe_filename(name: str) -> str:
+    # Keep it deterministic and filesystem-safe.
+    return "".join(c if c.isalnum() or c in {"-", "_", "."} else "_" for c in name).replace(".", "_")
+
+
+class XLoggerMCP:
+    """
+    MCP 组件专用 logger：
+    - 不依赖 Django/Channels
+    - 不调用 logging.basicConfig（避免污染宿主进程）
+    - 默认格式：YYYY-mm-dd HH:MM:SS | LEVEL | name | message
+    - 支持按需写文件（可通过参数或 env 开关）
+    """
+
+    _instance: Optional["XLoggerMCP"] = None
+
+    def __new__(cls) -> "XLoggerMCP":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+        self._initialized = True
+        self._cfg = _MCPLogConfig(default_level=_env_level(_MCPLogConfig.default_level))
+        self._loggers: Dict[str, logging.Logger] = {}
+
+    def get_logger(
+        self,
+        name: str = "iotsploit_mcp",
+        *,
+        level: Optional[int] = None,
+        to_file: Optional[bool] = None,
+        file_path: Optional[str] = None,
+    ) -> logging.Logger:
+        lvl = self._cfg.default_level if level is None else level
+        want_file = _env_bool("IOTSPLOIT_MCP_LOG_TO_FILE", False) if to_file is None else bool(to_file)
+
+        # Global override: send all MCP logs to a single file if provided.
+        env_log_file = (os.getenv("IOTSPLOIT_MCP_LOG_FILE") or "").strip() or None
+        env_log_dir = (os.getenv("IOTSPLOIT_MCP_LOG_DIR") or "").strip() or None
+
+        logger = self._loggers.get(name) or logging.getLogger(name)
+        logger.setLevel(lvl)
+
+        formatter = logging.Formatter(self._cfg.fmt, datefmt=self._cfg.datefmt)
+
+        # Ensure stream handler exists (stderr).
+        if not any(getattr(h, "_mcp_stream", False) for h in logger.handlers):
+            sh = logging.StreamHandler(sys.stderr)
+            sh.setLevel(lvl)
+            sh.setFormatter(formatter)
+            setattr(sh, "_mcp_stream", True)
+            logger.addHandler(sh)
+
+        # File handler is optional and can be enabled later.
+        if want_file:
+            target_file = (
+                file_path
+                or env_log_file
+                or str(Path(env_log_dir or self._cfg.default_log_dir) / f"{_safe_filename(name)}.log")
+            )
+
+            if not any(getattr(h, "_mcp_file", None) == target_file for h in logger.handlers):
+                Path(target_file).parent.mkdir(parents=True, exist_ok=True)
+                fh = logging.FileHandler(target_file)
+                fh.setLevel(logging.DEBUG)
+                fh.setFormatter(formatter)
+                setattr(fh, "_mcp_file", target_file)
+                logger.addHandler(fh)
+
+        logger.propagate = False
+        self._loggers[name] = logger
+        return logger
+
+    # Convenience wrappers (optional, mirrors iotsploit_django.tools.xlogger)
+    def debug(self, msg: str, name: str = "iotsploit_mcp", **kwargs) -> None:
+        self.get_logger(name).debug(msg, **kwargs)
+
+    def info(self, msg: str, name: str = "iotsploit_mcp", **kwargs) -> None:
+        self.get_logger(name).info(msg, **kwargs)
+
+    def warning(self, msg: str, name: str = "iotsploit_mcp", **kwargs) -> None:
+        self.get_logger(name).warning(msg, **kwargs)
+
+    def error(self, msg: str, name: str = "iotsploit_mcp", **kwargs) -> None:
+        self.get_logger(name).error(msg, **kwargs)
+
+    def critical(self, msg: str, name: str = "iotsploit_mcp", **kwargs) -> None:
+        self.get_logger(name).critical(msg, **kwargs)
+
+
+# Global instance
+xlog_mcp = XLoggerMCP()
+
+

iotsploit_mcp-0.0.6/src/iotsploit_mcp/websocket_bridge_simple.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""
+Simplified WebSocket Bridge for SAT FastMCP Server
+
+Bridge listens on ws://host:port (default 0.0.0.0:9998) and proxies messages to a
+FastMCP stdio subprocess.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import subprocess
+import sys
+from typing import Optional, Set
+
+import websockets
+
+
+from iotsploit_mcp.tools.xlogger_mcp import xlog_mcp
+
+logger = xlog_mcp.get_logger("iotsploit_mcp.websocket_bridge_simple")
+
+
+class SATMCPWebSocketBridge:
+    """Bridge between WebSocket clients and FastMCP stdio server."""
+
+    def __init__(self, *, host: str = "0.0.0.0", port: int = 9998):
+        self.host = host
+        self.port = port
+        self.mcp_process: Optional[subprocess.Popen] = None
+        self.clients: Set[websockets.WebSocketServerProtocol] = set()
+        self.mcp_initialized = False
+        self.request_id = 0
+
+    async def start_mcp_server(self) -> bool:
+        """Start the FastMCP stdio server process."""
+        try:
+            logger.info("Starting FastMCP server (stdio) via python -m iotsploit_mcp.cli stdio")
+            self.mcp_process = subprocess.Popen(
+                [sys.executable, "-m", "iotsploit_mcp.cli", "stdio"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=0,
+            )
+            logger.info("FastMCP server started with PID: %s", self.mcp_process.pid)
+            # Important: initialize immediately. Some environments may behave as if stdin is EOF
+            # unless a first line is promptly written.
+            await self.initialize_mcp_session()
+
+            # Give the process a brief moment; if it still exits, surface stderr for debugging.
+            await asyncio.sleep(0.1)
+            rc = self.mcp_process.poll()
+            if rc is not None:
+                try:
+                    stderr = self.mcp_process.stderr.read() if self.mcp_process.stderr else ""
+                except Exception:
+                    stderr = ""
+                logger.error("FastMCP server process terminated immediately (rc=%s). stderr=%r", rc, stderr[:2000])
+                return False
+
+            return True
+        except Exception as e:
+            logger.error("Failed to start MCP server: %s", e)
+            return False
+
+    async def initialize_mcp_session(self) -> None:
+        try:
+            logger.info("Initializing MCP session...")
+            initialize_request = {
+                "jsonrpc": "2.0",
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {"tools": {}},
+                    "clientInfo": {"name": "SAT-WebSocket-Bridge", "version": "1.0.0"},
+                },
+                "id": "init",
+            }
+            await self.send_to_mcp(initialize_request)
+
+            response_line = await asyncio.wait_for(
+                asyncio.get_event_loop().run_in_executor(None, self.mcp_process.stdout.readline),
+                timeout=5.0,
+            )
+
+            if response_line:
+                response = json.loads(response_line.strip())
+                if response.get("id") == "init" and "result" in response:
+                    initialized_notification = {"jsonrpc": "2.0", "method": "notifications/initialized", "params": {}}
+                    await self.send_to_mcp(initialized_notification)
+                    self.mcp_initialized = True
+                    logger.info("MCP session initialized successfully")
+                else:
+                    logger.error("MCP initialization failed: %s", response)
+            else:
+                logger.error("No response to MCP initialize request")
+        except Exception as e:
+            logger.error("Failed to initialize MCP session: %s", e)
+
+    async def send_to_mcp(self, data: dict) -> None:
+        try:
+            message = json.dumps(data) + "\n"
+            assert self.mcp_process is not None and self.mcp_process.stdin is not None
+            self.mcp_process.stdin.write(message)
+            self.mcp_process.stdin.flush()
+        except Exception as e:
+            logger.error("Error sending to MCP: %s", e)
+
+    async def handle_client(self, websocket):
+        client_addr = f"{websocket.remote_address[0]}:{websocket.remote_address[1]}"
+        try:
+            logger.info("New client connected: %s", client_addr)
+            self.clients.add(websocket)
+            async for message in websocket:
+                try:
+                    data = json.loads(message)
+                    msg_type = data.get("type")
+                    if msg_type == "mcp_call_tool":
+                        await self.handle_tool_call(data, websocket)
+                    elif msg_type == "mcp_list_tools":
+                        await self.handle_list_tools(websocket)
+                    else:
+                        await websocket.send(json.dumps({"type": "error", "error": f"Unknown message type: {msg_type}"}))
+                except json.JSONDecodeError:
+                    await websocket.send(json.dumps({"type": "error", "error": "Invalid JSON format"}))
+        except websockets.exceptions.ConnectionClosed:
+            logger.info("Client %s disconnected", client_addr)
+        except Exception as e:
+            logger.error("Error handling client %s: %s", client_addr, e)
+        finally:
+            self.clients.discard(websocket)
+
+    async def handle_tool_call(self, data: dict, websocket) -> None:
+        try:
+            if not self.mcp_initialized:
+                await websocket.send(json.dumps({"type": "error", "error": "MCP not initialized"}))
+                return
+
+            tool_name = data.get("tool_name")
+            arguments = data.get("arguments", {})
+            if not tool_name:
+                await websocket.send(json.dumps({"type": "error", "error": "Missing tool_name"}))
+                return
+
+            self.request_id += 1
+            request_id = f"req_{self.request_id}"
+
+            params = {"name": tool_name}
+            if arguments:
+                params["arguments"] = arguments
+
+            mcp_request = {"jsonrpc": "2.0", "method": "tools/call", "params": params, "id": request_id}
+            await self.send_to_mcp(mcp_request)
+
+            response_line = await asyncio.wait_for(
+                asyncio.get_event_loop().run_in_executor(None, self.mcp_process.stdout.readline),
+                timeout=30.0,
+            )
+
+            if response_line:
+                mcp_response = json.loads(response_line.strip())
+                if "result" in mcp_response:
+                    await websocket.send(
+                        json.dumps({"type": "tool_result", "tool_name": tool_name, "result": mcp_response["result"]})
+                    )
+                else:
+                    await websocket.send(
+                        json.dumps(
+                            {"type": "tool_error", "tool_name": tool_name, "error": mcp_response.get("error", "Unknown error")}
+                        )
+                    )
+            else:
+                await websocket.send(json.dumps({"type": "tool_error", "tool_name": tool_name, "error": "No response from MCP server"}))
+        except asyncio.TimeoutError:
+            await websocket.send(json.dumps({"type": "tool_error", "tool_name": tool_name, "error": "Tool execution timeout"}))
+        except Exception as e:
+            await websocket.send(json.dumps({"type": "tool_error", "tool_name": tool_name, "error": str(e)}))
+
+    async def handle_list_tools(self, websocket) -> None:
+        try:
+            if not self.mcp_initialized:
+                await websocket.send(json.dumps({"type": "error", "error": "MCP not initialized"}))
+                return
+
+            self.request_id += 1
+            request_id = f"req_{self.request_id}"
+            mcp_request = {"jsonrpc": "2.0", "method": "tools/list", "params": {}, "id": request_id}
+            await self.send_to_mcp(mcp_request)
+
+            response_line = await asyncio.wait_for(
+                asyncio.get_event_loop().run_in_executor(None, self.mcp_process.stdout.readline),
+                timeout=10.0,
+            )
+            if response_line:
+                mcp_response = json.loads(response_line.strip())
+                if "result" in mcp_response:
+                    await websocket.send(json.dumps({"type": "tools_list", "tools": mcp_response["result"].get("tools", [])}))
+                else:
+                    await websocket.send(json.dumps({"type": "error", "error": mcp_response.get("error", "Unknown error")}))
+            else:
+                await websocket.send(json.dumps({"type": "error", "error": "No response from MCP server"}))
+        except asyncio.TimeoutError:
+            await websocket.send(json.dumps({"type": "error", "error": "List tools timeout"}))
+        except Exception as e:
+            await websocket.send(json.dumps({"type": "error", "error": str(e)}))
+
+    async def start_server(self) -> None:
+        logger.info("Starting WebSocket bridge on %s:%s", self.host, self.port)
+        if not await self.start_mcp_server():
+            logger.error("Failed to start MCP server")
+            return
+        try:
+            async with websockets.serve(self.handle_client, self.host, self.port):
+                logger.info("WebSocket bridge running on ws://%s:%s", self.host, self.port)
+                await asyncio.Future()
+        finally:
+            await self.cleanup()
+
+    async def cleanup(self) -> None:
+        logger.info("Cleaning up...")
+        if self.mcp_process:
+            try:
+                self.mcp_process.terminate()
+                await asyncio.sleep(1)
+                if self.mcp_process.poll() is None:
+                    self.mcp_process.kill()
+                logger.info("FastMCP server stopped")
+            except Exception as e:
+                logger.error("Error stopping MCP server: %s", e)
+
+
+async def main() -> None:
+    bridge = SATMCPWebSocketBridge()
+    try:
+        await bridge.start_server()
+    finally:
+        await bridge.cleanup()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+