agent-runtime-cockpit 0.1.0a0__py3-none-any.whl

agent_runtime_cockpit/__daemon_main__.py

@@ -0,0 +1,52 @@
+"""ARC Daemon — PyInstaller entry point.
+
+This module serves as the main script for PyInstaller bundling.
+When frozen, it starts the ARC daemon server directly.
+In normal development, users use `arc serve` via the CLI.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+# Ensure the package root is on sys.path when frozen
+if getattr(sys, "frozen", False):
+    # PyInstaller bundles packages under sys._MEIPASS
+    meipass = Path(sys._MEIPASS)  # type: ignore[attr-defined]
+    pkg_root = meipass / "agent_runtime_cockpit"
+    if pkg_root.is_dir():
+        sys.path.insert(0, str(meipass))
+
+
+def main() -> None:
+    """Parse CLI-style args and start the daemon."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="ARC Studio Daemon")
+    parser.add_argument(
+        "--host",
+        default="localhost",
+        help="Host to bind (default: localhost)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7777,
+        help="Port to bind (default: 7777)",
+    )
+    parser.add_argument(
+        "--workspace",
+        type=Path,
+        default=None,
+        help="Workspace path",
+    )
+    args = parser.parse_args()
+
+    from agent_runtime_cockpit.daemon import start
+
+    start(host=args.host, port=args.port, workspace=args.workspace)
+
+
+if __name__ == "__main__":
+    main()

agent_runtime_cockpit/__init__.py

@@ -0,0 +1,6 @@
+"""ARC — Agent Runtime Cockpit
+Python daemon, CLI, adapters, and context retrieval engine.
+"""
+
+__version__ = "0.1.0a0"
+__all__ = ["__version__"]

agent_runtime_cockpit/_legacy_cli.py

@@ -0,0 +1,60 @@
+"""ARC CLI — Agent Runtime Cockpit command-line interface.
+
+Commands:
+  arc version    — print ARC version information
+  arc health     — check ARC daemon and environment health
+  arc status     — show ARC workspace and runtime status overview
+  arc inspect    — inspect workspace, detect runtimes
+  arc runtimes   — list detected runtimes
+  arc workflows  — list detected workflows
+  arc schemas    — list detected schemas
+  arc serve      — start HTTP daemon
+  arc run        — execute a workflow
+  arc runs       — list stored runs
+  arc doctor     — diagnostics (swarmgraph, all)
+  arc context    — context retrieval commands
+  arc adapter    — adapter management and conformance testing
+"""
+
+from __future__ import annotations
+
+# Phase 25: decomposed CLI modules. Re-export for backward compatibility.
+from .cli._app import app, console, err_console, main  # noqa: F401
+from .cli._helpers import (  # noqa: F401
+    DEBUG_FLAG,
+    JSON_FLAG,
+    LOCAL_REAL_GATE_ENVS,
+    WORKSPACE_FLAG,
+    _local_real_gate_open,
+    _local_real_gate_state,
+    _out,
+    _profile_payload,
+    _run_preflight,
+    _setup_logging,
+    _validate_runtime_mode,
+    _workspace,
+    check_swarmgraph_runtime,
+)
+from .cli._subapps import (  # noqa: F401
+    accounts_app,
+    adapter_app,
+    config_app,
+    context_app,
+    doctor_app,
+    eval_app,
+    hitl_app,
+    isolation_app,
+    key_app,
+    profiles_app,
+    prompt_app,
+    providers_app,
+    quota_app,
+    routing_app,
+    storage_app,
+    studio_app,
+    studio_sessions_app,
+    workspace_app,
+)
+
+
+# ─── version ──────────────────────────────────────────────────────────────────

agent_runtime_cockpit/a2a/__init__.py

@@ -0,0 +1,23 @@
+"""A2A Local AgentCard Generator + Loopback Client.
+
+Provides A2A v1.2 spec-compliant agent card generation, disk-based storage,
+per-card approval, and a loopback-only outbound client.
+
+NO inbound HTTP server — cards are written to .arc/a2a/agent-card.json only.
+"""
+
+from .models import (
+    AgentCard,
+    AgentCardCapability,
+    AgentCardProvider,
+    AgentCardSignature,
+    AgentCardSkill,
+)
+
+__all__ = [
+    "AgentCard",
+    "AgentCardCapability",
+    "AgentCardProvider",
+    "AgentCardSignature",
+    "AgentCardSkill",
+]

