aaax 0.0.1a0__py3-none-any.whl

aaax/__init__.py

@@ -0,0 +1,20 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from aaax.bootstrap import bootstrap_kernel
+from aaax.config import AAAXConfig, LibOSConfig, ModuleConfig, NetworkConfig
+from aaax.kernel import AAAXKernel
+
+try:
+    __version__ = version("aaax")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "AAAXConfig",
+    "LibOSConfig",
+    "ModuleConfig",
+    "NetworkConfig",
+    "AAAXKernel",
+    "bootstrap_kernel",
+]

aaax/__main__.py

@@ -0,0 +1,5 @@
+from aaax.cli import main
+
+
+if __name__ == "__main__":
+    main()

aaax/_vendor.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def ensure_vendor_paths() -> None:
+    """Prefer vendored local framework repos when they exist in the workspace."""
+    root = Path(__file__).resolve().parents[1]
+    for name in ("sssn", "lllm"):
+        candidate = root / name
+        if not candidate.is_dir():
+            continue
+        path = str(candidate)
+        if path not in sys.path:
+            sys.path.insert(0, path)

aaax/action_gate.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any
+
+from aaax.capability import CapabilityManager
+from aaax.policy import PolicyEngine
+
+
+def _message_content_data(msg) -> dict[str, Any]:
+    content = getattr(msg, "content", None)
+    data = getattr(content, "data", None)
+    return data if isinstance(data, dict) else {}
+
+
+def _requester_id(msg, payload: dict[str, Any]) -> str:
+    return str(payload.get("from") or payload.get("system_id") or msg.sender_id)
+
+
+class ActionGate:
+    """Authorize and classify side-effecting operations."""
+
+    async def process(
+        self,
+        msg,
+        policy: PolicyEngine,
+        capabilities: CapabilityManager,
+    ) -> dict[str, Any]:
+        content = _message_content_data(msg)
+        system_id = _requester_id(msg, content)
+        action = str(content["action"])
+        executor = str(content["executor"])
+        target = str(content["target"])
+        payload = content.get("payload", {})
+        cap_token = content.get("capability")
+        risk_level = str(content.get("risk_level", "medium"))
+
+        if not cap_token:
+            return {
+                "type": "action_denied",
+                "request_id": msg.id,
+                "reason": "Missing execute capability token",
+            }
+
+        if not capabilities.validate(system_id, cap_token, executor, "execute"):
+            return {
+                "type": "action_denied",
+                "request_id": msg.id,
+                "reason": "Invalid or expired capability token",
+            }
+
+        decision = await policy.evaluate_action(
+            system_id=system_id,
+            action=action,
+            executor=executor,
+            target=target,
+            payload=payload,
+            risk_level=risk_level,
+        )
+        if decision.escalate:
+            return {
+                "type": "action_escalated",
+                "request_id": msg.id,
+                "reason": decision.reason,
+                "escalated_to": decision.escalate_to,
+            }
+        if not decision.allowed:
+            return {
+                "type": "action_denied",
+                "request_id": msg.id,
+                "reason": decision.reason,
+            }
+        return {
+            "type": "action_approved",
+            "request_id": msg.id,
+            "executor": executor,
+            "modified_payload": decision.modified_payload or payload,
+        }

aaax/bootstrap.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from aaax.config import AAAXConfig
+from aaax.kernel import AAAXKernel
+
+
+async def bootstrap_kernel(config: AAAXConfig, *, start_channels: bool = False) -> AAAXKernel:
+    kernel = AAAXKernel(config)
+    await kernel.setup()
+    kernel._setup_done = True
+    if start_channels:
+        await kernel.start_owned_channels()
+    return kernel

