halyn 0.2.0__py3-none-any.whl

halyn/drivers/browser.py

@@ -0,0 +1,60 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+Browser Driver — Chrome/Chromium via CDP.
+"""
+from __future__ import annotations
+import json
+import subprocess
+from typing import Any
+from nrp import NRPDriver, ShieldRule, ShieldType
+
+class BrowserDriver(NRPDriver):
+    def __init__(self, cdp_url: str = "http://localhost:9222") -> None:
+        self.cdp_url = cdp_url
+
+    @property
+    def kind(self) -> str: return "browser"
+
+    @property
+    def capabilities(self) -> list[str]:
+        return ["navigate", "screenshot", "click", "type", "read_page", "tabs", "execute_js"]
+
+    async def observe(self, channels: list[str] | None = None) -> dict[str, Any]:
+        import aiohttp
+        async with aiohttp.ClientSession() as s:
+            async with s.get(f"{self.cdp_url}/json") as r:
+                tabs = await r.json()
+        return {"tabs": [{"title": t.get("title",""), "url": t.get("url","")} for t in tabs[:10]]}
+
+    async def act(self, command: str, args: dict[str, Any]) -> Any:
+        if command == "navigate":
+            return await self._cdp_cmd("Page.navigate", {"url": args["url"]})
+        elif command == "screenshot":
+            data = await self._cdp_cmd("Page.captureScreenshot", {})
+            return {"base64_length": len(data.get("data",""))}
+        elif command == "execute_js":
+            return await self._cdp_cmd("Runtime.evaluate", {"expression": args["code"]})
+        raise ValueError(f"Unknown browser command: {command}")
+
+    def shield_rules(self) -> list[ShieldRule]:
+        return [
+            ShieldRule("no_file_urls", ShieldType.PATTERN, "file://", description="Block local file access"),
+            ShieldRule("no_data_exfil", ShieldType.PATTERN, "document.cookie", description="Block cookie theft"),
+        ]
+
+    async def _cdp_cmd(self, method: str, params: dict) -> dict:
+        import aiohttp
+        async with aiohttp.ClientSession() as s:
+            async with s.get(f"{self.cdp_url}/json") as r:
+                tabs = await r.json()
+            if not tabs:
+                return {"error": "no tabs"}
+            ws_url = tabs[0].get("webSocketDebuggerUrl", "")
+            if not ws_url:
+                return {"error": "no websocket"}
+            async with s.ws_connect(ws_url) as ws:
+                await ws.send_json({"id": 1, "method": method, "params": params})
+                resp = await ws.receive_json()
+                return resp.get("result", {})
+

halyn/drivers/dds.py

@@ -0,0 +1,156 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+DDS meta-driver — Data Distribution Service (pub/sub real-time).
+
+Covers: ROS2 (via rmw), autonomous vehicles, military systems,
+real-time telemetry, high-frequency sensor fusion.
+DDS operates at UDP layer with QoS guarantees.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import Any
+
+from nrp import (
+    NRPDriver, NRPManifest, NRPId,
+    ChannelSpec, ActionSpec, ShieldSpec, ShieldRule, ShieldType,
+)
+
+log = logging.getLogger("halyn.drivers.dds")
+
+try:
+    import rclpy
+    from rclpy.node import Node as ROS2Node
+    HAS_ROS2 = True
+except ImportError:
+    HAS_ROS2 = False
+
+
+class DDSDriver(NRPDriver):
+    """
+    DDS pub/sub driver with optional ROS2 bridge.
+
+    Two modes:
+      - ros2: uses rclpy for full ROS2 interop
+      - raw: direct DDS via cyclonedds-python
+    """
+
+    def __init__(
+        self,
+        domain_id: int = 0,
+        topics_sub: list[str] | None = None,
+        topics_pub: list[str] | None = None,
+        qos_depth: int = 10,
+        mode: str = "ros2",
+    ) -> None:
+        super().__init__()
+        self.domain_id = domain_id
+        self.topics_sub = topics_sub or []
+        self.topics_pub = topics_pub or []
+        self.qos_depth = qos_depth
+        self.mode = mode
+        self._state: dict[str, Any] = {}
+        self._msg_counts: dict[str, int] = {}
+        self._node = None
+        self._subs: list[Any] = []
+        self._pubs: dict[str, Any] = {}
+
+    def manifest(self) -> NRPManifest:
+        channels = [
+            ChannelSpec("active_topics", "json", description="Subscribed topics and message counts"),
+        ]
+        for topic in self.topics_sub:
+            channels.append(ChannelSpec(
+                topic.replace("/", "_").strip("_"),
+                "json", rate="on_change",
+                description=f"Latest message from {topic}",
+            ))
+
+        actions = []
+        for topic in self.topics_pub:
+            safe_name = topic.replace("/", "_").strip("_")
+            actions.append(ActionSpec(
+                f"pub_{safe_name}",
+                {"message": "json — message payload"},
+                f"Publish to {topic}",
+            ))
+        actions.append(ActionSpec("list_topics", {}, "Enumerate discovered DDS topics"))
+
+        return NRPManifest(
+            nrp_id=self._nrp_id or NRPId.create("local", "dds", f"domain-{self.domain_id}"),
+            manufacturer="DDS",
+            model=f"domain={self.domain_id} mode={self.mode}",
+            observe=channels,
+            act=actions,
+            shield=[ShieldSpec("pub_rate", "limit", 1000, "msg/s")],
+        )
+
+    async def connect(self) -> bool:
+        if self.mode == "ros2":
+            return self._connect_ros2()
+        log.warning("dds: raw DDS mode requires cyclonedds (not yet bundled)")
+        return False
+
+    async def observe(self, channels: list[str] | None = None) -> dict[str, Any]:
+        state: dict[str, Any] = {"active_topics": dict(self._msg_counts)}
+        if channels:
+            for ch in channels:
+                if ch in self._state:
+                    state[ch] = self._state[ch]
+        else:
+            state.update(self._state)
+        return state
+
+    async def act(self, command: str, args: dict[str, Any]) -> Any:
+        if command == "list_topics" and self._node and HAS_ROS2:
+            return {
+                "publishers": self._node.get_publisher_names_and_types_by_node(
+                    self._node.get_name(), self._node.get_namespace()),
+                "subscribers": self._node.get_subscriber_names_and_types_by_node(
+                    self._node.get_name(), self._node.get_namespace()),
+            }
+        for topic in self.topics_pub:
+            safe = topic.replace("/", "_").strip("_")
+            if command == f"pub_{safe}":
+                return self._publish(topic, args.get("message", {}))
+        return {"error": f"unknown: {command}"}
+
+    def shield_rules(self) -> list[ShieldRule]:
+        return [ShieldRule("pub_rate", ShieldType.LIMIT, 1000)]
+
+    async def disconnect(self) -> None:
+        if self._node and HAS_ROS2:
+            self._node.destroy_node()
+        self._node = None
+
+    def _connect_ros2(self) -> bool:
+        if not HAS_ROS2:
+            log.warning("dds: rclpy not installed")
+            return False
+        try:
+            if not rclpy.ok():
+                rclpy.init()
+            self._node = ROS2Node("halyn_dds_bridge", namespace=f"halyn")
+            log.info("dds.ros2_connected domain=%d topics=%d",
+                     self.domain_id, len(self.topics_sub))
+            return True
+        except Exception as e:
+            log.error("dds.ros2_failed: %s", e)
+            return False
+
+    def _publish(self, topic: str, message: Any) -> dict[str, Any]:
+        pub = self._pubs.get(topic)
+        if not pub:
+            return {"error": f"no publisher for {topic}"}
+        try:
+            from std_msgs.msg import String
+            msg = String()
+            msg.data = message if isinstance(message, str) else str(message)
+            pub.publish(msg)
+            return {"published": topic, "size": len(msg.data)}
+        except Exception as e:
+            return {"error": str(e)}

halyn/drivers/docker.py

@@ -0,0 +1,62 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+Docker Driver — Containers, images, volumes.
+"""
+from __future__ import annotations
+import json
+import subprocess
+from typing import Any
+from nrp import NRPDriver, ShieldRule, ShieldType
+
+class DockerDriver(NRPDriver):
+    def __init__(self, host: str = "unix:///var/run/docker.sock") -> None:
+        self.host = host
+
+    @property
+    def kind(self) -> str: return "docker"
+
+    @property
+    def capabilities(self) -> list[str]:
+        return ["run", "stop", "restart", "logs", "exec", "images", "volumes"]
+
+    async def observe(self, channels: list[str] | None = None) -> dict[str, Any]:
+        ps = self._cmd("docker ps --format '{{.Names}}\t{{.Status}}\t{{.Image}}'")
+        containers = []
+        for line in ps.strip().splitlines():
+            parts = line.split("\t")
+            if parts:
+                containers.append({"name": parts[0], "status": parts[1] if len(parts)>1 else "",
+                                   "image": parts[2] if len(parts)>2 else ""})
+        stats = self._cmd("docker system df --format '{{.Type}}\t{{.Size}}'")
+        return {"containers": containers, "disk": stats.strip()}
+
+    async def act(self, command: str, args: dict[str, Any]) -> Any:
+        name = args.get("name", args.get("container", ""))
+        if command == "run":
+            image = args["image"]
+            flags = args.get("flags", "-d")
+            return self._cmd(f"docker run {flags} --name {name} {image}")
+        elif command == "stop":
+            return self._cmd(f"docker stop {name}")
+        elif command == "restart":
+            return self._cmd(f"docker restart {name}")
+        elif command == "logs":
+            n = args.get("lines", 50)
+            return self._cmd(f"docker logs --tail {n} {name}")
+        elif command == "exec":
+            cmd = args.get("command", "echo ok")
+            return self._cmd(f"docker exec {name} {cmd}")
+        raise ValueError(f"Unknown docker command: {command}")
+
+    def shield_rules(self) -> list[ShieldRule]:
+        return [
+            ShieldRule("no_privileged", ShieldType.PATTERN, "--privileged", description="Block privileged containers"),
+            ShieldRule("no_host_network", ShieldType.PATTERN, "--network host", description="Block host networking"),
+            ShieldRule("confirm_stop", ShieldType.CONFIRM, "stop", description="Confirm before stopping"),
+        ]
+
+    def _cmd(self, cmd: str, timeout: int = 15) -> str:
+        r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=timeout)
+        return r.stdout
+