agent_runtime_cockpit/a2a/client.py

@@ -0,0 +1,127 @@
+"""Loopback-only outbound A2A client.
+
+Constraints:
+- Only 127.0.0.1 URLs accepted (no other hosts)
+- Unsigned cards refused
+- Per-card approval required
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from .models import AgentCard
+
+_LOOPBACK_RE = re.compile(r"^http://127\.0\.0\.1:\d+(/|$)")
+
+APPROVED_CARDS_FILE = "approved.json"
+
+
+class A2AClientError(Exception):
+    """Base error for A2A client."""
+
+
+class NonLoopbackError(A2AClientError):
+    """URL is not loopback."""
+
+
+class UnsignedCardError(A2AClientError):
+    """Card has no signature."""
+
+
+class UnapprovedCardError(A2AClientError):
+    """Card not in approved list."""
+
+
+def _validate_url(url: str) -> None:
+    if not _LOOPBACK_RE.match(url):
+        raise NonLoopbackError(f"Non-loopback URL refused: {url}")
+
+
+def _load_approved(arc_dir: Path) -> dict[str, Any]:
+    path = arc_dir / "a2a" / APPROVED_CARDS_FILE
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text())
+
+
+def _save_approved(arc_dir: Path, data: dict[str, Any]) -> None:
+    path = arc_dir / "a2a" / APPROVED_CARDS_FILE
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def is_card_approved(card: AgentCard, arc_dir: Optional[Path] = None) -> bool:
+    """Check if a card is in the approved list."""
+    base = arc_dir or Path.home() / ".arc"
+    approved = _load_approved(base)
+    return card.name in approved
+
+
+def approve_card(card: AgentCard, arc_dir: Optional[Path] = None) -> None:
+    """Add card to the approved list."""
+    base = arc_dir or Path.home() / ".arc"
+    approved = _load_approved(base)
+    approved[card.name] = {"version": card.version, "url": card.url}
+    _save_approved(base, approved)
+
+
+def revoke_card(card_name: str, arc_dir: Optional[Path] = None) -> bool:
+    """Remove card from approved list. Returns True if was present."""
+    base = arc_dir or Path.home() / ".arc"
+    approved = _load_approved(base)
+    if card_name in approved:
+        del approved[card_name]
+        _save_approved(base, approved)
+        return True
+    return False
+
+
+def _check_card(card: AgentCard, arc_dir: Path) -> None:
+    """Validate card has signature and is approved."""
+    if not card.signature:
+        raise UnsignedCardError(f"Card '{card.name}' has no signature")
+    if not is_card_approved(card, arc_dir):
+        raise UnapprovedCardError(f"Card '{card.name}' is not approved")
+
+
+def invoke_sync(
+    card: AgentCard,
+    *,
+    payload: dict[str, Any],
+    arc_dir: Optional[Path] = None,
+    timeout: float = 30.0,
+) -> dict[str, Any]:
+    """Synchronous A2A invoke — loopback only, signed+approved cards only."""
+    import httpx
+
+    base = arc_dir or Path.home() / ".arc"
+    _validate_url(card.url)
+    _check_card(card, base)
+
+    resp = httpx.post(card.url, json=payload, timeout=timeout)
+    resp.raise_for_status()
+    return resp.json()
+
+
+async def invoke_async(
+    card: AgentCard,
+    *,
+    payload: dict[str, Any],
+    arc_dir: Optional[Path] = None,
+    timeout: float = 30.0,
+) -> dict[str, Any]:
+    """Async A2A invoke — loopback only, signed+approved cards only."""
+    import httpx
+
+    base = arc_dir or Path.home() / ".arc"
+    _validate_url(card.url)
+    _check_card(card, base)
+
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(card.url, json=payload, timeout=timeout)
+        resp.raise_for_status()
+        return resp.json()

agent_runtime_cockpit/a2a/generator.py

@@ -0,0 +1,98 @@
+"""A2A AgentCard generator — writes .arc/a2a/agent-card.json."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Optional
+
+from .models import (
+    AgentCard,
+    AgentCardCapability,
+    AgentCardProvider,
+    AgentCardSignature,
+    AgentCardSkill,
+)
+
+
+def _canonicalize(card: AgentCard) -> bytes:
+    """Deterministic JSON for signing (excludes signature field)."""
+    d = card.model_dump(mode="json", exclude={"signature"})
+    return json.dumps(d, sort_keys=True, separators=(",", ":")).encode("utf-8")
+
+
+def _sign_card_hmac(
+    card: AgentCard, secret_key: str, signer_id: str = "arc-runtime"
+) -> AgentCardSignature:
+    import base64
+    import hmac as _hmac
+
+    data = _canonicalize(card)
+    sig = _hmac.new(secret_key.encode(), data, hashlib.sha256).digest()
+    return AgentCardSignature(
+        algorithm="hmac_sha256",
+        signature=base64.b64encode(sig).decode("ascii"),
+        signer_id=signer_id,
+    )
+
+
+def generate_agent_card(
+    *,
+    name: str = "arc-studio",
+    description: str = "ARC Studio local agent",
+    version: str = "1.0.0",
+    url: str = "",
+    provider_name: str = "arc-studio",
+    provider_url: str = "",
+    capabilities: Optional[AgentCardCapability] = None,
+    skills: Optional[list[AgentCardSkill]] = None,
+    secret_key: Optional[str] = None,
+    signer_id: str = "arc-runtime",
+) -> AgentCard:
+    """Generate a deterministic AgentCard. Optionally sign with HMAC."""
+    card = AgentCard(
+        name=name,
+        description=description,
+        version=version,
+        url=url,
+        provider=AgentCardProvider(name=provider_name, url=provider_url),
+        capabilities=capabilities or AgentCardCapability(),
+        skills=skills or [],
+    )
+    if secret_key:
+        card.signature = _sign_card_hmac(card, secret_key, signer_id)
+    return card
+
+
+def write_agent_card(card: AgentCard, arc_dir: Optional[Path] = None) -> Path:
+    """Write AgentCard to .arc/a2a/agent-card.json. Returns path written."""
+    base = arc_dir or Path.home() / ".arc"
+    out_dir = base / "a2a"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_path = out_dir / "agent-card.json"
+    out_path.write_text(json.dumps(card.model_dump(mode="json"), indent=2, sort_keys=True) + "\n")
+    return out_path
+
+
+def load_agent_card(arc_dir: Optional[Path] = None) -> Optional[AgentCard]:
+    """Load AgentCard from disk, or None if not present."""
+    base = arc_dir or Path.home() / ".arc"
+    path = base / "a2a" / "agent-card.json"
+    if not path.exists():
+        return None
+    data = json.loads(path.read_text())
+    return AgentCard.model_validate(data)
+
+
+def verify_agent_card(card: AgentCard, secret_key: str) -> bool:
+    """Verify HMAC signature on an AgentCard."""
+    if not card.signature or card.signature.algorithm != "hmac_sha256":
+        return False
+    import base64
+    import hmac as _hmac
+
+    data = _canonicalize(card)
+    expected = _hmac.new(secret_key.encode(), data, hashlib.sha256).digest()
+    expected_b64 = base64.b64encode(expected).decode("ascii")
+    return _hmac.compare_digest(expected_b64, card.signature.signature)

