halyn 0.2.0__py3-none-any.whl

halyn/cli.py

@@ -0,0 +1,208 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+CLI — halyn serve | scan | status | test | emergency-stop
+
+The command line is the cockpit.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+import sys
+import time
+from typing import Any
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="halyn",
+        description="Halyn — NRP Control Plane",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # serve
+    p_serve = sub.add_parser("serve", help="Start the control plane + HTTP server")
+    p_serve.add_argument("--config", "-c", default="", help="Config file path")
+    p_serve.add_argument("--host", default="", help="Override host")
+    p_serve.add_argument("--port", type=int, default=0, help="Override port")
+
+    # scan
+    p_scan = sub.add_parser("scan", help="Discover nodes on the network")
+    p_scan.add_argument("--subnet", default="", help="Subnet to scan (e.g. 192.168.1.0/24)")
+    p_scan.add_argument("--ssh", nargs="*", default=[], help="SSH hosts to check")
+    p_scan.add_argument("--mqtt", nargs="*", default=[], help="MQTT brokers to check")
+    p_scan.add_argument("--http", nargs="*", default=[], help="HTTP URLs to check")
+    p_scan.add_argument("--docker", nargs="*", default=[], help="Docker hosts")
+    p_scan.add_argument("--json", action="store_true", help="Output as JSON")
+
+    # status
+    p_status = sub.add_parser("status", help="Show control plane status")
+    p_status.add_argument("--config", "-c", default="")
+
+    # test
+    p_test = sub.add_parser("test", help="Run test suite")
+
+    # emergency-stop
+    sub.add_parser("emergency-stop", help="STOP ALL NODES IMMEDIATELY")
+
+    # version
+    sub.add_parser("version", help="Show version")
+
+    args = parser.parse_args()
+
+    if args.command == "serve":
+        _cmd_serve(args)
+    elif args.command == "scan":
+        _cmd_scan(args)
+    elif args.command == "status":
+        _cmd_status(args)
+    elif args.command == "test":
+        _cmd_test()
+    elif args.command == "emergency-stop":
+        _cmd_emergency_stop(args)
+    elif args.command == "version":
+        from . import __version__
+        print(f"Halyn v{__version__}")
+    else:
+        parser.print_help()
+
+
+def _cmd_serve(args: Any) -> None:
+    from .config import HalynConfig
+    from .control_plane import ControlPlane
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    config = HalynConfig.load(args.config)
+    if args.host:
+        config.host = args.host
+    if args.port:
+        config.port = args.port
+
+    cp = ControlPlane(config)
+
+    async def run() -> None:
+        await cp.start()
+        status = cp.status()
+        print(f"\n  Halyn v0.1.0 — listening on {config.host}:{config.port}")
+        print(f"  {status['nodes']} nodes | {status['tools']} tools | MCP ready")
+        print(f"  Audit: {status['audit_entries']} entries | Chain: {'valid' if status['audit_chain_valid'] else 'BROKEN'}")
+        print(f"  Watchdog: {status['watchdog']['overall']}")
+        print()
+
+        try:
+            from .server import create_app
+            from aiohttp import web
+            app = create_app(cp, config.api_key)
+            from .mcp import mount_mcp
+            mount_mcp(app, cp)
+            runner = web.AppRunner(app)
+            await runner.setup()
+            site = web.TCPSite(runner, config.host, config.port)
+            await site.start()
+            print(f"  HTTP: http://{config.host}:{config.port}")
+            print(f"  MCP:  http://{config.host}:{config.port}/mcp")
+            print(f"  SSE:  http://{config.host}:{config.port}/events")
+            print()
+            await asyncio.Event().wait()  # Run forever
+        except ImportError:
+            print("  aiohttp not installed — running without HTTP server")
+            print("  Install: pip install aiohttp")
+            await asyncio.Event().wait()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            await cp.stop()
+
+    asyncio.run(run())
+
+
+def _cmd_scan(args: Any) -> None:
+    from .discovery import Scanner
+
+    logging.basicConfig(level=logging.WARNING)
+
+    scanner = Scanner(timeout=1.0)
+    config: dict[str, Any] = {}
+
+    if args.ssh:
+        config["ssh_hosts"] = args.ssh
+    if args.subnet:
+        config["subnets"] = [args.subnet]
+    if args.mqtt:
+        config["mqtt_brokers"] = args.mqtt
+    if args.http:
+        config["http_urls"] = args.http
+    if args.docker:
+        config["docker_hosts"] = args.docker
+
+    if not config:
+        # Default: scan localhost
+        config = {"docker_hosts": ["localhost"]}
+
+    print("\n  Halyn — Scanning...\n")
+    t0 = time.time()
+
+    nodes = asyncio.run(scanner.scan_all(config))
+
+    elapsed = time.time() - t0
+
+    if getattr(args, 'json', False):
+        print(json.dumps([{
+            "address": n.address, "port": n.port,
+            "protocol": n.protocol, "name": n.name,
+            "nrp_id": n.suggested_nrp_id,
+            "metadata": n.metadata,
+        } for n in nodes], indent=2))
+    else:
+        print(scanner.format_results(nodes))
+        print(f"\n  Scanned in {elapsed:.1f}s")
+        if nodes:
+            print(f"\n  To connect: halyn serve --config halyn.yml")
+
+
+def _cmd_status(args: Any) -> None:
+    """Query a running Halyn instance."""
+    import urllib.request
+    try:
+        url = "http://localhost:8935/health"
+        with urllib.request.urlopen(url, timeout=5) as resp:
+            data = json.loads(resp.read())
+            print(json.dumps(data, indent=2))
+    except Exception as e:
+        print(f"Cannot reach Halyn at localhost:8935: {e}")
+        print("Is Halyn running? Start with: halyn serve")
+
+
+def _cmd_test() -> None:
+    """Run the test suite."""
+    import subprocess
+    test_path = __file__.replace("cli.py", "").replace("src/halyn/", "") + "tests/test_halyn.py"
+    subprocess.run([sys.executable, test_path])
+
+
+def _cmd_emergency_stop(args: Any) -> None:
+    """Send emergency stop to running instance."""
+    import urllib.request
+    try:
+        req = urllib.request.Request(
+            "http://localhost:8935/emergency-stop",
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            print("EMERGENCY STOP SENT")
+            print(resp.read().decode())
+    except Exception as e:
+        print(f"Cannot reach Halyn: {e}")
+
+
+if __name__ == "__main__":
+    main()

halyn/config.py

@@ -0,0 +1,135 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+Configuration — YAML-based Halyn setup.
+
+YAML/env-based configuration loader.
+Merges file config, environment variables, and defaults.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger("halyn.config")
+
+_DEFAULT_CONFIG = {
+    "version": "1",
+    "server": {
+        "host": "0.0.0.0",
+        "port": 8935,
+        "api_key": "",
+    },
+    "llm": {
+        "provider": "ollama",
+        "model": "",
+        "api_key": "",
+    },
+    "domains": {
+        "infrastructure": {
+            "level": 2,
+            "nodes": ["server/*", "cloud/*", "docker/*"],
+            "confirm": ["restart", "deploy", "delete"],
+        },
+        "monitoring": {
+            "level": 4,
+            "nodes": ["sensor/*", "monitor/*"],
+        },
+    },
+    "nodes": [],
+    "logging": {
+        "level": "INFO",
+        "file": "",
+    },
+}
+
+
+@dataclass(slots=True)
+class HalynConfig:
+    """Parsed configuration."""
+    host: str = "0.0.0.0"
+    port: int = 8935
+    api_key: str = ""
+    llm_provider: str = "ollama"
+    llm_model: str = ""
+    llm_api_key: str = ""
+    domains: dict[str, dict[str, Any]] = field(default_factory=dict)
+    nodes: list[dict[str, Any]] = field(default_factory=list)
+    log_level: str = "INFO"
+    log_file: str = ""
+    data_dir: str = ""
+
+    @classmethod
+    def load(cls, path: str = "") -> HalynConfig:
+        """Load config from YAML file, env vars, or defaults."""
+        raw = dict(_DEFAULT_CONFIG)
+
+        # Try loading YAML
+        config_path = path or os.environ.get("HALYN_CONFIG", "")
+        if not config_path:
+            for candidate in ["halyn.yml", "halyn.yaml", ".halyn.yml",
+                              str(Path.home() / ".halyn" / "config.yml")]:
+                if Path(candidate).is_file():
+                    config_path = candidate
+                    break
+
+        if config_path and Path(config_path).is_file():
+            try:
+                import yaml
+                with open(config_path) as f:
+                    user_config = yaml.safe_load(f) or {}
+                _deep_merge(raw, user_config)
+                log.info("config.loaded path=%s", config_path)
+            except ImportError:
+                # Fallback: try JSON
+                import json as json_mod
+                if config_path.endswith(".json"):
+                    with open(config_path) as f:
+                        user_config = json_mod.load(f)
+                    _deep_merge(raw, user_config)
+            except Exception as exc:
+                log.warning("config.load_error path=%s error=%s", config_path, exc)
+
+        # Environment variable overrides
+        server = raw.get("server", {})
+        llm = raw.get("llm", {})
+
+        cfg = cls(
+            host=os.environ.get("HALYN_HOST", str(server.get("host", "0.0.0.0"))),
+            port=int(os.environ.get("HALYN_PORT", server.get("port", 8935))),
+            api_key=os.environ.get("HALYN_API_KEY", server.get("api_key", "")),
+            llm_provider=os.environ.get("HALYN_LLM_PROVIDER", llm.get("provider", "ollama")),
+            llm_model=os.environ.get("HALYN_LLM_MODEL", llm.get("model", "")),
+            llm_api_key=os.environ.get("ANTHROPIC_API_KEY",
+                        os.environ.get("OPENAI_API_KEY", llm.get("api_key", ""))),
+            domains=raw.get("domains", {}),
+            nodes=raw.get("nodes", []),
+            log_level=os.environ.get("HALYN_LOG_LEVEL",
+                                     raw.get("logging", {}).get("level", "INFO")),
+            log_file=raw.get("logging", {}).get("file", ""),
+            data_dir=os.environ.get("HALYN_DATA_DIR",
+                                    str(Path.home() / ".halyn")),
+        )
+        return cfg
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "server": {"host": self.host, "port": self.port},
+            "llm": {"provider": self.llm_provider, "model": self.llm_model},
+            "domains": self.domains,
+            "nodes": self.nodes,
+            "logging": {"level": self.log_level},
+        }
+
+
+def _deep_merge(base: dict, override: dict) -> None:
+    for key, val in override.items():
+        if key in base and isinstance(base[key], dict) and isinstance(val, dict):
+            _deep_merge(base[key], val)
+        else:
+            base[key] = val
+