aaax/capability.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+from aaax.policy import PolicyEngine
+
+ACCESS_LEVELS = {"read": 0, "write": 1, "execute": 2}
+
+
+def _message_content_data(msg) -> dict[str, Any]:
+    content = getattr(msg, "content", None)
+    data = getattr(content, "data", None)
+    return data if isinstance(data, dict) else {}
+
+
+def _requester_id(msg, payload: dict[str, Any]) -> str:
+    return str(payload.get("from") or payload.get("system_id") or msg.sender_id)
+
+
+@dataclass(slots=True)
+class Capability:
+    token: str
+    system_id: str
+    resource: str
+    access: str
+    issued_at: float
+    expires_at: float
+    scope: dict[str, Any] = field(default_factory=dict)
+
+
+class CapabilityManager:
+    """AAAX-local capability tokens for mediated resources."""
+
+    def __init__(self) -> None:
+        self._capabilities: dict[str, Capability] = {}
+        self._by_system: dict[str, set[str]] = {}
+
+    async def process_request(self, msg, policy: PolicyEngine) -> dict[str, Any]:
+        content = _message_content_data(msg)
+        system_id = _requester_id(msg, content)
+        resource = str(content["resource"])
+        access = str(content["access"])
+        scope = content.get("scope", {})
+        context = content.get("context", {})
+
+        decision = await policy.evaluate_capability(
+            system_id=system_id,
+            resource=resource,
+            access=access,
+            context=context,
+        )
+        if not decision.allowed:
+            return {
+                "type": "capability_deny",
+                "resource": resource,
+                "reason": decision.reason,
+            }
+
+        return await self.issue(
+            system_id=system_id,
+            resource=resource,
+            access=access,
+            scope=scope,
+        )
+
+    async def issue(
+        self,
+        system_id: str,
+        resource: str,
+        access: str,
+        scope: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        scope = scope or {}
+        ttl = float(scope.get("ttl", 3600.0))
+        token = uuid.uuid4().hex
+        now = time.time()
+        capability = Capability(
+            token=token,
+            system_id=system_id,
+            resource=resource,
+            access=access,
+            issued_at=now,
+            expires_at=now + ttl,
+            scope=scope,
+        )
+        self._capabilities[token] = capability
+        self._by_system.setdefault(system_id, set()).add(token)
+        return {
+            "type": "capability_grant",
+            "resource": resource,
+            "token": token,
+            "expires": capability.expires_at,
+        }
+
+    def validate(self, system_id: str, token: str, resource: str, access: str) -> bool:
+        capability = self._capabilities.get(token)
+        if capability is None:
+            return False
+        if capability.expires_at < time.time():
+            self._capabilities.pop(token, None)
+            self._by_system.get(capability.system_id, set()).discard(token)
+            return False
+        if capability.system_id != system_id:
+            return False
+        if capability.resource != resource:
+            return False
+        return ACCESS_LEVELS.get(capability.access, -1) >= ACCESS_LEVELS.get(access, 0)
+
+    def revoke_all(self, system_id: str) -> None:
+        tokens = self._by_system.pop(system_id, set())
+        for token in tokens:
+            self._capabilities.pop(token, None)
+
+    def expire_stale(self) -> None:
+        now = time.time()
+        expired = [token for token, cap in self._capabilities.items() if cap.expires_at < now]
+        for token in expired:
+            cap = self._capabilities.pop(token)
+            self._by_system.get(cap.system_id, set()).discard(token)
+
+    def active_count(self) -> int:
+        return len(self._capabilities)

aaax/cli.py

@@ -0,0 +1,13 @@
+import click
+
+from aaax.cli_kernel import launch, modules
+
+
+@click.group()
+@click.version_option(package_name="aaax")
+def main() -> None:
+    """AAAX CLI."""
+
+
+main.add_command(launch)
+main.add_command(modules)

aaax/cli_kernel.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from aaax.bootstrap import bootstrap_kernel
+from aaax.config import AAAXConfig
+
+
+def _print_kernel_snapshot(kernel, *, host: str | None = None, port: int | None = None) -> None:
+    click.echo(f"kernel_id={kernel.id}")
+    click.echo(f"docked_systems={kernel._constellation.system_ids()}")
+    click.echo("channels:")
+    for channel in kernel.all_channels:
+        click.echo(f"  - {channel.id}")
+    if host is not None and port is not None:
+        click.echo(f"http_transport=http://{host}:{port} (PUBLIC channels only)")
+
+
+@click.command()
+@click.argument("config_path", type=click.Path(exists=True, dir_okay=False))
+@click.option("--publish", is_flag=True, help="Publish public channels over HTTP.")
+@click.option(
+    "--once",
+    is_flag=True,
+    help="Bootstrap the kernel, run one step, print a summary, and exit.",
+)
+def launch(config_path: str, publish: bool, once: bool) -> None:
+    """Launch an AAAX kernel from a TOML config."""
+
+    if publish and once:
+        raise click.UsageError("--once cannot be combined with --publish.")
+
+    async def _run() -> None:
+        config = AAAXConfig.from_file(config_path)
+        kernel = await bootstrap_kernel(config, start_channels=once)
+        if once:
+            await kernel.step()
+            _print_kernel_snapshot(kernel)
+            return
+
+        click.echo(f"Starting AAAX runtime for '{config.name}' ({kernel.id}).")
+        if publish:
+            _print_kernel_snapshot(
+                kernel,
+                host=config.network.host,
+                port=config.network.port,
+            )
+            click.echo("Press Ctrl+C to stop.")
+            await kernel.publish(host=config.network.host, port=config.network.port)
+        else:
+            _print_kernel_snapshot(kernel)
+            click.echo("Press Ctrl+C to stop.")
+            await kernel.launch()
+
+    try:
+        asyncio.run(_run())
+    except KeyboardInterrupt:
+        click.echo("\nStopped AAAX runtime.")
+
+
+@click.group()
+def modules() -> None:
+    """Module management commands."""
+
+
+@modules.command("list")
+def list_modules() -> None:
+    """Placeholder until persistent module registry commands are implemented."""
+    click.echo("Module registry commands require a running kernel instance.")

aaax/config.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+def _load_toml(path: str | Path) -> dict[str, Any]:
+    try:
+        import tomllib  # type: ignore[attr-defined]
+    except ModuleNotFoundError:
+        import tomli as tomllib  # type: ignore[no-redef]
+
+    with open(path, "rb") as handle:
+        return tomllib.load(handle)
+
+
+class NetworkConfig(BaseModel):
+    publish: bool = False
+    host: str = "0.0.0.0"
+    port: int = 8100
+
+
+class LibOSConfig(BaseModel):
+    name: str = "lllm"
+    strict_boot: bool = True
+    discover_shared_packages: bool = False
+
+
+class ModuleConfig(BaseModel):
+    id: str
+    framework: str = "lllm"
+    lllm_toml: str | None = None
+    channels: list[str] = Field(default_factory=list)
+    executors: list[str] = Field(default_factory=list)
+    remote_channels: list[str] = Field(default_factory=list)
+    manifest: dict[str, Any] | None = None
+
+
+class AAAXConfig(BaseModel):
+    id: str = "aaax-main"
+    name: str = "AAAX Kernel"
+    policy: str | dict[str, Any] | None = "default"
+    libos: LibOSConfig = Field(default_factory=LibOSConfig)
+    modules: list[ModuleConfig] = Field(default_factory=list)
+    network: NetworkConfig = Field(default_factory=NetworkConfig)
+
+    @classmethod
+    def from_file(cls, path: str | Path) -> "AAAXConfig":
+        raw = _load_toml(path)
+        return cls(**raw.get("aaax", {}))

aaax/constellation.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from aaax._vendor import ensure_vendor_paths
+
+ensure_vendor_paths()
+
+from sssn.core.channel import BaseChannel
+from sssn.core.system import BaseSystem
+
+
+@dataclass(slots=True)
+class DockRecord:
+    system_id: str
+    system: BaseSystem
+    granted_channels: set[str] = field(default_factory=set)
+    provided_channels: set[str] = field(default_factory=set)
+    privileged: bool = False
+    status: str = "docked"
+
+
+class ConstellationManager:
+    def __init__(self) -> None:
+        self._systems: dict[str, DockRecord] = {}
+        self._channels: dict[str, BaseChannel] = {}
+
+    def register(
+        self,
+        system: BaseSystem,
+        channels: list[str] | None = None,
+        *,
+        privileged: bool = False,
+    ) -> DockRecord:
+        if system.id in self._systems:
+            raise ValueError(f"System '{system.id}' is already docked.")
+
+        provided_channels: set[str] = set()
+        for channel in system.all_channels:
+            existing = self._channels.get(channel.id)
+            if existing is not None and existing is not channel:
+                raise ValueError(f"Channel '{channel.id}' already registered by another system.")
+            self._channels[channel.id] = channel
+            provided_channels.add(channel.id)
+
+        record = DockRecord(
+            system_id=system.id,
+            system=system,
+            granted_channels=set(channels or []),
+            provided_channels=provided_channels,
+            privileged=privileged,
+        )
+        self._systems[system.id] = record
+        return record
+
+    def unregister(self, system_id: str) -> DockRecord | None:
+        record = self._systems.pop(system_id, None)
+        if record is None:
+            return None
+        for channel_id in record.provided_channels:
+            channel = self._channels.get(channel_id)
+            if channel is not None and channel in record.system.all_channels:
+                self._channels.pop(channel_id, None)
+        return record
+
+    def get(self, system_id: str) -> DockRecord | None:
+        return self._systems.get(system_id)
+
+    def set_status(self, system_id: str, status: str) -> None:
+        record = self._systems.get(system_id)
+        if record is not None:
+            record.status = status
+
+    def resolve_channel(self, channel_id: str) -> BaseChannel | None:
+        return self._channels.get(channel_id)
+
+    def systems(self) -> list[DockRecord]:
+        return list(self._systems.values())
+
+    def system_ids(self) -> list[str]:
+        return sorted(self._systems.keys())
+
+    def active_count(self) -> int:
+        return len(self._systems)