agent_runtime_cockpit/a2a/models.py

@@ -0,0 +1,69 @@
+"""A2A v1.2 spec models — AgentCard, skills, capabilities, signature."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+A2A_PROTOCOL_VERSION = "1.2"
+
+
+class AgentCardSkill(BaseModel):
+    """A2A skill descriptor."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str
+    name: str
+    description: str = ""
+    tags: list[str] = Field(default_factory=list)
+    examples: list[str] = Field(default_factory=list)
+
+
+class AgentCardCapability(BaseModel):
+    """A2A agent capabilities."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    streaming: bool = False
+    pushNotifications: bool = False
+    stateTransitionHistory: bool = False
+
+
+class AgentCardProvider(BaseModel):
+    """A2A provider info."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    name: str
+    url: str = ""
+
+
+class AgentCardSignature(BaseModel):
+    """Cryptographic signature for an AgentCard."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    algorithm: str  # e.g. "hmac_sha256", "ecdsa_p256"
+    signature: str  # Base64-encoded
+    signer_id: str = "arc-runtime"
+    public_key_pem: Optional[str] = None
+
+
+class AgentCard(BaseModel):
+    """A2A v1.2 AgentCard — disk-only, no inbound HTTP."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    name: str
+    description: str = ""
+    version: str = "1.0.0"
+    protocolVersion: str = A2A_PROTOCOL_VERSION
+    url: str = ""  # loopback URL or empty
+    provider: AgentCardProvider = Field(
+        default_factory=lambda: AgentCardProvider(name="arc-studio")
+    )
+    capabilities: AgentCardCapability = Field(default_factory=AgentCardCapability)
+    skills: list[AgentCardSkill] = Field(default_factory=list)
+    signature: Optional[AgentCardSignature] = None

