pilotprotocol 1.7.2__tar.gz → 1.9.1__tar.gz

{pilotprotocol-1.7.2 → pilotprotocol-1.9.1}/MANIFEST.in

@@ -3,8 +3,11 @@ include README.md
 include LICENSE
 include CHANGELOG.md
 
-# Include all binaries in bin/ directory
+# Include all binaries in bin/ directory (the seed cache).
+# Dotfiles like .pilot-version need an explicit pattern because some
+# setuptools versions skip them under recursive-include.
 recursive-include pilotprotocol/bin *
+include pilotprotocol/bin/.pilot-version
 
 # Include type stubs if any
 recursive-include pilotprotocol *.pyi

{pilotprotocol-1.7.2/pilotprotocol.egg-info → pilotprotocol-1.9.1}/PKG-INFO

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: pilotprotocol
-Version: 1.7.2
+Version: 1.9.1
 Summary: Python SDK for Pilot Protocol - the network stack for AI agents
-Author-email: Alexandru Godoroja <alex@vulturelabs.com>
-Maintainer-email: Alexandru Godoroja <alex@vulturelabs.com>, Teodor Calin <teodor@vulturelabs.com>
+Author-email: Alexandru Godoroja <alex@pilotprotocol.network>
+Maintainer-email: Alexandru Godoroja <alex@pilotprotocol.network>, Teodor Calin <teodor@pilotprotocol.network>
 License: AGPL-3.0-or-later
 Project-URL: Homepage, https://pilotprotocol.network
 Project-URL: Documentation, https://pilotprotocol.network/docs/
 Project-URL: Repository, https://github.com/TeoSlayer/pilotprotocol
 Project-URL: Bug Tracker, https://github.com/TeoSlayer/pilotprotocol/issues
 Project-URL: Changelog, https://github.com/TeoSlayer/pilotprotocol/blob/main/sdk/python/CHANGELOG.md
-Project-URL: Live Dashboard, https://polo.pilotprotocol.network
 Keywords: pilot-protocol,networking,p2p,agent,ai,protocol,ctypes,udp,encryption
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -312,7 +311,7 @@ See `examples/python_sdk/` for comprehensive examples:
 - **`basic_usage.py`** — Connection, identity, trust management
 - **`data_exchange_demo.py`** — Send messages, files, JSON
 - **`event_stream_demo.py`** — Pub/sub patterns
-- **`task_submit_demo.py`** — Task delegation and polo score
+- **`task_submit_demo.py`** — Task delegation
 - **`pydantic_ai_agent.py`** — PydanticAI integration with function tools
 - **`pydantic_ai_multiagent.py`** — Multi-agent collaboration system
 
@@ -349,7 +348,7 @@ make publish-test     # Publish to TestPyPI
 - **Examples:** `examples/python_sdk/README.md`
 - **CLI Reference:** `examples/cli/BASIC_USAGE.md`
 - **Protocol Spec:** `docs/SPEC.md`
-- **Agent Skills:** `docs/SKILLS.md`
+- **Agent Skills:** https://github.com/TeoSlayer/pilot-skills
 
 ## License
 

{pilotprotocol-1.7.2 → pilotprotocol-1.9.1}/README.md

@@ -273,7 +273,7 @@ See `examples/python_sdk/` for comprehensive examples:
 - **`basic_usage.py`** — Connection, identity, trust management
 - **`data_exchange_demo.py`** — Send messages, files, JSON
 - **`event_stream_demo.py`** — Pub/sub patterns
-- **`task_submit_demo.py`** — Task delegation and polo score
+- **`task_submit_demo.py`** — Task delegation
 - **`pydantic_ai_agent.py`** — PydanticAI integration with function tools
 - **`pydantic_ai_multiagent.py`** — Multi-agent collaboration system
 
@@ -310,7 +310,7 @@ make publish-test     # Publish to TestPyPI
 - **Examples:** `examples/python_sdk/README.md`
 - **CLI Reference:** `examples/cli/BASIC_USAGE.md`
 - **Protocol Spec:** `docs/SPEC.md`
-- **Agent Skills:** `docs/SKILLS.md`
+- **Agent Skills:** https://github.com/TeoSlayer/pilot-skills
 
 ## License
 

pilotprotocol-1.9.1/pilotprotocol/_runtime.py