halyn/consent.py

@@ -0,0 +1,243 @@
+# Copyright (c) 2026 Elmadani SALKA. All rights reserved.
+# Licensed under the MIT License. See LICENSE file.
+"""
+Consent — The human decides what connects.
+
+Every new node requires explicit operator approval before
+it can observe or act through the control plane.
+
+The consent flow:
+  1. Discovery finds a node
+  2. Halyn presents it to the human: "New device found: Unitree G1 at 10.0.1.50"
+  3. Human chooses: ALLOW (full) | READ_ONLY | DENY | TEMPORARY (24h)
+  4. Decision is recorded in the consent store (persistent)
+  5. On reconnection, the stored consent is reused (no repeated prompts)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+import threading
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger("halyn.consent")
+
+
+class ConsentLevel(str, Enum):
+    """What the human allows for a node."""
+    FULL = "full"             # observe + act (within shield limits)
+    READ_ONLY = "read_only"   # observe only, no act
+    DENY = "deny"             # blocked entirely
+    TEMPORARY = "temporary"   # full access for limited time
+    PENDING = "pending"       # waiting for human decision
+
+
+@dataclass(slots=True)
+class ConsentRecord:
+    """Persistent record of a consent decision."""
+    nrp_id: str
+    level: ConsentLevel
+    granted_at: float = 0.0
+    expires_at: float = 0.0       # 0 = never expires
+    granted_by: str = ""          # user ID
+    device_info: str = ""         # manifest summary at time of consent
+    reason: str = ""              # why this level was chosen
+
+    @property
+    def expired(self) -> bool:
+        if self.expires_at == 0.0:
+            return False
+        return time.time() > self.expires_at
+
+    @property
+    def active(self) -> bool:
+        return self.level not in (ConsentLevel.DENY, ConsentLevel.PENDING) and not self.expired
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "nrp_id": self.nrp_id,
+            "level": self.level.value,
+            "granted_at": self.granted_at,
+            "expires_at": self.expires_at,
+            "granted_by": self.granted_by,
+            "device_info": self.device_info,
+            "reason": self.reason,
+            "expired": self.expired,
+            "active": self.active,
+        }
+
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS consent (
+    nrp_id TEXT PRIMARY KEY,
+    level TEXT NOT NULL DEFAULT 'pending',
+    granted_at REAL NOT NULL DEFAULT 0,
+    expires_at REAL NOT NULL DEFAULT 0,
+    granted_by TEXT NOT NULL DEFAULT '',
+    device_info TEXT NOT NULL DEFAULT '',
+    reason TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS idx_consent_level ON consent(level);
+"""
+
+
+class ConsentStore:
+    """
+    Persistent consent decisions.
+
+    Stored in SQLite. Survives restarts.
+    Persisted across restarts.
+    """
+
+    def __init__(self, db_path: str = "") -> None:
+        if not db_path:
+            data_dir = Path.home() / ".halyn"
+            data_dir.mkdir(parents=True, exist_ok=True)
+            db_path = str(data_dir / "consent.db")
+        self._db_path = db_path
+        self._lock = threading.Lock()
+        self._conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._conn.execute("PRAGMA journal_mode=WAL")
+        self._conn.executescript(_SCHEMA)
+        self._conn.commit()
+        log.info("consent.init db=%s", db_path)
+
+    def check(self, nrp_id: str) -> ConsentRecord | None:
+        """Check if consent exists for a node. Returns None if no record."""
+        with self._lock:
+            row = self._conn.execute(
+                "SELECT nrp_id, level, granted_at, expires_at, granted_by, device_info, reason "
+                "FROM consent WHERE nrp_id = ?", (nrp_id,)
+            ).fetchone()
+        if not row:
+            return None
+        record = ConsentRecord(
+            nrp_id=row[0], level=ConsentLevel(row[1]),
+            granted_at=row[2], expires_at=row[3],
+            granted_by=row[4], device_info=row[5], reason=row[6],
+        )
+        # Auto-expire temporary consents
+        if record.expired and record.level == ConsentLevel.TEMPORARY:
+            self.revoke(nrp_id, reason="auto-expired")
+            return None
+        return record
+
+    def grant(
+        self,
+        nrp_id: str,
+        level: ConsentLevel,
+        granted_by: str = "",
+        device_info: str = "",
+        reason: str = "",
+        duration_hours: float = 0,
+    ) -> ConsentRecord:
+        """Grant consent for a node."""
+        now = time.time()
+        expires = now + (duration_hours * 3600) if duration_hours > 0 else 0.0
+
+        record = ConsentRecord(
+            nrp_id=nrp_id, level=level,
+            granted_at=now, expires_at=expires,
+            granted_by=granted_by, device_info=device_info,
+            reason=reason,
+        )
+
+        with self._lock:
+            self._conn.execute(
+                "INSERT OR REPLACE INTO consent "
+                "(nrp_id, level, granted_at, expires_at, granted_by, device_info, reason) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (nrp_id, level.value, now, expires, granted_by, device_info, reason),
+            )
+            self._conn.commit()
+
+        log.info("consent.granted nrp_id=%s level=%s by=%s expires=%s",
+                 nrp_id, level.value, granted_by,
+                 f"{duration_hours}h" if duration_hours else "never")
+        return record
+
+    def revoke(self, nrp_id: str, reason: str = "") -> bool:
+        """Revoke consent for a node."""
+        with self._lock:
+            cursor = self._conn.execute(
+                "UPDATE consent SET level = ?, reason = ? WHERE nrp_id = ?",
+                (ConsentLevel.DENY.value, reason or "revoked", nrp_id),
+            )
+            self._conn.commit()
+            revoked = cursor.rowcount > 0
+
+        if revoked:
+            log.info("consent.revoked nrp_id=%s reason=%s", nrp_id, reason)
+        return revoked
+
+    def list_all(self, level: ConsentLevel | None = None) -> list[ConsentRecord]:
+        """List all consent records, optionally filtered by level."""
+        with self._lock:
+            if level:
+                rows = self._conn.execute(
+                    "SELECT nrp_id, level, granted_at, expires_at, granted_by, device_info, reason "
+                    "FROM consent WHERE level = ? ORDER BY granted_at DESC",
+                    (level.value,)
+                ).fetchall()
+            else:
+                rows = self._conn.execute(
+                    "SELECT nrp_id, level, granted_at, expires_at, granted_by, device_info, reason "
+                    "FROM consent ORDER BY granted_at DESC"
+                ).fetchall()
+
+        return [
+            ConsentRecord(
+                nrp_id=r[0], level=ConsentLevel(r[1]),
+                granted_at=r[2], expires_at=r[3],
+                granted_by=r[4], device_info=r[5], reason=r[6],
+            )
+            for r in rows
+        ]
+
+    def pending_count(self) -> int:
+        """How many nodes are waiting for consent."""
+        with self._lock:
+            r = self._conn.execute(
+                "SELECT COUNT(*) FROM consent WHERE level = ?",
+                (ConsentLevel.PENDING.value,)
+            ).fetchone()
+            return r[0] if r else 0
+
+    def request_consent(self, nrp_id: str, device_info: str = "") -> ConsentRecord:
+        """
+        Request consent for a new node.
+        Creates a PENDING record. The human must approve or deny.
+        """
+        existing = self.check(nrp_id)
+        if existing and existing.active:
+            return existing  # Already consented
+
+        return self.grant(
+            nrp_id=nrp_id,
+            level=ConsentLevel.PENDING,
+            device_info=device_info,
+            reason="awaiting human approval",
+        )
+
+    def format_request(self, nrp_id: str, device_info: str = "") -> str:
+        """Format a consent request for display to the human."""
+        return (
+            f"New device detected:\n"
+            f"  Node: {nrp_id}\n"
+            f"  {device_info}\n"
+            f"\n"
+            f"  [ALLOW]      Full access (observe + act within shield limits)\n"
+            f"  [READ_ONLY]  Observe only (no actions)\n"
+            f"  [TEMPORARY]  Full access for 24 hours\n"
+            f"  [DENY]       Block this device\n"
+        )
+
+    def close(self) -> None:
+        with self._lock:
+            self._conn.close()