agent_runtime_cockpit/adapters/__init__.py

@@ -0,0 +1,21 @@
+"""ARC runtime adapters — base, registry, swarmgraph, langgraph, conformance.
+
+Module layout
+-------------
+Each adapter has a **canonical single-file implementation** (e.g. ``crewai.py``) that
+is the live, wired module imported by ``registry.py:build_default()``.
+
+Some adapters also have a **sibling package** (e.g. ``crewai/``) whose ``__init__.py``
+re-exports the adapter class via ``_compat.load_sibling_adapter``. These packages exist
+so that ``from .adapters.crewai import CrewAIAdapter`` works as a package import path.
+They are **intentional forwarding shims**, not duplicates.
+
+The ``*_mapping.py`` siblings (``agno_mapping``, ``browser_use_mapping``,
+``letta_mapping``, ``pydantic_ai_mapping``, ``strands_mapping``) are side-effect
+imports that register AG-UI event mappers on import; each is imported by its parent
+adapter module.
+"""
+from .base import RuntimeAdapter
+from .registry import AdapterRegistry
+
+__all__ = ["RuntimeAdapter", "AdapterRegistry"]

agent_runtime_cockpit/adapters/_compat.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+
+def load_sibling_adapter(package_file: str, module_name: str) -> ModuleType:
+    adapter_path = Path(package_file).resolve().parent.with_suffix(".py")
+    spec_name = f"agent_runtime_cockpit.adapters._{module_name}_adapter"
+    spec = importlib.util.spec_from_file_location(spec_name, adapter_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"cannot load {module_name} adapter from {adapter_path}")
+    module = importlib.util.module_from_spec(spec)
+    module.__package__ = "agent_runtime_cockpit.adapters"
+    sys.modules[spec_name] = module
+    spec.loader.exec_module(module)
+    return module

agent_runtime_cockpit/adapters/_shared.py

@@ -0,0 +1,78 @@
+"""Shared helpers used by multiple runtime adapters."""
+
+from __future__ import annotations
+
+import sys
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from decimal import Decimal
+from pathlib import Path
+from typing import Any, Iterator
+
+from ..protocol.schemas import RunEvent
+
+
+def make_event(run_id: str, sequence: int, event_type: str, data: dict) -> RunEvent:
+    """Construct a RunEvent with the current UTC timestamp."""
+    return RunEvent(
+        type=event_type,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+        run_id=run_id,
+        sequence=sequence,
+        data=data,
+    )
+
+
+def budget_checkpoint(
+    enforcer: Any,
+    estimated_cost_usd: Any,
+    *,
+    provider_id: str,
+    run_active: bool = True,
+    workflow_active: bool = True,
+) -> None:
+    """Shared adapter effect-boundary budget gate (B2P-09).
+
+    Adapters/run paths call this immediately before a cost-incurring effect. With a `BudgetEnforcer`
+    present it runs `preflight`, which raises `BudgetExceeded` (real-time exhaustion interrupt) or
+    `ConfirmationRequired`. When ``enforcer`` is ``None`` it falls back to the run-scoped enforcer
+    (``budget.runtime_context``); if that is also ``None`` it is a no-op (budget disabled), so callers
+    can invoke it unconditionally at every effect boundary.
+    """
+    if enforcer is None:
+        from ..budget.runtime_context import current_run_budget_enforcer
+
+        enforcer = current_run_budget_enforcer()
+    if enforcer is None:
+        return
+    cost = (
+        estimated_cost_usd
+        if isinstance(estimated_cost_usd, Decimal)
+        else Decimal(str(estimated_cost_usd))
+    )
+    enforcer.preflight(
+        cost,
+        provider_id=provider_id,
+        run_active=run_active,
+        workflow_active=workflow_active,
+    )
+
+
+@contextmanager
+def workspace_import_path(workspace: Path) -> Iterator[None]:
+    """Temporarily add workspace (and workspace/src) to sys.path."""
+    added: list[str] = []
+    for candidate in (workspace, workspace / "src"):
+        if candidate.exists():
+            value = str(candidate.resolve())
+            if value not in sys.path:
+                sys.path.insert(0, value)
+                added.append(value)
+    try:
+        yield
+    finally:
+        for value in added:
+            try:
+                sys.path.remove(value)
+            except ValueError:
+                pass