@@ -0,0 +1,382 @@
+"""Runtime environment seeder for the Pilot Protocol Python SDK.
+
+Both the CLI shims (``cli.py``) and the FFI loader (``client._load_lib``)
+funnel through :func:`ensure_runtime_seeded`, which idempotently mirrors
+the binaries shipped inside the wheel into ``~/.pilot/bin/``.
+
+Design goals:
+- The wheel is the *seed cache*; ``~/.pilot/bin/`` is the canonical runtime.
+- No install-time code runs; seeding happens lazily on first SDK use.
+- Concurrency-safe (flock) and crash-safe (atomic rename).
+- Never downgrades; never replaces a running daemon binary.
+- Coexists with ``install.sh`` (same layout, same ``.pilot-version`` marker).
+"""
+
+from __future__ import annotations
+
+import errno
+import json
+import os
+import platform
+import shutil
+import socket
+import sys
+import tempfile
+import threading
+from pathlib import Path
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+_BIN_NAMES = ("pilotctl", "pilot-daemon", "pilot-gateway", "pilot-updater")
+_LIB_NAMES = {
+    "Darwin": "libpilot.dylib",
+    "Linux": "libpilot.so",
+    "Windows": "libpilot.dll",
+}
+
+DEFAULT_REGISTRY = "34.71.57.205:9000"
+DEFAULT_BEACON = "34.71.57.205:9001"
+DEFAULT_SOCKET = "/tmp/pilot.sock"
+
+
+# ---------------------------------------------------------------------------
+# Path helpers
+# ---------------------------------------------------------------------------
+
+def _pkg_bin_dir() -> Path:
+    """Where the wheel ships its bundled binaries (the seed cache)."""
+    return Path(__file__).resolve().parent / "bin"
+
+
+def _runtime_root() -> Path:
+    """Canonical runtime dir. Honours ``PILOT_HOME`` for CI / multi-tenant."""
+    override = os.environ.get("PILOT_HOME")
+    if override:
+        return Path(override).expanduser()
+    return Path.home() / ".pilot"
+
+
+def _runtime_bin() -> Path:
+    return _runtime_root() / "bin"
+
+
+def _platform_lib_name() -> str:
+    name = _LIB_NAMES.get(platform.system())
+    if name is None:
+        raise OSError(f"unsupported platform: {platform.system()}")
+    return name
+
+
+# ---------------------------------------------------------------------------
+# Version helpers
+# ---------------------------------------------------------------------------
+
+def _semver_tuple(v: str) -> tuple[int, ...]:
+    """Parse a SemVer-ish string into a comparable tuple. Unparseable → ()."""
+    s = (v or "").strip().lstrip("v").split("-", 1)[0].split("+", 1)[0]
+    if not s:
+        return ()
+    parts = []
+    for p in s.split("."):
+        try:
+            parts.append(int(p))
+        except ValueError:
+            return ()
+    return tuple(parts)
+
+
+def _bundled_version() -> str:
+    """Version of the binaries bundled in this wheel."""
+    f = _pkg_bin_dir() / ".pilot-version"
+    if f.is_file():
+        try:
+            return f.read_text().strip()
+        except OSError:
+            pass
+    # Fall back to the package metadata if the marker file is missing.
+    try:
+        from importlib.metadata import version as _pkg_version
+        return _pkg_version("pilotprotocol")
+    except Exception:
+        return ""
+
+
+def _runtime_version(rt: Path) -> str:
+    f = rt / ".pilot-version"
+    if f.is_file():
+        try:
+            return f.read_text().strip()
+        except OSError:
+            return ""
+    return ""
+
+
+# ---------------------------------------------------------------------------
+# Daemon liveness probe
+# ---------------------------------------------------------------------------
+
+def _daemon_running() -> bool:
+    """True if a pilot daemon is reachable on its IPC socket."""
+    sock_path = DEFAULT_SOCKET
+    try:
+        with open(_runtime_root() / "config.json") as f:
+            cfg = json.load(f)
+        sock_path = cfg.get("socket", sock_path) or sock_path
+    except (OSError, ValueError):
+        pass
+
+    if not Path(sock_path).exists():
+        return False
+    s = socket.socket(socket.AF_UNIX)
+    s.settimeout(0.2)
+    try:
+        s.connect(sock_path)
+        return True
+    except OSError:
+        return False
+    finally:
+        try:
+            s.close()
+        except OSError:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Atomic file ops
+# ---------------------------------------------------------------------------
+
+def _atomic_install(src: Path, dst: Path) -> None:
+    """Copy *src* → *dst* atomically, surviving in-flight execs.
+
+    Writes to ``<dst>.tmp.<pid>`` then ``os.replace()`` over the target.
+    On POSIX this unlinks the old inode while leaving any running process
+    that mapped it untouched.
+    """
+    tmp = dst.with_name(f"{dst.name}.tmp.{os.getpid()}.{threading.get_ident()}")
+    if tmp.exists():
+        tmp.unlink()
+    shutil.copy2(src, tmp)
+    try:
+        tmp.chmod(0o755)
+        os.replace(tmp, dst)
+    except OSError:
+        try:
+            tmp.unlink()
+        except OSError:
+            pass
+        raise
+
+
+def _ensure_dir_writable(p: Path) -> None:
+    """Create *p* if it does not exist; raise a clear error if we cannot
+    write to it (e.g. owned by root after a botched install)."""
+    p.mkdir(parents=True, exist_ok=True)
+    if not os.access(p, os.W_OK):
+        raise PermissionError(
+            f"{p} is not writable by user {os.getuid()}. "
+            f"Repair with: chown -R $USER {p}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Config seeding
+# ---------------------------------------------------------------------------
+
+def _ensure_default_config() -> Path:
+    """Make sure ``~/.pilot/config.json`` exists. Never overwrites an
+    existing one — install.sh or the user may have set an email.
+    """
+    root = _runtime_root()
+    _ensure_dir_writable(root)
+    cfg_path = root / "config.json"
+    if cfg_path.is_file():
+        return cfg_path
+    cfg = {
+        "registry": DEFAULT_REGISTRY,
+        "beacon": DEFAULT_BEACON,
+        "socket": DEFAULT_SOCKET,
+        "encrypt": True,
+        "identity": str(root / "identity.json"),
+    }
+    tmp = cfg_path.with_name(
+        f"config.json.tmp.{os.getpid()}.{threading.get_ident()}"
+    )
+    tmp.write_text(json.dumps(cfg, indent=2) + "\n")
+    try:
+        os.replace(tmp, cfg_path)
+    except FileNotFoundError:
+        # Another thread won the race; that's fine.
+        if tmp.exists():
+            try:
+                tmp.unlink()
+            except OSError:
+                pass
+    return cfg_path
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+class SeedReport:
+    """Summary of what a seeder pass did. Useful for tests + diagnostics."""
+
+    def __init__(self) -> None:
+        self.copied: list[str] = []
+        self.skipped: list[str] = []
+        self.action: str = "noop"   # one of: noop, seed, upgrade, daemon-skip
+        self.bundled_version: str = ""
+        self.installed_version: str = ""
+        self.runtime_dir: Path = _runtime_bin()
+
+
+_SEEDED_ONCE = False
+
+
+def ensure_runtime_seeded(force: bool = False) -> Path:
+    """Idempotently mirror bundled binaries into ``~/.pilot/bin/``.
+
+    Returns the runtime bin dir. Safe to call on every CLI invocation and
+    every Driver() construction; the steady state is a single stat() +
+    string compare.
+
+    Set ``force=True`` to re-run even if this process has already seeded.
+    """
+    global _SEEDED_ONCE
+    if _SEEDED_ONCE and not force:
+        return _runtime_bin()
+
+    report = run_seeder()
+    _SEEDED_ONCE = True
+    return report.runtime_dir
+
+
+def run_seeder() -> SeedReport:
+    """Run one seeder pass and return a structured report."""
+    report = SeedReport()
+    rt_root = _runtime_root()
+    rt = _runtime_bin()
+    pkg = _pkg_bin_dir()
+
+    # Make sure ~/.pilot/ exists and is writable.
+    _ensure_dir_writable(rt_root)
+    _ensure_dir_writable(rt)
+    _ensure_default_config()
+
+    # Cross-platform fcntl shim. flock is POSIX-only; on Windows we use
+    # msvcrt.locking. Tests run on POSIX so the Windows path is best-effort.
+    lock_path = rt / ".seed.lock"
+    lock_path.touch(exist_ok=True)
+    lock_fd = os.open(lock_path, os.O_RDWR)
+    try:
+        if os.name == "posix":
+            import fcntl
+            fcntl.flock(lock_fd, fcntl.LOCK_EX)
+        else:  # pragma: no cover - Windows
+            import msvcrt
+            msvcrt.locking(lock_fd, msvcrt.LK_LOCK, 1)
+
+        bundled_str = _bundled_version()
+        installed_str = _runtime_version(rt)
+        report.bundled_version = bundled_str
+        report.installed_version = installed_str
+
+        bundled = _semver_tuple(bundled_str)
+        installed = _semver_tuple(installed_str)
+
+        # Decide overall action.
+        force = os.environ.get("PILOT_FORCE_SEED") == "1"
+        if not force and installed and bundled and bundled <= installed:
+            # Same or newer already installed. Still verify each file exists.
+            need_seed = False
+            for name in _BIN_NAMES + (_platform_lib_name(),):
+                if not (rt / name).is_file():
+                    need_seed = True
+                    break
+            if not need_seed:
+                report.action = "noop"
+                return report
+
+        report.action = "upgrade" if installed else "seed"
+        daemon_busy = _daemon_running()
+
+        for name in _BIN_NAMES + (_platform_lib_name(),):
+            src = pkg / name
+            if not src.is_file():
+                # Wrong-platform wheel or partial bundle. Skip — caller will
+                # surface a clear error when the missing binary is needed.
+                continue
+            dst = rt / name
+            if name == "pilot-daemon" and daemon_busy and dst.is_file():
+                report.skipped.append(name)
+                report.action = "daemon-skip"
+                continue
+            try:
+                _atomic_install(src, dst)
+                report.copied.append(name)
+            except OSError as e:
+                # ETXTBSY can hit Linux despite atomic rename if a tool has
+                # the file mmap'd. Skip with a notice; caller can retry.
+                if e.errno in (errno.ETXTBSY, errno.EBUSY):
+                    report.skipped.append(name)
+                    continue
+                raise
+
+        # Update the marker last; a partial seed leaves the old marker.
+        if bundled_str:
+            ver_path = rt / ".pilot-version"
+            tmp = ver_path.with_name(f".pilot-version.tmp.{os.getpid()}")
+            tmp.write_text(bundled_str + "\n")
+            os.replace(tmp, ver_path)
+
+        return report
+    finally:
+        try:
+            if os.name == "posix":
+                import fcntl
+                fcntl.flock(lock_fd, fcntl.LOCK_UN)
+        finally:
+            os.close(lock_fd)
+
+
+def runtime_binary(name: str) -> Path:
+    """Resolve a binary by name, seeding if needed.
+
+    Use this from CLI shims; it returns the path to exec.
+    """
+    rt = ensure_runtime_seeded()
+    p = rt / name
+    if not p.is_file():
+        # Last-ditch fallback: run from the wheel itself.
+        fallback = _pkg_bin_dir() / name
+        if fallback.is_file():
+            return fallback
+        raise FileNotFoundError(
+            f"Binary {name!r} not found in {rt} or {_pkg_bin_dir()}. "
+            f"This wheel may be for a different platform."
+        )
+    return p
+
+
+def runtime_library() -> Path:
+    """Resolve libpilot.{so,dylib,dll}, seeding if needed."""
+    rt = ensure_runtime_seeded()
+    name = _platform_lib_name()
+    p = rt / name
+    if p.is_file():
+        return p
+    fallback = _pkg_bin_dir() / name
+    if fallback.is_file():
+        return fallback
+    raise FileNotFoundError(
+        f"libpilot ({name}) not found in {rt} or {_pkg_bin_dir()}."
+    )
+
+
+def reset_seeded_marker() -> None:
+    """Test helper: forget that this process has already seeded."""
+    global _SEEDED_ONCE
+    _SEEDED_ONCE = False

pilotprotocol-1.9.1/pilotprotocol/bin/.pilot-version

@@ -0,0 +1 @@
+1.9.1

{pilotprotocol-1.7.2 → pilotprotocol-1.9.1}/pilotprotocol/bin/libpilot.h

@@ -21,7 +21,7 @@ extern const char *_GoStringPtr(_GoString_ s);
 /* Start of preamble from import "C" comments.  */
 
 
-#line 3 "bindings.go"
+#line 5 "bindings.go"
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -152,6 +152,37 @@ extern struct PilotConnWrite_return PilotConnWrite(uint64_t ch, void* data, int
 extern char* PilotConnClose(uint64_t ch);
 extern char* PilotSendTo(uint64_t h, char* fullAddr, void* data, int dataLen);
 extern char* PilotRecvFrom(uint64_t h);
+extern char* PilotHealth(uint64_t h);
+extern char* PilotRotateKey(uint64_t h);
+extern char* PilotBroadcast(uint64_t h, uint16_t netID, uint16_t port, void* data, int dataLen, char* adminToken);
+
+/* Return type for PilotDialTimeout */
+struct PilotDialTimeout_return {
+	uint64_t r0;
+	char* r1;
+};
+extern struct PilotDialTimeout_return PilotDialTimeout(uint64_t h, char* addr, uint64_t timeoutMs);
+
+// PilotConnSetReadDeadline sets the read deadline as Unix nanoseconds.
+// Pass 0 to clear the deadline.
+//
+extern char* PilotConnSetReadDeadline(uint64_t ch, int64_t deadlineUnixNanos);
+extern char* PilotNetworkList(uint64_t h);
+extern char* PilotNetworkJoin(uint64_t h, uint16_t networkID, char* token);
+extern char* PilotNetworkLeave(uint64_t h, uint16_t networkID);
+extern char* PilotNetworkMembers(uint64_t h, uint16_t networkID);
+extern char* PilotNetworkInvite(uint64_t h, uint16_t networkID, uint32_t targetNodeID);
+extern char* PilotNetworkPollInvites(uint64_t h);
+extern char* PilotNetworkRespondInvite(uint64_t h, uint16_t networkID, int accept);
+extern char* PilotManagedScore(uint64_t h, uint16_t networkID, uint32_t nodeID, int32_t delta, char* topic);
+extern char* PilotManagedStatus(uint64_t h, uint16_t networkID);
+extern char* PilotManagedRankings(uint64_t h, uint16_t networkID);
+extern char* PilotManagedForceCycle(uint64_t h, uint16_t networkID);
+extern char* PilotManagedReconcile(uint64_t h, uint16_t networkID);
+extern char* PilotPolicyGet(uint64_t h, uint16_t networkID);
+extern char* PilotPolicySet(uint64_t h, uint16_t networkID, char* policyJSON);
+extern char* PilotMemberTagsGet(uint64_t h, uint16_t networkID, uint32_t nodeID);
+extern char* PilotMemberTagsSet(uint64_t h, uint16_t networkID, uint32_t nodeID, char* tagsJSON);
 
 #ifdef __cplusplus
 }

pilotprotocol-1.9.1/pilotprotocol/cli.py

@@ -0,0 +1,55 @@
+"""Command-line entry points for the Pilot Protocol CLI binaries.
+
+The wheel ships pre-built Go binaries inside ``pilotprotocol/bin/``. On
+first call, :mod:`pilotprotocol._runtime` mirrors those into
+``~/.pilot/bin/`` (the canonical runtime directory shared with
+``install.sh``) and these wrappers exec the seeded copy.
+
+This means:
+- pip-installed and curl-installed users converge on the same daemon.
+- Multiple venvs, multiple SDK versions: highest version wins, no
+  parallel binary trees.
+- Uninstalling the wheel never deletes ``~/.pilot/`` (identity, config,
+  daemon state are preserved).
+"""
+
+import subprocess
+import sys
+
+from ._runtime import ensure_runtime_seeded, runtime_binary
+
+
+def _exec_runtime_binary(name: str) -> None:
+    """Seed ``~/.pilot/bin/`` if needed, then exec the named binary."""
+    ensure_runtime_seeded()
+    binary = runtime_binary(name)
+    sys.exit(subprocess.call([str(binary)] + sys.argv[1:]))
+
+
+def run_pilotctl() -> None:
+    """Entry point for the ``pilotctl`` console script."""
+    _exec_runtime_binary("pilotctl")
+
+
+def run_daemon() -> None:
+    """Entry point for the ``pilot-daemon`` console script.
+
+    Note: the daemon needs an email address (passed via ``--email`` or
+    set in ``~/.pilot/config.json``) to register at the registry. The
+    SDK does not auto-prompt for one — call::
+
+        pilotctl daemon start --email you@example.com
+
+    on first launch, after which the email is cached in ``config.json``.
+    """
+    _exec_runtime_binary("pilot-daemon")
+
+
+def run_gateway() -> None:
+    """Entry point for the ``pilot-gateway`` console script."""
+    _exec_runtime_binary("pilot-gateway")
+
+
+def run_updater() -> None:
+    """Entry point for the ``pilot-updater`` console script."""
+    _exec_runtime_binary("pilot-updater")

{pilotprotocol-1.7.2 → pilotprotocol-1.9.1}/pilotprotocol/client.py

@@ -101,8 +101,24 @@ def _find_library() -> str:
 
 
 def _load_lib() -> ctypes.CDLL:  # pragma: no cover
-    path = _find_library()
-    return ctypes.CDLL(path)
+    """Load libpilot.
+
+    Order:
+    1. ``PILOT_LIB_PATH`` (explicit override) — bypasses the seeder.
+    2. The seeded library at ``~/.pilot/bin/`` (canonical runtime).
+    3. Legacy fallback via :func:`_find_library` (system search etc.).
+    """
+    env = os.environ.get("PILOT_LIB_PATH")
+    if env:
+        return ctypes.CDLL(_find_library())
+
+    try:
+        from ._runtime import runtime_library
+        return ctypes.CDLL(str(runtime_library()))
+    except Exception:
+        # Seeder failed (read-only home, etc.) — fall back to legacy lookup
+        # so the SDK still loads from the wheel-bundled location.
+        return ctypes.CDLL(_find_library())
 
 
 _lib: Optional[ctypes.CDLL] = None
@@ -168,8 +184,10 @@ def _setup_signatures(lib: ctypes.CDLL) -> None:  # pragma: no cover
 
     # JSON-RPC (single *C.char return → c_void_p)
     for name in (
-        "PilotInfo", "PilotPendingHandshakes", "PilotTrustedPeers",
+        "PilotInfo", "PilotHealth", "PilotRotateKey",
+        "PilotPendingHandshakes", "PilotTrustedPeers",
         "PilotDeregister", "PilotRecvFrom",
+        "PilotNetworkList", "PilotNetworkPollInvites",
     ):
         fn = getattr(lib, name)
         fn.argtypes = [ctypes.c_uint64]
@@ -209,6 +227,9 @@ def _setup_signatures(lib: ctypes.CDLL) -> None:  # pragma: no cover
     lib.PilotDial.argtypes = [ctypes.c_uint64, ctypes.c_char_p]
     lib.PilotDial.restype = _HandleErr
 
+    lib.PilotDialTimeout.argtypes = [ctypes.c_uint64, ctypes.c_char_p, ctypes.c_uint64]
+    lib.PilotDialTimeout.restype = _HandleErr
+
     # Listen: (handle, uint16) -> struct{handle, err}
     lib.PilotListen.argtypes = [ctypes.c_uint64, ctypes.c_uint16]
     lib.PilotListen.restype = _HandleErr
@@ -220,7 +241,7 @@ def _setup_signatures(lib: ctypes.CDLL) -> None:  # pragma: no cover
     lib.PilotListenerClose.argtypes = [ctypes.c_uint64]
     lib.PilotListenerClose.restype = ctypes.c_void_p
 
-    # Conn Read / Write / Close
+    # Conn Read / Write / Close / SetReadDeadline
     lib.PilotConnRead.argtypes = [ctypes.c_uint64, ctypes.c_int]
     lib.PilotConnRead.restype = _ReadResult
 
@@ -230,10 +251,69 @@ def _setup_signatures(lib: ctypes.CDLL) -> None:  # pragma: no cover
     lib.PilotConnClose.argtypes = [ctypes.c_uint64]
     lib.PilotConnClose.restype = ctypes.c_void_p
 
+    lib.PilotConnSetReadDeadline.argtypes = [ctypes.c_uint64, ctypes.c_int64]
+    lib.PilotConnSetReadDeadline.restype = ctypes.c_void_p
+
     # SendTo: (handle, string, void*, int) -> *char
     lib.PilotSendTo.argtypes = [ctypes.c_uint64, ctypes.c_char_p, ctypes.c_void_p, ctypes.c_int]
     lib.PilotSendTo.restype = ctypes.c_void_p
 
+    # Broadcast: (handle, uint16 net, uint16 port, void* data, int len, *char token) -> *char
+    lib.PilotBroadcast.argtypes = [
+        ctypes.c_uint64, ctypes.c_uint16, ctypes.c_uint16,
+        ctypes.c_void_p, ctypes.c_int, ctypes.c_char_p,
+    ]
+    lib.PilotBroadcast.restype = ctypes.c_void_p
+
+    # Networks (handle, uint16) -> *char
+    for name in ("PilotNetworkLeave", "PilotNetworkMembers"):
+        fn = getattr(lib, name)
+        fn.argtypes = [ctypes.c_uint64, ctypes.c_uint16]
+        fn.restype = ctypes.c_void_p
+
+    # PilotNetworkJoin: (handle, uint16, *char token) -> *char
+    lib.PilotNetworkJoin.argtypes = [ctypes.c_uint64, ctypes.c_uint16, ctypes.c_char_p]
+    lib.PilotNetworkJoin.restype = ctypes.c_void_p
+
+    # PilotNetworkInvite: (handle, uint16, uint32) -> *char
+    lib.PilotNetworkInvite.argtypes = [ctypes.c_uint64, ctypes.c_uint16, ctypes.c_uint32]
+    lib.PilotNetworkInvite.restype = ctypes.c_void_p
+
+    # PilotNetworkRespondInvite: (handle, uint16, int) -> *char
+    lib.PilotNetworkRespondInvite.argtypes = [ctypes.c_uint64, ctypes.c_uint16, ctypes.c_int]
+    lib.PilotNetworkRespondInvite.restype = ctypes.c_void_p
+
+    # Managed (handle, uint16) -> *char
+    for name in (
+        "PilotManagedStatus", "PilotManagedRankings",
+        "PilotManagedForceCycle", "PilotManagedReconcile",
+        "PilotPolicyGet",
+    ):
+        fn = getattr(lib, name)
+        fn.argtypes = [ctypes.c_uint64, ctypes.c_uint16]
+        fn.restype = ctypes.c_void_p
+
+    # PilotManagedScore: (handle, uint16 net, uint32 node, int32 delta, *char topic)
+    lib.PilotManagedScore.argtypes = [
+        ctypes.c_uint64, ctypes.c_uint16, ctypes.c_uint32,
+        ctypes.c_int32, ctypes.c_char_p,
+    ]
+    lib.PilotManagedScore.restype = ctypes.c_void_p
+
+    # PilotPolicySet: (handle, uint16, *char json)
+    lib.PilotPolicySet.argtypes = [ctypes.c_uint64, ctypes.c_uint16, ctypes.c_char_p]
+    lib.PilotPolicySet.restype = ctypes.c_void_p
+
+    # PilotMemberTagsGet: (handle, uint16 net, uint32 node) -> *char
+    lib.PilotMemberTagsGet.argtypes = [ctypes.c_uint64, ctypes.c_uint16, ctypes.c_uint32]
+    lib.PilotMemberTagsGet.restype = ctypes.c_void_p
+
+    # PilotMemberTagsSet: (handle, uint16 net, uint32 node, *char tagsJson) -> *char
+    lib.PilotMemberTagsSet.argtypes = [
+        ctypes.c_uint64, ctypes.c_uint16, ctypes.c_uint32, ctypes.c_char_p,
+    ]
+    lib.PilotMemberTagsSet.restype = ctypes.c_void_p
+
 
 # ---------------------------------------------------------------------------
 # Error helpers
@@ -351,6 +431,23 @@ class Conn:
             if "error" in obj:
                 raise PilotError(obj["error"])
 
+    def set_read_deadline(self, deadline: Optional[float]) -> None:
+        """Set the read deadline.
+
+        ``deadline`` is a Unix timestamp in seconds (e.g. ``time.time() + 5``)
+        or ``None`` to clear. After the deadline passes, ``read()`` returns
+        a ``PilotError`` with a "deadline exceeded" message.
+        """
+        if self._closed:
+            raise PilotError("connection closed")
+        if deadline is None:
+            nanos = 0
+        else:
+            nanos = int(deadline * 1_000_000_000)
+        lib = _get_lib()
+        ptr = lib.PilotConnSetReadDeadline(self._h, ctypes.c_int64(nanos))
+        _check_err(ptr)
+
     def __enter__(self) -> "Conn":
         return self
 
@@ -472,6 +569,14 @@ class Driver:
         """Return the daemon's status information."""
         return self._call_json("PilotInfo")
 
+    def health(self) -> dict[str, Any]:
+        """Lightweight health check from the daemon."""
+        return self._call_json("PilotHealth")
+
+    def rotate_key(self) -> dict[str, Any]:
+        """Rotate the daemon's Ed25519 identity at the registry."""
+        return self._call_json("PilotRotateKey")
+
     # -- Handshake / Trust --
 
     def handshake(self, node_id: int, justification: str = "") -> dict[str, Any]:
@@ -540,10 +645,18 @@ class Driver:
 
     # -- Streams --
 
-    def dial(self, addr: str) -> Conn:
-        """Open a stream connection to addr (format: "N:XXXX.YYYY.YYYY:PORT")."""
+    def dial(self, addr: str, timeout: Optional[float] = None) -> Conn:
+        """Open a stream connection to addr (format: "N:XXXX.YYYY.YYYY:PORT").
+
+        If ``timeout`` is given (seconds), the dial is cancelled if the daemon
+        does not respond within that window.
+        """
         lib = _get_lib()
-        res = lib.PilotDial(self._h, addr.encode())
+        if timeout is None:
+            res = lib.PilotDial(self._h, addr.encode())
+        else:
+            ms = max(0, int(timeout * 1000))
+            res = lib.PilotDialTimeout(self._h, addr.encode(), ctypes.c_uint64(ms))
         if res.err:
             raw = ctypes.string_at(res.err)
             lib.FreeString(res.err)
@@ -576,6 +689,152 @@ class Driver:
         """
         return self._call_json("PilotRecvFrom")
 
+    def broadcast(
+        self,
+        network_id: int,
+        port: int,
+        data: bytes,
+        admin_token: str,
+    ) -> None:
+        """Broadcast an unreliable datagram to every member of a network.
+
+        Requires the daemon's admin token; an empty or mismatched token is
+        rejected. Permitted on every network including network 0 (backbone).
+        """
+        lib = _get_lib()
+        buf = ctypes.create_string_buffer(data)
+        ptr = lib.PilotBroadcast(
+            self._h,
+            ctypes.c_uint16(network_id),
+            ctypes.c_uint16(port),
+            buf,
+            ctypes.c_int(len(data)),
+            admin_token.encode(),
+        )
+        _check_err(ptr)
+
+    # -- Networks --
+
+    def network_list(self) -> dict[str, Any]:
+        """List all networks known to the registry."""
+        return self._call_json("PilotNetworkList")
+
+    def network_join(self, network_id: int, token: str = "") -> dict[str, Any]:
+        """Join a network by ID, optionally with a token for token-gated networks."""
+        return self._call_json(
+            "PilotNetworkJoin", ctypes.c_uint16(network_id), token.encode()
+        )
+
+    def network_leave(self, network_id: int) -> dict[str, Any]:
+        """Leave a network by ID."""
+        return self._call_json("PilotNetworkLeave", ctypes.c_uint16(network_id))
+
+    def network_members(self, network_id: int) -> dict[str, Any]:
+        """List all members of a network."""
+        return self._call_json("PilotNetworkMembers", ctypes.c_uint16(network_id))
+
+    def network_invite(self, network_id: int, target_node_id: int) -> dict[str, Any]:
+        """Invite a target node to a network (requires admin token on daemon)."""
+        return self._call_json(
+            "PilotNetworkInvite",
+            ctypes.c_uint16(network_id),
+            ctypes.c_uint32(target_node_id),
+        )
+
+    def network_poll_invites(self) -> dict[str, Any]:
+        """Return pending network invites for this node."""
+        return self._call_json("PilotNetworkPollInvites")
+
+    def network_respond_invite(self, network_id: int, accept: bool) -> dict[str, Any]:
+        """Accept or reject a pending network invite."""
+        return self._call_json(
+            "PilotNetworkRespondInvite",
+            ctypes.c_uint16(network_id),
+            ctypes.c_int(1 if accept else 0),
+        )
+
+    # -- Managed networks --
+
+    def managed_score(
+        self,
+        network_id: int,
+        node_id: int,
+        delta: int,
+        topic: str = "",
+    ) -> dict[str, Any]:
+        """Adjust a peer's score in a managed network."""
+        return self._call_json(
+            "PilotManagedScore",
+            ctypes.c_uint16(network_id),
+            ctypes.c_uint32(node_id),
+            ctypes.c_int32(delta),
+            topic.encode(),
+        )
+
+    def managed_status(self, network_id: int) -> dict[str, Any]:
+        """Return the status of a managed network engine."""
+        return self._call_json("PilotManagedStatus", ctypes.c_uint16(network_id))
+
+    def managed_rankings(self, network_id: int) -> dict[str, Any]:
+        """Return ranked peers in a managed network."""
+        return self._call_json("PilotManagedRankings", ctypes.c_uint16(network_id))
+
+    def managed_force_cycle(self, network_id: int) -> dict[str, Any]:
+        """Force a prune/fill cycle in a managed network."""
+        return self._call_json("PilotManagedForceCycle", ctypes.c_uint16(network_id))
+
+    def managed_reconcile(self, network_id: int) -> dict[str, Any]:
+        """Refresh the managed network's peer set without running a policy cycle."""
+        return self._call_json("PilotManagedReconcile", ctypes.c_uint16(network_id))
+
+    # -- Policy --
+
+    def policy_get(self, network_id: int) -> dict[str, Any]:
+        """Retrieve the active policy for a network."""
+        return self._call_json("PilotPolicyGet", ctypes.c_uint16(network_id))
+
+    def policy_set(self, network_id: int, policy: Any) -> dict[str, Any]:
+        """Apply a policy document to a network.
+
+        ``policy`` may be a dict, a JSON string, or pre-encoded bytes.
+        """
+        if isinstance(policy, (bytes, bytearray)):
+            payload = bytes(policy)
+        elif isinstance(policy, str):
+            payload = policy.encode()
+        else:
+            payload = json.dumps(policy).encode()
+        return self._call_json(
+            "PilotPolicySet", ctypes.c_uint16(network_id), payload
+        )
+
+    # -- Member tags --
+
+    def member_tags_get(self, network_id: int, node_id: int) -> dict[str, Any]:
+        """Retrieve admin-assigned member tags for a node in a network."""
+        return self._call_json(
+            "PilotMemberTagsGet",
+            ctypes.c_uint16(network_id),
+            ctypes.c_uint32(node_id),
+        )
+
+    def member_tags_set(
+        self, network_id: int, node_id: int, tags: list[str]
+    ) -> dict[str, Any]:
+        """Set admin-assigned member tags for a node in a network."""
+        return self._call_json(
+            "PilotMemberTagsSet",
+            ctypes.c_uint16(network_id),
+            ctypes.c_uint32(node_id),
+            json.dumps(tags).encode(),
+        )
+
+    # -- Identity --
+
+    def rotate_identity(self) -> dict[str, Any]:
+        """Alias for :meth:`rotate_key`."""
+        return self.rotate_key()
+
     # -- High-level service methods --
 
     def send_message(self, target: str, data: bytes, msg_type: str = "text") -> dict[str, Any]:

{pilotprotocol-1.7.2 → pilotprotocol-1.9.1/pilotprotocol.egg-info}/PKG-INFO

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: pilotprotocol
-Version: 1.7.2
+Version: 1.9.1
 Summary: Python SDK for Pilot Protocol - the network stack for AI agents
-Author-email: Alexandru Godoroja <alex@vulturelabs.com>
-Maintainer-email: Alexandru Godoroja <alex@vulturelabs.com>, Teodor Calin <teodor@vulturelabs.com>
+Author-email: Alexandru Godoroja <alex@pilotprotocol.network>
+Maintainer-email: Alexandru Godoroja <alex@pilotprotocol.network>, Teodor Calin <teodor@pilotprotocol.network>
 License: AGPL-3.0-or-later
 Project-URL: Homepage, https://pilotprotocol.network
 Project-URL: Documentation, https://pilotprotocol.network/docs/
 Project-URL: Repository, https://github.com/TeoSlayer/pilotprotocol
 Project-URL: Bug Tracker, https://github.com/TeoSlayer/pilotprotocol/issues
 Project-URL: Changelog, https://github.com/TeoSlayer/pilotprotocol/blob/main/sdk/python/CHANGELOG.md
-Project-URL: Live Dashboard, https://polo.pilotprotocol.network
 Keywords: pilot-protocol,networking,p2p,agent,ai,protocol,ctypes,udp,encryption
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
@@ -312,7 +311,7 @@ See `examples/python_sdk/` for comprehensive examples:
 - **`basic_usage.py`** — Connection, identity, trust management
 - **`data_exchange_demo.py`** — Send messages, files, JSON
 - **`event_stream_demo.py`** — Pub/sub patterns
-- **`task_submit_demo.py`** — Task delegation and polo score
+- **`task_submit_demo.py`** — Task delegation
 - **`pydantic_ai_agent.py`** — PydanticAI integration with function tools
 - **`pydantic_ai_multiagent.py`** — Multi-agent collaboration system
 
@@ -349,7 +348,7 @@ make publish-test     # Publish to TestPyPI
 - **Examples:** `examples/python_sdk/README.md`
 - **CLI Reference:** `examples/cli/BASIC_USAGE.md`
 - **Protocol Spec:** `docs/SPEC.md`
-- **Agent Skills:** `docs/SKILLS.md`
+- **Agent Skills:** https://github.com/TeoSlayer/pilot-skills
 
 ## License
 

{pilotprotocol-1.7.2 → pilotprotocol-1.9.1}/pilotprotocol.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ README.md
 pyproject.toml
 setup.py
 pilotprotocol/__init__.py
+pilotprotocol/_runtime.py
 pilotprotocol/cli.py
 pilotprotocol/client.py
 pilotprotocol/py.typed
@@ -14,6 +15,7 @@ pilotprotocol.egg-info/dependency_links.txt
 pilotprotocol.egg-info/entry_points.txt
 pilotprotocol.egg-info/requires.txt
 pilotprotocol.egg-info/top_level.txt
+pilotprotocol/bin/.pilot-version
 pilotprotocol/bin/libpilot.h
 pilotprotocol/bin/libpilot.so
 pilotprotocol/bin/pilot-daemon

{pilotprotocol-1.7.2 → pilotprotocol-1.9.1}/pyproject.toml

@@ -9,22 +9,23 @@ include-package-data = true
 [tool.setuptools.package-data]
 pilotprotocol = [
     "bin/*",
+    "bin/.pilot-version",
     "py.typed"
 ]
 
 [project]
 name = "pilotprotocol"
-version = "1.7.2"
+version = "1.9.1"
 description = "Python SDK for Pilot Protocol - the network stack for AI agents"
 readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "AGPL-3.0-or-later"}
 authors = [
-    {name = "Alexandru Godoroja", email = "alex@vulturelabs.com"}
+    {name = "Alexandru Godoroja", email = "alex@pilotprotocol.network"}
 ]
 maintainers = [
-    {name = "Alexandru Godoroja", email = "alex@vulturelabs.com"},
-    {name = "Teodor Calin", email = "teodor@vulturelabs.com"}
+    {name = "Alexandru Godoroja", email = "alex@pilotprotocol.network"},
+    {name = "Teodor Calin", email = "teodor@pilotprotocol.network"}
 ]
 keywords = [
     "pilot-protocol",
@@ -68,7 +69,6 @@ Documentation = "https://pilotprotocol.network/docs/"
 Repository = "https://github.com/TeoSlayer/pilotprotocol"
 "Bug Tracker" = "https://github.com/TeoSlayer/pilotprotocol/issues"
 Changelog = "https://github.com/TeoSlayer/pilotprotocol/blob/main/sdk/python/CHANGELOG.md"
-"Live Dashboard" = "https://polo.pilotprotocol.network"
 
 [project.optional-dependencies]
 dev = [

pilotprotocol-1.7.2/pilotprotocol/cli.py

@@ -1,169 +0,0 @@
-"""Command-line interface wrappers for Pilot Protocol binaries.
-
-This module provides entry points for the bundled Go binaries:
-- pilotctl: CLI tool for managing the daemon
-- pilot-daemon: Background service
-- pilot-gateway: IP traffic bridge
-
-Each wrapper:
-1. Ensures ~/.pilot/ directory exists
-2. Creates default config.json if missing
-3. Executes the bundled binary with all arguments passed through
-"""
-
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-
-def _ensure_pilot_env():
-    """Ensure ~/.pilot/ directory and config.json exist.
-    
-    Creates:
-    - ~/.pilot/ directory
-    - ~/.pilot/config.json with default settings (if not present)
-    
-    This function is called before every binary execution to ensure
-    the runtime environment is properly initialized.
-    """
-    # Get user's home directory
-    home = Path.home()
-    pilot_dir = home / ".pilot"
-    config_file = pilot_dir / "config.json"
-    
-    # Create ~/.pilot/ if it doesn't exist
-    pilot_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Create default config.json if it doesn't exist
-    if not config_file.exists():
-        default_config = {
-            "registry": "34.71.57.205:9000",
-            "beacon": "34.71.57.205:9001",
-            "socket": "/tmp/pilot.sock",
-            "encrypt": True,
-            "identity": str(pilot_dir / "identity.json")
-        }
-        
-        with open(config_file, 'w') as f:
-            json.dump(default_config, f, indent=2)
-
-
-def _get_binary_path(binary_name: str) -> Path:
-    """Get absolute path to a bundled binary.
-    
-    Args:
-        binary_name: Name of the binary (e.g., 'pilotctl', 'pilot-daemon')
-        
-    Returns:
-        Absolute path to the binary
-        
-    Raises:
-        FileNotFoundError: If binary not found in package
-    """
-    # Find the bin/ directory relative to this file
-    package_dir = Path(__file__).resolve().parent
-    bin_dir = package_dir / "bin"
-    binary_path = bin_dir / binary_name
-    
-    if not binary_path.exists():
-        raise FileNotFoundError(
-            f"Binary '{binary_name}' not found at {binary_path}\n"
-            f"Expected location: {bin_dir}\n"
-            "The wheel may not have been built correctly."
-        )
-    
-    return binary_path
-
-
-def run_pilotctl():
-    """Entry point for pilotctl CLI tool.
-    
-    This is called when the user runs 'pilotctl' from the command line.
-    All arguments are passed through to the Go binary.
-    
-    Example:
-        $ pilotctl daemon start --hostname my-agent
-        $ pilotctl info
-        $ pilotctl ping other-agent
-    """
-    # Ensure environment is set up
-    _ensure_pilot_env()
-    
-    # Get path to bundled binary
-    binary = _get_binary_path("pilotctl")
-    
-    # Execute the binary with all arguments
-    # subprocess.call() returns the exit code directly
-    exit_code = subprocess.call([str(binary)] + sys.argv[1:])
-    
-    # Exit with the same code as the binary
-    sys.exit(exit_code)
-
-
-def run_daemon():
-    """Entry point for pilot-daemon background service.
-    
-    This is called when the user runs 'pilot-daemon' from the command line.
-    All arguments are passed through to the Go binary.
-    
-    Example:
-        $ pilot-daemon -registry 34.71.57.205:9000 -beacon 34.71.57.205:9001
-        $ pilot-daemon -hostname my-agent -public
-    """
-    # Ensure environment is set up
-    _ensure_pilot_env()
-    
-    # Get path to bundled binary
-    binary = _get_binary_path("pilot-daemon")
-    
-    # Execute the binary with all arguments
-    exit_code = subprocess.call([str(binary)] + sys.argv[1:])
-    
-    # Exit with the same code as the binary
-    sys.exit(exit_code)
-
-
-def run_gateway():
-    """Entry point for pilot-gateway IP traffic bridge.
-
-    This is called when the user runs 'pilot-gateway' from the command line.
-    All arguments are passed through to the Go binary.
-
-    Example:
-        $ pilot-gateway --ports 80,3000 <pilot-addr>
-    """
-    # Ensure environment is set up
-    _ensure_pilot_env()
-
-    # Get path to bundled binary
-    binary = _get_binary_path("pilot-gateway")
-
-    # Execute the binary with all arguments
-    exit_code = subprocess.call([str(binary)] + sys.argv[1:])
-
-    # Exit with the same code as the binary
-    sys.exit(exit_code)
-
-
-def run_updater():
-    """Entry point for pilot-updater auto-update sidecar.
-
-    This is called when the user runs 'pilot-updater' from the command line.
-    All arguments are passed through to the Go binary.
-
-    Example:
-        $ pilot-updater -install-dir ~/.pilot/bin
-    """
-    # Ensure environment is set up
-    _ensure_pilot_env()
-
-    # Get path to bundled binary
-    binary = _get_binary_path("pilot-updater")
-
-    # Execute the binary with all arguments
-    exit_code = subprocess.call([str(binary)] + sys.argv[1:])
-
-    # Exit with the same code as the binary
-    sys.exit(exit_code)