halyn/drivers/http_auto.py

@@ -0,0 +1,259 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+HTTP Auto-Introspection Driver — The universal API connector.
+
+Auto-introspecting HTTP driver.
+
+Reads OpenAPI 3.x or GraphQL introspection schemas
+and generates NRP manifests from discovered endpoints.
+"""
+
+from __future__ import annotations
+
+import json as json_mod
+import logging
+from typing import Any
+from urllib.parse import urljoin
+
+from nrp import NRPDriver, ShieldRule, ShieldType
+
+log = logging.getLogger("halyn.drivers.http_auto")
+
+try:
+    import aiohttp
+    HAS_AIOHTTP = True
+except ImportError:
+    HAS_AIOHTTP = False
+
+
+class HTTPAutoDriver(NRPDriver):
+    """
+    Auto-introspecting HTTP/REST/GraphQL driver.
+
+    Give it a base URL. It discovers the API automatically.
+
+    Supports:
+    - OpenAPI 3.x (reads /openapi.json, /swagger.json, /docs)
+    - GraphQL (reads /graphql introspection)
+    - REST (manual endpoint registration)
+    - Webhook callbacks
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        auth_header: str = "",
+        auth_token: str = "",
+        openapi_path: str = "",
+        timeout: int = 30,
+    ) -> None:
+        super().__init__()
+        self.base_url = base_url.rstrip("/")
+        self.auth_header = auth_header or "Authorization"
+        self.auth_token = auth_token
+        self.openapi_path = openapi_path
+        self.timeout = timeout
+        self._spec: dict[str, Any] = {}
+        self._endpoints: list[dict[str, Any]] = []
+
+    def manifest(self):
+        from nrp import NRPManifest, ChannelSpec, ActionSpec, ShieldSpec
+        nrp_id = self._nrp_id
+        observe_channels = [
+            ChannelSpec("health", "string", description="API health status"),
+            ChannelSpec("endpoints", "json", description="Available API endpoints"),
+        ]
+        actions = []
+
+        for ep in self._endpoints:
+            method = ep.get("method", "GET").upper()
+            path = ep.get("path", "")
+            desc = ep.get("description", f"{method} {path}")
+            args: dict[str, str] = {}
+            for param in ep.get("parameters", []):
+                pname = param.get("name", "")
+                ptype = param.get("type", "string")
+                args[pname] = f"{ptype} — {param.get('description', '')}"
+            if method in ("POST", "PUT", "PATCH"):
+                args["body"] = "json — request body"
+
+            dangerous = method in ("DELETE", "PUT", "PATCH", "POST")
+            action_name = ep.get("operationId", f"{method.lower()}_{path.replace('/', '_').strip('_')}")
+            actions.append(ActionSpec(
+                name=action_name, args=args, description=desc, dangerous=dangerous,
+            ))
+
+        return NRPManifest(
+            nrp_id=nrp_id,
+            manufacturer="HTTP API",
+            model=self._spec.get("info", {}).get("title", self.base_url),
+            firmware=self._spec.get("info", {}).get("version", ""),
+            observe=observe_channels,
+            act=actions,
+            shield=[
+                ShieldSpec("rate_limit", "limit", 100, "req/min", "API rate limit"),
+            ],
+        )
+
+    async def connect(self) -> bool:
+        """Try to discover the API spec automatically."""
+        if not HAS_AIOHTTP:
+            log.warning("http_auto: aiohttp not installed, using manual mode")
+            return True
+
+        spec_paths = [
+            self.openapi_path,
+            "/openapi.json", "/swagger.json",
+            "/api/openapi.json", "/v1/openapi.json",
+            "/docs/openapi.json", "/.well-known/openapi.json",
+        ]
+        headers = self._headers()
+
+        async with aiohttp.ClientSession() as session:
+            for path in spec_paths:
+                if not path:
+                    continue
+                url = urljoin(self.base_url + "/", path.lstrip("/"))
+                try:
+                    async with session.get(url, headers=headers, timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                        if resp.status == 200:
+                            ct = resp.content_type or ""
+                            if "json" in ct or "yaml" in ct:
+                                self._spec = await resp.json()
+                                self._parse_openapi()
+                                log.info("http_auto.spec_found url=%s endpoints=%d",
+                                         url, len(self._endpoints))
+                                return True
+                except Exception as exc:
+                    log.debug("http_auto.probe_failed url=%s error=%s", url, exc)
+
+            # Try GraphQL introspection
+            try:
+                gql_url = urljoin(self.base_url + "/", "graphql")
+                introspection = {"query": "{ __schema { types { name } } }"}
+                async with session.post(gql_url, json=introspection, headers=headers,
+                                        timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                    if resp.status == 200:
+                        data = await resp.json()
+                        if "data" in data and "__schema" in data["data"]:
+                            self._spec = {"graphql": True, "schema": data["data"]["__schema"]}
+                            self._endpoints = [{"method": "POST", "path": "/graphql",
+                                                "operationId": "graphql_query",
+                                                "description": "Execute GraphQL query",
+                                                "parameters": [{"name": "query", "type": "string"}]}]
+                            log.info("http_auto.graphql_found url=%s", gql_url)
+                            return True
+            except Exception:
+                pass
+
+        log.info("http_auto.no_spec_found url=%s (manual mode)", self.base_url)
+        return True
+
+    async def observe(self, channels=None):
+        channels = channels or ["health", "endpoints"]
+        state: dict[str, Any] = {}
+
+        if "health" in channels:
+            if HAS_AIOHTTP:
+                try:
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(
+                            self.base_url, headers=self._headers(),
+                            timeout=aiohttp.ClientTimeout(total=5)
+                        ) as resp:
+                            state["health"] = f"status={resp.status}"
+                except Exception as exc:
+                    state["health"] = f"error: {str(exc)[:100]}"
+            else:
+                state["health"] = "unknown (aiohttp not installed)"
+
+        if "endpoints" in channels:
+            state["endpoints"] = [
+                {"method": ep.get("method"), "path": ep.get("path"),
+                 "name": ep.get("operationId", "")}
+                for ep in self._endpoints[:50]
+            ]
+
+        return state
+
+    async def act(self, command: str, args: dict[str, Any]) -> Any:
+        if not HAS_AIOHTTP:
+            return {"error": "aiohttp not installed"}
+
+        ep = next((e for e in self._endpoints if e.get("operationId") == command), None)
+        if not ep:
+            return {"error": f"Unknown endpoint: {command}"}
+
+        method = ep.get("method", "GET").upper()
+        path = ep.get("path", "/")
+
+        # Substitute path parameters
+        for param in ep.get("parameters", []):
+            pname = param.get("name", "")
+            if pname in args and f"{{{pname}}}" in path:
+                path = path.replace(f"{{{pname}}}", str(args.pop(pname)))
+
+        url = urljoin(self.base_url + "/", path.lstrip("/"))
+        body = args.pop("body", None)
+        query_params = {k: v for k, v in args.items() if v is not None}
+
+        headers = self._headers()
+        if body:
+            headers["Content-Type"] = "application/json"
+
+        async with aiohttp.ClientSession() as session:
+            async with session.request(
+                method, url, headers=headers, params=query_params or None,
+                json=body if body else None,
+                timeout=aiohttp.ClientTimeout(total=self.timeout),
+            ) as resp:
+                ct = resp.content_type or ""
+                if "json" in ct:
+                    data = await resp.json()
+                else:
+                    data = await resp.text()
+                return {"status": resp.status, "data": data}
+
+    def shield_rules(self):
+        return [ShieldRule("rate_limit", ShieldType.LIMIT, 100)]
+
+    def add_endpoint(self, method: str, path: str, operation_id: str = "",
+                     description: str = "", parameters: list[dict] | None = None) -> None:
+        """Manually register an endpoint (when no spec is available)."""
+        self._endpoints.append({
+            "method": method.upper(), "path": path,
+            "operationId": operation_id or f"{method.lower()}_{path.replace('/', '_').strip('_')}",
+            "description": description,
+            "parameters": parameters or [],
+        })
+
+    def _parse_openapi(self) -> None:
+        """Parse OpenAPI 3.x spec into endpoints."""
+        paths = self._spec.get("paths", {})
+        for path, methods in paths.items():
+            for method, details in methods.items():
+                if method.upper() not in ("GET", "POST", "PUT", "DELETE", "PATCH"):
+                    continue
+                params = []
+                for p in details.get("parameters", []):
+                    params.append({
+                        "name": p.get("name", ""),
+                        "type": p.get("schema", {}).get("type", "string"),
+                        "description": p.get("description", ""),
+                        "required": p.get("required", False),
+                    })
+                self._endpoints.append({
+                    "method": method.upper(),
+                    "path": path,
+                    "operationId": details.get("operationId", ""),
+                    "description": details.get("summary", details.get("description", "")),
+                    "parameters": params,
+                })
+
+    def _headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {"Accept": "application/json"}
+        if self.auth_token:
+            headers[self.auth_header] = self.auth_token
+        return headers
+

halyn/drivers/mqtt.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+MQTT Driver — IoT sensors and actuators.
+
+Connects to any MQTT broker. Observes topics. Publishes commands.
+Covers: temperature sensors, smart switches, irrigation, weather stations,
+industrial sensors, home automation, agricultural monitoring.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any
+
+from nrp import NRPDriver, ShieldRule, ShieldType
+
+
+class MQTTDriver(NRPDriver):
+    """Control IoT devices via MQTT."""
+
+    def __init__(self, broker: str = "localhost", port: int = 1883,
+                 topics: list[str] | None = None) -> None:
+        self.broker = broker
+        self.port = port
+        self.topics = topics or []
+        self._client: Any = None
+        self._last_messages: dict[str, Any] = {}
+
+    @property
+    def kind(self) -> str:
+        return "mqtt"
+
+    @property
+    def capabilities(self) -> list[str]:
+        return ["publish", "subscribe", "read_topic", "set_value"]
+
+    async def connect(self) -> bool:
+        try:
+            import paho.mqtt.client as mqtt
+            self._client = mqtt.Client()
+            self._client.on_message = self._on_message
+            self._client.connect(self.broker, self.port, 60)
+            for topic in self.topics:
+                self._client.subscribe(topic)
+            self._client.loop_start()
+            return True
+        except Exception:
+            return False
+
+    async def disconnect(self) -> None:
+        if self._client:
+            self._client.loop_stop()
+            self._client.disconnect()
+
+    async def observe(self, channels: list[str] | None = None) -> dict[str, Any]:
+        if channels:
+            return {ch: self._last_messages.get(ch, None) for ch in channels}
+        return dict(self._last_messages)
+
+    async def act(self, command: str, args: dict[str, Any]) -> Any:
+        if not self._client:
+            raise RuntimeError("Not connected to MQTT broker")
+        topic = args.get("topic", "")
+        payload = args.get("payload", args.get("value", ""))
+        if isinstance(payload, (dict, list)):
+            payload = json.dumps(payload)
+        self._client.publish(topic, str(payload))
+        return {"published": topic, "payload": str(payload)[:200]}
+
+    def shield_rules(self) -> list[ShieldRule]:
+        return [
+            ShieldRule("read_only_sensors", ShieldType.PATTERN, "sensor/*",
+                      description="Sensor topics are read-only"),
+            ShieldRule("max_publish_rate", ShieldType.LIMIT, 10, unit="msg/s",
+                      description="Max 10 messages per second"),
+        ]
+
+    def _on_message(self, client: Any, userdata: Any, msg: Any) -> None:
+        try:
+            payload = msg.payload.decode()
+            try:
+                payload = json.loads(payload)
+            except (json.JSONDecodeError, ValueError):
+                pass
+            self._last_messages[msg.topic] = {
+                "value": payload,
+                "timestamp": time.time(),
+            }
+        except Exception:
+            pass
+