agent_runtime_cockpit/adapters/_static.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import itertools
+from pathlib import Path
+
+from ..protocol.schemas import NodeType, WorkflowInfo, WorkflowNode
+from ..workspace import iter_workspace_files
+
+
+def _strip_inline_comment(line: str) -> str:
+    """Drop everything from the first ``#`` (comment marker) to end of line."""
+    idx = line.find("#")
+    return line if idx < 0 else line[:idx]
+
+
+def _token_present(text: str, needle: str) -> bool:
+    """True if *needle* occurs in *text* as a package-name token.
+
+    Hardened against substring false positives:
+    - comments (``#`` to end-of-line) are stripped per line, so a commented-out
+      dependency or import never counts as evidence;
+    - a match must not be flanked by an alphanumeric character on either side,
+      so ``agno`` matches ``agno>=1.0`` and ``crewai-tools`` but NOT
+      ``diagnostics`` / ``agnostic``.
+
+    Inputs are expected to be already lower-cased.
+    """
+    nlen = len(needle)
+    for raw_line in text.splitlines():
+        line = _strip_inline_comment(raw_line)
+        start = 0
+        while True:
+            i = line.find(needle, start)
+            if i < 0:
+                break
+            before = line[i - 1] if i > 0 else ""
+            after = line[i + nlen] if i + nlen < len(line) else ""
+            if not (before.isalnum() or after.isalnum()):
+                return True
+            start = i + 1
+    return False
+
+
+def dependency_evidence(workspace: Path, needles: tuple[str, ...]) -> tuple[float, list[str]]:
+    score = 0.0
+    evidence: list[str] = []
+    for req_file in ("pyproject.toml", "requirements.txt", "requirements-dev.txt"):
+        path = workspace / req_file
+        if not path.exists():
+            continue
+        try:
+            text = path.read_text(errors="ignore").lower()
+        except OSError:
+            continue
+        for needle in needles:
+            if _token_present(text, needle):
+                evidence.append(f"{needle} in {req_file}")
+                score += 0.8
+                break
+    return min(score, 1.0), evidence
+
+
+def import_evidence(workspace: Path, needles: tuple[str, ...]) -> tuple[float, list[str]]:
+    score = 0.0
+    evidence: list[str] = []
+    for py_file in itertools.islice(iter_workspace_files(workspace, (".py",)), 40):
+        try:
+            text = py_file.read_text(errors="ignore").lower()
+        except OSError:
+            continue
+        if any(_token_present(text, needle) for needle in needles):
+            evidence.append(f"import in {py_file.name}")
+            score += 0.6
+            break
+    return min(score, 1.0), evidence
+
+
+def static_workflow(
+    runtime: str, name: str, workspace: Path, evidence: list[str]
+) -> list[WorkflowInfo]:
+    source = evidence[0] if evidence else None
+    return [
+        WorkflowInfo(
+            id=f"wf-{runtime}-static",
+            name=f"{name} static export",
+            runtime=runtime,
+            source_file=source,
+            nodes=[WorkflowNode(id="runtime", label=name, type=NodeType.AGENT)],
+            metadata={"workspace": str(workspace), "can_run": False, "export_mode": "static"},
+        )
+    ]

agent_runtime_cockpit/adapters/ag2/detect.py

@@ -0,0 +1,23 @@
+"""Detect AG2 (AutoGen) projects in a workspace."""
+from __future__ import annotations
+
+import pathlib
+import re
+
+_PATTERNS = [re.compile(r"\bfrom\s+autogen\b"), re.compile(r"\bGroupChatManager\b")]
+
+
+def is_ag2_workspace(workspace: pathlib.Path) -> bool:
+    py = (workspace / "pyproject.toml")
+    if py.exists() and "autogen" in py.read_text(errors="ignore").lower():
+        return True
+    for p in workspace.rglob("*.py"):
+        if any(part in {".venv", "site-packages"} for part in p.parts):
+            continue
+        try:
+            src = p.read_text(errors="ignore")
+        except OSError:
+            continue
+        if any(pat.search(src) for pat in _PATTERNS):
+            return True
+    return False