halyn 0.2.3__tar.gz → 0.3.1__tar.gz

halyn-0.3.1/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: halyn
+Version: 0.3.1
+Summary: Halyn — NRP control plane with domain-scoped authorization.
+Author-email: Elmadani SALKA <contact@halyn.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/ElmadaniS/halyn
+Project-URL: Repository, https://github.com/ElmadaniS/halyn
+Project-URL: Issues, https://github.com/ElmadaniS/halyn/issues
+Keywords: ai,browser,robotics,iot,mcp,nrp,llm,infrastructure,devops
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nrprotocol>=0.1.0
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: enterprise
+Requires-Dist: grpcio>=1.60; extra == "enterprise"
+Requires-Dist: psycopg2-binary; extra == "enterprise"
+Requires-Dist: redis; extra == "enterprise"
+Provides-Extra: robotics
+Requires-Dist: rclpy; extra == "robotics"
+Requires-Dist: unitree-sdk2py; extra == "robotics"
+Provides-Extra: iot
+Requires-Dist: paho-mqtt; extra == "iot"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+
+# Halyn
+
+**Connect any device to any AI.**
+
+[![PyPI](https://img.shields.io/pypi/v/halyn?style=flat-square&color=0a6e3f)](https://pypi.org/project/halyn/)
+[![License](https://img.shields.io/badge/license-MIT-0a6e3f?style=flat-square)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10+-0a6e3f?style=flat-square)](https://pypi.org/project/halyn/)
+
+MCP Server · 12 drivers · Shield rules · Audit chain · 5 autonomy levels
+
+[Website](https://halyn.dev) · [Quickstart](#quickstart) · [MCP Server](#mcp-server) · [Tutorials](https://halyn.dev#tutorials)
+
+</div>
+
+---
+
+## The Problem
+
+MCP connects AI to software. But AI is entering the physical world — robots, drones, factories, farms, hospitals. There's no universal standard for how AI safely controls hardware.
+
+**Halyn connects AI to everything else.** Servers, sensors, robots, industrial machines, smart homes — with safety rules the AI cannot break.
+
+## Quickstart
+
+```bash
+pip install halyn
+```
+
+```python
+from halyn import ControlPlane, SSHDriver
+
+cp = ControlPlane()
+cp.connect(SSHDriver("192.168.1.10", "admin"))
+
+# Safety rules — the AI physically cannot bypass these
+cp.shield("deny * delete *")
+cp.shield("deny * write /etc/*")
+
+# Observe
+state = cp.observe()
+print(state)  # {"cpu": 23.4, "mem": 67.2, ...}
+
+# Act (within shield rules)
+cp.act("restart nginx")     # ✓ allowed
+cp.act("rm -rf /etc")       # ✗ blocked by shield
+```
+
+## MCP Server
+
+Connect Claude.ai, ChatGPT, Cursor, or any MCP client directly to your devices:
+
+```bash
+# Start the MCP Server
+halyn-mcp --port 8935
+
+# In Claude.ai → Settings → MCP → Add Server
+# URL: http://your-server:8935/mcp
+```
+
+Then just talk:
+- *"Show me the status of all connected devices"*
+- *"What's the temperature in the greenhouse?"*
+- *"Restart nginx on server-01"*
+- *"Show me the audit trail"*
+
+The AI sees your devices as tools. Shield rules still apply. Every action is audited.
+
+## 12 Drivers
+
+| Driver | Target | Protocol |
+|--------|--------|----------|
+| `SSHDriver` | Linux/Mac servers | SSH |
+| `HTTPDriver` | REST APIs, webhooks | HTTP |
+| `WebSocketDriver` | Real-time streams | WebSocket |
+| `SerialDriver` | Arduino, Pi, PLCs | Serial |
+| `MQTTDriver` | IoT sensors | MQTT |
+| `OPCUADriver` | Industrial machines | OPC-UA |
+| `ROS2Driver` | Robots, drones | ROS2/DDS |
+| `DDSDriver` | Real-time systems | DDS |
+| `DockerDriver` | Containers | Docker API |
+| `BrowserDriver` | Web automation | Chrome CDP |
+| `UnitreeDriver` | Unitree robots | UDP |
+| `SocketDriver` | Raw TCP/UDP | Socket |
+
+## Safety
+
+**Shield Rules** — Constraints enforced at protocol level. The AI has no power to override them.
+
+```python
+cp.shield("deny * delete *")                    # no deletions
+cp.shield("deny * write temperature > 180")     # thermal limit
+cp.shield("deny lock unlock between 23:00-06:00")  # doors locked at night
+```
+
+**Audit Chain** — Every action recorded in SHA-256 hash chain. Tamper-evident. Append-only.
+
+**Consent Protocol** — Devices and AI negotiate permissions before any interaction.
+
+**5 Autonomy Levels** — From fully manual to fully autonomous. You choose.
+
+| Level | Name | Who Decides |
+|-------|------|-------------|
+| 0 | Manual | Human does everything |
+| 1 | Advisory | AI suggests, human acts |
+| 2 | Supervised | AI acts, human approves |
+| 3 | Monitored | AI acts freely, human watches |
+| 4 | Autonomous | AI decides within shield rules |
+
+## Works with Every LLM
+
+```python
+# Claude
+import anthropic
+client = anthropic.Anthropic()
+response = client.messages.create(model="claude-sonnet-4-6", ...)
+cp.act(response.content[0].text)
+
+# GPT
+from openai import OpenAI
+client = OpenAI()
+response = client.chat.completions.create(model="gpt-5", ...)
+
+# Local (Ollama — no internet needed)
+import ollama
+response = ollama.chat(model="llama4", ...)
+
+# All use the same shield rules. Same audit chain.
+```
+
+## Built on NRP
+
+Halyn implements [NRP (Node Reach Protocol)](https://nrprotocol.dev) — the open standard for AI-to-device communication. 6 primitives: Manifest, Observe, Act, Shield, Audit, Consent.
+
+## Free. Open Source. Forever.
+
+MIT licensed. Use it for anything. Modify it. Build a company on it. No fees, no limits, no lock-in.
+
+---
+
+[halyn.dev](https://halyn.dev) · [nrprotocol.dev](https://nrprotocol.dev) · [PyPI](https://pypi.org/project/halyn/) · [contact@halyn.dev](mailto:contact@halyn.dev)

halyn-0.3.1/README.md

@@ -0,0 +1,142 @@
+<div align="center">
+
+# Halyn
+
+**Connect any device to any AI.**
+
+[![PyPI](https://img.shields.io/pypi/v/halyn?style=flat-square&color=0a6e3f)](https://pypi.org/project/halyn/)
+[![License](https://img.shields.io/badge/license-MIT-0a6e3f?style=flat-square)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10+-0a6e3f?style=flat-square)](https://pypi.org/project/halyn/)
+
+MCP Server · 12 drivers · Shield rules · Audit chain · 5 autonomy levels
+
+[Website](https://halyn.dev) · [Quickstart](#quickstart) · [MCP Server](#mcp-server) · [Tutorials](https://halyn.dev#tutorials)
+
+</div>
+
+---
+
+## The Problem
+
+MCP connects AI to software. But AI is entering the physical world — robots, drones, factories, farms, hospitals. There's no universal standard for how AI safely controls hardware.
+
+**Halyn connects AI to everything else.** Servers, sensors, robots, industrial machines, smart homes — with safety rules the AI cannot break.
+
+## Quickstart
+
+```bash
+pip install halyn
+```
+
+```python
+from halyn import ControlPlane, SSHDriver
+
+cp = ControlPlane()
+cp.connect(SSHDriver("192.168.1.10", "admin"))
+
+# Safety rules — the AI physically cannot bypass these
+cp.shield("deny * delete *")
+cp.shield("deny * write /etc/*")
+
+# Observe
+state = cp.observe()
+print(state)  # {"cpu": 23.4, "mem": 67.2, ...}
+
+# Act (within shield rules)
+cp.act("restart nginx")     # ✓ allowed
+cp.act("rm -rf /etc")       # ✗ blocked by shield
+```
+
+## MCP Server
+
+Connect Claude.ai, ChatGPT, Cursor, or any MCP client directly to your devices:
+
+```bash
+# Start the MCP Server
+halyn-mcp --port 8935
+
+# In Claude.ai → Settings → MCP → Add Server
+# URL: http://your-server:8935/mcp
+```
+
+Then just talk:
+- *"Show me the status of all connected devices"*
+- *"What's the temperature in the greenhouse?"*
+- *"Restart nginx on server-01"*
+- *"Show me the audit trail"*
+
+The AI sees your devices as tools. Shield rules still apply. Every action is audited.
+
+## 12 Drivers
+
+| Driver | Target | Protocol |
+|--------|--------|----------|
+| `SSHDriver` | Linux/Mac servers | SSH |
+| `HTTPDriver` | REST APIs, webhooks | HTTP |
+| `WebSocketDriver` | Real-time streams | WebSocket |
+| `SerialDriver` | Arduino, Pi, PLCs | Serial |
+| `MQTTDriver` | IoT sensors | MQTT |
+| `OPCUADriver` | Industrial machines | OPC-UA |
+| `ROS2Driver` | Robots, drones | ROS2/DDS |
+| `DDSDriver` | Real-time systems | DDS |
+| `DockerDriver` | Containers | Docker API |
+| `BrowserDriver` | Web automation | Chrome CDP |
+| `UnitreeDriver` | Unitree robots | UDP |
+| `SocketDriver` | Raw TCP/UDP | Socket |
+
+## Safety
+
+**Shield Rules** — Constraints enforced at protocol level. The AI has no power to override them.
+
+```python
+cp.shield("deny * delete *")                    # no deletions
+cp.shield("deny * write temperature > 180")     # thermal limit
+cp.shield("deny lock unlock between 23:00-06:00")  # doors locked at night
+```
+
+**Audit Chain** — Every action recorded in SHA-256 hash chain. Tamper-evident. Append-only.
+
+**Consent Protocol** — Devices and AI negotiate permissions before any interaction.
+
+**5 Autonomy Levels** — From fully manual to fully autonomous. You choose.
+
+| Level | Name | Who Decides |
+|-------|------|-------------|
+| 0 | Manual | Human does everything |
+| 1 | Advisory | AI suggests, human acts |
+| 2 | Supervised | AI acts, human approves |
+| 3 | Monitored | AI acts freely, human watches |
+| 4 | Autonomous | AI decides within shield rules |
+
+## Works with Every LLM
+
+```python
+# Claude
+import anthropic
+client = anthropic.Anthropic()
+response = client.messages.create(model="claude-sonnet-4-6", ...)
+cp.act(response.content[0].text)
+
+# GPT
+from openai import OpenAI
+client = OpenAI()
+response = client.chat.completions.create(model="gpt-5", ...)
+
+# Local (Ollama — no internet needed)
+import ollama
+response = ollama.chat(model="llama4", ...)
+
+# All use the same shield rules. Same audit chain.
+```
+
+## Built on NRP
+
+Halyn implements [NRP (Node Reach Protocol)](https://nrprotocol.dev) — the open standard for AI-to-device communication. 6 primitives: Manifest, Observe, Act, Shield, Audit, Consent.
+
+## Free. Open Source. Forever.
+
+MIT licensed. Use it for anything. Modify it. Build a company on it. No fees, no limits, no lock-in.
+
+---
+
+[halyn.dev](https://halyn.dev) · [nrprotocol.dev](https://nrprotocol.dev) · [PyPI](https://pypi.org/project/halyn/) · [contact@halyn.dev](mailto:contact@halyn.dev)

{halyn-0.2.3 → halyn-0.3.1}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "halyn"
-version = "0.2.3"
+version = "0.3.1"
 description = "Halyn — NRP control plane with domain-scoped authorization."
 requires-python = ">=3.10"
 license = {text = "MIT"}
-authors = [{name = "Elmadani SALKA", email = "Elmadani.SALKA@proton.me"}]
+authors = [{name = "Elmadani SALKA", email = "contact@halyn.dev"}]
 readme = "README.md"
 keywords = ["ai", "browser", "robotics", "iot", "mcp", "nrp", "llm", "infrastructure", "devops"]
 classifiers = [
@@ -27,6 +27,7 @@ iot = ["paho-mqtt"]
 dev = ["pytest", "pytest-asyncio", "mypy", "ruff"]
 
 [project.scripts]
+halyn-mcp = "halyn.mcp_serve:main"
 halyn = "halyn.cli:main"
 
 [project.urls]

halyn-0.3.1/src/halyn/integrations/telegram.py

@@ -0,0 +1,193 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+Telegram integration — Halyn in your pocket.
+
+Users interact with the control plane through Telegram.
+Every message goes through the full pipeline:
+auth > autonomy > shield > execute > audit > intent.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+from typing import Any
+
+import aiohttp
+
+log = logging.getLogger("halyn.telegram")
+
+TELEGRAM_API = "https://api.telegram.org/bot{token}"
+
+
+class TelegramBridge:
+    """
+    Bidirectional bridge between Telegram and the Halyn ControlPlane.
+    """
+
+    def __init__(self, control_plane, bot_token="", allowed_users=None):
+        self.cp = control_plane
+        self.token = bot_token or os.environ.get("HALYN_TELEGRAM_TOKEN", "")
+        self.allowed_users = set(allowed_users or [])
+        self._api = TELEGRAM_API.format(token=self.token)
+        self._session = None
+        self._offset = 0
+        self._running = False
+
+    async def start(self):
+        if not self.token:
+            log.warning("telegram: no token (set HALYN_TELEGRAM_TOKEN)")
+            return
+        self._session = aiohttp.ClientSession()
+        self._running = True
+        me = await self._call("getMe")
+        if me.get("ok"):
+            log.info("telegram.connected bot=@%s", me["result"].get("username"))
+        asyncio.create_task(self._poll_loop())
+
+    async def stop(self):
+        self._running = False
+        if self._session:
+            await self._session.close()
+
+    async def send(self, chat_id, text, parse_mode="Markdown"):
+        for chunk in [text[i:i+4000] for i in range(0, len(text), 4000)]:
+            await self._call("sendMessage", {"chat_id": chat_id, "text": chunk, "parse_mode": parse_mode})
+
+    async def _poll_loop(self):
+        while self._running:
+            try:
+                updates = await self._call("getUpdates", {"offset": self._offset, "timeout": 30})
+                if updates.get("ok"):
+                    for u in updates.get("result", []):
+                        self._offset = u["update_id"] + 1
+                        await self._handle(u)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                log.error("telegram.poll: %s", e)
+                await asyncio.sleep(5)
+
+    async def _handle(self, update):
+        msg = update.get("message", {})
+        text = msg.get("text", "").strip()
+        chat_id = msg.get("chat", {}).get("id", 0)
+        user_id = msg.get("from", {}).get("id", 0)
+        username = msg.get("from", {}).get("username", "")
+        if not text or not chat_id:
+            return
+        if self.allowed_users and user_id not in self.allowed_users:
+            await self.send(chat_id, "Access denied.")
+            return
+        log.info("telegram.msg user=%s text=%s", username, text[:60])
+        if text.startswith("/"):
+            await self._cmd(chat_id, text, user_id, username)
+        else:
+            await self._natural(chat_id, text, user_id, username)
+
+    async def _cmd(self, chat_id, text, user_id, username):
+        cmd = text.split()[0].lower()
+        args = text[len(cmd):].strip()
+
+        if cmd == "/start":
+            s = self.cp.status()
+            await self.send(chat_id,
+                f"*Halyn Control Plane*\n"
+                f"Nodes: {s['nodes']} | Tools: {s['tools']}\n"
+                f"Audit: {s['audit_entries']} entries\n"
+                f"Watchdog: {s['watchdog']['overall']}\n\n"
+                f"Commands: /status /nodes /scan /audit /stop /resume\n"
+                f"Or type naturally: _check server load_")
+
+        elif cmd == "/status":
+            s = self.cp.status()
+            await self.send(chat_id,
+                f"*Status*\nNodes: {s['nodes']}\nTools: {s['tools']}\n"
+                f"Emergency: {s['emergency_stop']}\nAudit: {s['audit_entries']}\n"
+                f"Chain: {'valid' if s['audit_chain_valid'] else 'BROKEN'}\n"
+                f"Watchdog: {s['watchdog']['overall']}")
+
+        elif cmd == "/nodes":
+            nodes = []
+            for nid, m in self.cp._manifests.items():
+                nodes.append(f"  {nid} ({len(m.observe)}ch, {len(m.act)}act)")
+            await self.send(chat_id, "*Nodes*\n" + "\n".join(nodes) if nodes else "No nodes.")
+
+        elif cmd == "/scan":
+            await self.send(chat_id, "Scanning...")
+            found = await self.cp.scan()
+            if found:
+                lines = [f"*Found {len(found)}:*"]
+                for n in found:
+                    lines.append(f"  {n.suggested_nrp_id} ({n.protocol})")
+                await self.send(chat_id, "\n".join(lines))
+            else:
+                await self.send(chat_id, "No devices found.")
+
+        elif cmd == "/audit":
+            entries = self.cp.audit.query(limit=5)
+            valid, count, info = self.cp.audit.verify_chain()
+            lines = [f"*Audit* ({count} entries, {info})"]
+            for e in entries:
+                lines.append(f"  [{e.status}] {e.tool}")
+            await self.send(chat_id, "\n".join(lines))
+
+        elif cmd == "/stop":
+            await self.cp.emergency_stop()
+            await self.send(chat_id, "EMERGENCY STOP. All nodes halted.")
+
+        elif cmd == "/resume":
+            await self.cp.resume()
+            await self.send(chat_id, "Resumed.")
+
+        elif cmd == "/exec":
+            if not args:
+                await self.send(chat_id, "Usage: /exec tool_name {\"arg\": \"value\"}")
+                return
+            parts = args.split(" ", 1)
+            tool = parts[0]
+            tool_args = json.loads(parts[1]) if len(parts) > 1 else {}
+            result = await self.cp.execute(tool, tool_args, user_id=str(user_id),
+                intent_text=f"telegram:{username} /exec {tool}")
+            if result.ok:
+                await self.send(chat_id, f"```\n{json.dumps(result.data, indent=2, default=str)}\n```")
+            else:
+                await self.send(chat_id, f"Blocked: {result.error}")
+
+    async def _natural(self, chat_id, text, user_id, username):
+        tl = text.lower()
+        if any(w in tl for w in ["status", "health"]):
+            await self._cmd(chat_id, "/status", user_id, username); return
+        if any(w in tl for w in ["nodes", "devices"]):
+            await self._cmd(chat_id, "/nodes", user_id, username); return
+        if any(w in tl for w in ["scan", "discover"]):
+            await self._cmd(chat_id, "/scan", user_id, username); return
+        if any(w in tl for w in ["audit", "log", "trail"]):
+            await self._cmd(chat_id, "/audit", user_id, username); return
+        if any(w in tl for w in ["stop", "halt", "emergency"]):
+            await self._cmd(chat_id, "/stop", user_id, username); return
+
+        tools = sorted(self.cp.engine.registry.tool_names)
+        for tool in tools:
+            parts = tool.replace("/", " ").replace(".", " ").split()
+            if any(p in tl for p in parts if len(p) > 2):
+                result = await self.cp.execute(tool, {},
+                    user_id=str(user_id), intent_text=f"telegram:{username}: {text}")
+                if result.ok:
+                    await self.send(chat_id, f"```\n{json.dumps(result.data, indent=2, default=str)}\n```")
+                else:
+                    await self.send(chat_id, f"Blocked: {result.error}")
+                return
+
+        await self.send(chat_id, f"{len(tools)} tools available. Try /nodes or /exec <tool>")
+
+    async def _call(self, method, data=None):
+        try:
+            async with self._session.post(f"{self._api}/{method}", json=data or {}) as r:
+                return await r.json()
+        except Exception as e:
+            return {"ok": False, "error": str(e)}