aria-code 0.52.0__py3-none-any.whl

aria_code/apps/__init__.py

@@ -0,0 +1,2 @@
+"""Product entrypoints for Aria Code."""
+

aria_code/apps/channels/README.md

@@ -0,0 +1,15 @@
+# Channel Apps
+
+Target role: adapters for non-terminal entrypoints.
+
+Examples:
+
+- relay server/client;
+- Feishu bot;
+- Telegram bot;
+- webhooks;
+- future desktop or browser UI.
+
+Each channel should translate inbound messages into gateway requests and render
+gateway responses back to the channel. It should not bypass safety, runtime, or
+artifact policies.

aria_code/apps/channels/__init__.py

@@ -0,0 +1,17 @@
+"""Aria channels — external entrypoints as structured-task producers."""
+
+from .registry import (
+    CHANNEL_TASK_SCHEMA,
+    ChannelSpec,
+    channel_map,
+    default_channels,
+    enabled_channels,
+)
+
+__all__ = [
+    "CHANNEL_TASK_SCHEMA",
+    "ChannelSpec",
+    "channel_map",
+    "default_channels",
+    "enabled_channels",
+]

aria_code/apps/channels/intake.py

@@ -0,0 +1,92 @@
+"""Channel intake policy + gateway submission (the daemon-facing half).
+
+Completes the channels contract loop: the daemon's webhook endpoint hands
+verified channel tasks to ``runtime.run_turn`` instead of poking CLI
+internals, and refuses unauthenticated ("open mode") intake from anywhere
+but localhost.
+
+Two pieces, both dependency-light so the daemon can import them without
+dragging in aria_cli:
+
+  • should_refuse_open_intake() — pure policy: when neither an intake token
+    nor ARIA_WEBHOOK_SECRET is configured, only loopback clients may submit.
+  • analyze_alert_via_gateway() — submits a task prompt through the shared
+    runtime gateway with an EMPTY tool set: channel-triggered turns get
+    model analysis but can never execute tools from the daemon context.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+_LOOPBACK_HOSTS = {"127.0.0.1", "::1", "localhost"}
+
+
+def should_refuse_open_intake(
+    client_host: Optional[str],
+    *,
+    token_configured: bool,
+    secret_configured: bool,
+) -> bool:
+    """True when an unauthenticated intake must be rejected.
+
+    With any credential configured (endpoint token or webhook passphrase),
+    authentication handles trust and remote clients are fine. With neither
+    configured the endpoint is running "open", which is only acceptable from
+    the loopback interface — an open endpoint reachable off-host would let
+    anyone on the network inject buy/sell alerts.
+    """
+    if token_configured or secret_configured:
+        return False
+    host = str(client_host or "").strip().lower()
+    if host.startswith("[") and host.endswith("]"):  # bracketed IPv6
+        host = host[1:-1]
+    return host not in _LOOPBACK_HOSTS
+
+
+async def analyze_alert_via_gateway(
+    prompt: str,
+    config: Dict[str, Any],
+    *,
+    run_turn_fn: Optional[Callable] = None,
+    max_rounds: int = 4,
+) -> str:
+    """Run one tool-less analysis turn for a channel task; returns the text.
+
+    ``run_turn_fn`` is injectable for tests; the default builds the same
+    provider selection the CLI uses (chat_routing via runtime_bridge) and
+    drives ``runtime.gateway.run_turn``. Raises on failure — the caller
+    decides its own fallback (the daemon keeps its legacy quick summary).
+    """
+    if run_turn_fn is None:
+        # stream_ollama borrows 47 bare names from aria_cli's module globals
+        # (verified by AST audit) and only works after aria_cli's import-time
+        # rebinding. Until that module is untangled, any out-of-CLI consumer
+        # of the default Ollama path must import aria_cli first — a one-time
+        # ~1s cost the long-lived daemon amortizes.
+        import aria_cli  # noqa: F401  (side effect: binds stream_ollama globals)
+        from apps.cli.providers.runtime_bridge import build_tool_executor, make_provider_fn
+        from runtime.gateway import run_turn as run_turn_fn_impl
+
+        provider_fn = make_provider_fn(
+            model=str(config.get("model", "qwen2.5:7b")),
+            config=config,
+            api_url=config.get("api_url"),
+            ollama_url=str(config.get("ollama_url", "http://localhost:11434")),
+            tool_schemas=[],
+        )
+        executor = build_tool_executor({}, config)
+
+        async def run_turn_fn(prompt_, history_, **kw):
+            return await run_turn_fn_impl(
+                prompt_, history_,
+                provider_fn=provider_fn, tool_executor=executor,
+                tool_schemas=[], max_rounds=max_rounds,
+            )
+
+    result = await run_turn_fn(prompt, [])
+    text = (getattr(result, "text", "") or "").strip()
+    error = getattr(result, "error", None)
+    if error or not text:
+        raise RuntimeError(f"gateway turn failed: {error or 'empty response'}")
+    return text

aria_code/apps/channels/registry.py

@@ -0,0 +1,95 @@
+"""Channel registry — the declared inventory of external entrypoints.
+
+First slice of the channels layer (contract: "Channels submit structured
+tasks to gateway/runtime and never call CLI internals directly"). The
+registry is pure data + config resolution: it names each channel, its
+direction, the config/env that enables it, and which capability it maps to,
+so the daemon and doctor can reason about channels uniformly instead of each
+integration hard-coding its own discovery.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Mapping, Tuple
+
+CHANNEL_TASK_SCHEMA = "aria.channel_task.v1"
+
+
+@dataclass(frozen=True)
+class ChannelSpec:
+    name: str
+    direction: str              # "inbound" | "outbound" | "both"
+    description: str
+    capabilities: Tuple[str, ...] = ()
+    # Any of these config keys (or env vars) being truthy enables the channel.
+    config_keys: Tuple[str, ...] = ()
+    env_keys: Tuple[str, ...] = ()
+
+    def enabled(self, config: Mapping[str, Any], env: Mapping[str, str]) -> bool:
+        for key in self.config_keys:
+            if config.get(key):
+                return True
+        for key in self.env_keys:
+            if str(env.get(key, "") or "").strip():
+                return True
+        return False
+
+
+def default_channels() -> List[ChannelSpec]:
+    return [
+        ChannelSpec(
+            name="tradingview",
+            direction="inbound",
+            description="TradingView alert webhooks → structured alert tasks",
+            capabilities=("alerts.ingest", "orders.preview"),
+            config_keys=("tradingview_webhook",),
+            env_keys=("ARIA_WEBHOOK_SECRET",),
+        ),
+        ChannelSpec(
+            name="webhook_jobs",
+            direction="inbound",
+            description="Generic daemon webhook job queue (/webhook/trigger)",
+            capabilities=("tasks.enqueue",),
+            env_keys=("WEBHOOK_TOKEN",),
+        ),
+        ChannelSpec(
+            name="telegram",
+            direction="both",
+            description="Telegram bot push + command intake via the daemon",
+            capabilities=("notify.push", "chat.intake"),
+            config_keys=("telegram_bot_token",),
+            env_keys=("TELEGRAM_BOT_TOKEN",),
+        ),
+        ChannelSpec(
+            name="feishu",
+            direction="outbound",
+            description="Feishu webhook card push",
+            capabilities=("notify.push",),
+            config_keys=("feishu_webhook",),
+            env_keys=("FEISHU_WEBHOOK_URL",),
+        ),
+        ChannelSpec(
+            name="macos_notify",
+            direction="outbound",
+            description="Local macOS notification center",
+            capabilities=("notify.push",),
+            config_keys=("macos_notifications",),
+        ),
+        ChannelSpec(
+            name="email",
+            direction="outbound",
+            description="SMTP email push",
+            capabilities=("notify.push",),
+            config_keys=("email_smtp_host",),
+            env_keys=("ARIA_SMTP_HOST",),
+        ),
+    ]
+
+
+def channel_map() -> Dict[str, ChannelSpec]:
+    return {spec.name: spec for spec in default_channels()}
+
+
+def enabled_channels(config: Mapping[str, Any], env: Mapping[str, str]) -> List[ChannelSpec]:
+    return [spec for spec in default_channels() if spec.enabled(config, env)]

aria_code/apps/channels/tradingview.py

@@ -0,0 +1,94 @@
+"""TradingView alert → structured channel task (aria.channel_task.v1).
+
+The channels contract requires external entrypoints to submit *structured
+tasks* to the gateway instead of poking CLI internals. This adapter turns a
+raw TradingView webhook payload into that task shape, reusing the hardened
+primitives that already live in apps/cli/tradingview_bridge.py (field-tolerant
+parsing, passphrase + HMAC verification, dedup keys).
+
+Verification posture mirrors the bridge's documented semantics: with
+ARIA_WEBHOOK_SECRET unset verification is open (localhost-only assumption),
+but the task carries explicit ``verified`` / ``open_mode`` flags so a
+downstream gate (daemon, SafetyService) can refuse open-mode tasks in
+non-local deployments.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, Optional
+
+from aria_code.apps.cli.tradingview_bridge import (
+    _alert_dedup_key as alert_dedup_key,
+    _expected_webhook_secret,
+    parse_tradingview_alert,
+    verify_webhook_hmac,
+    verify_webhook_secret,
+)
+from aria_code.apps.channels.registry import CHANNEL_TASK_SCHEMA
+
+
+def alert_to_task(
+    payload: Dict[str, Any] | str,
+    *,
+    raw_body: Optional[bytes | str] = None,
+    signature: Optional[str] = None,
+    clock: Callable[[], float] = time.time,
+) -> Dict[str, Any]:
+    """Normalize + authenticate one webhook delivery.
+
+    Returns ``{"success": True, "task": {...}}`` or
+    ``{"success": False, "error": ...}`` (tool-result convention).
+    """
+    alert = parse_tradingview_alert(payload)
+    raw = alert.get("raw") or {}
+
+    secret_configured = bool(_expected_webhook_secret())
+    if signature is not None:
+        # A fronting signer supplied an HMAC — it must verify (never open).
+        if not verify_webhook_hmac(raw_body if raw_body is not None else "", signature):
+            return {"success": False, "error": "tradingview alert rejected: HMAC signature mismatch"}
+        verified = True
+    else:
+        if not verify_webhook_secret(raw):
+            return {"success": False, "error": "tradingview alert rejected: passphrase missing or wrong"}
+        verified = secret_configured  # open mode when no secret is configured
+
+    if not alert.get("symbol"):
+        return {"success": False, "error": "tradingview alert rejected: no symbol in payload"}
+
+    task = {
+        "schema": CHANNEL_TASK_SCHEMA,
+        "channel": "tradingview",
+        "kind": "alert",
+        "received_at": clock(),
+        "verified": verified,
+        "open_mode": not secret_configured and signature is None,
+        "dedup_key": alert_dedup_key(alert),
+        "symbol": alert["symbol"],
+        "action": alert["action"],
+        "price": alert.get("price"),
+        "time": alert.get("time"),
+        "message": alert.get("message") or "",
+        "prompt": task_prompt(alert),
+    }
+    return {"success": True, "task": task}
+
+
+def task_prompt(alert: Dict[str, Any]) -> str:
+    """Render the gateway-facing natural-language task for this alert.
+
+    The daemon submits this prompt to runtime's ``run_turn`` — the agent then
+    analyses the alert with its normal tools; nothing here places orders.
+    """
+    symbol = alert.get("symbol", "")
+    action = alert.get("action", "ALERT")
+    price = alert.get("price")
+    at = f" at {price}" if price not in (None, "") else ""
+    msg = str(alert.get("message") or "").strip()
+    tail = f' Alert message: "{msg}".' if msg else ""
+    return (
+        f"TradingView alert received: {action} signal for {symbol}{at}.{tail} "
+        f"Assess the signal against current market data and the portfolio, and "
+        f"summarize whether it warrants action. Do not place any orders."
+    )

aria_code/apps/cli/README.md

@@ -0,0 +1,13 @@
+# CLI App
+
+Target role: terminal UI and command parsing only.
+
+The CLI should depend on these services:
+
+- `gateway`: session routing and task orchestration.
+- `runtime`: agent loop and tool execution.
+- `ui`: terminal rendering and input.
+- `reports`: local artifact and report output.
+
+Migration rule: new slash commands should call package services instead of
+adding more business logic to `aria_cli.py`.

aria_code/apps/cli/__init__.py

@@ -0,0 +1,2 @@
+"""Terminal client entrypoint and adapters for Aria Code."""
+

aria_code/apps/cli/_optional.py

@@ -0,0 +1,120 @@
+"""Guarded imports for optional dependencies.
+
+These try/except blocks sat in aria_cli.py, so five command mixins reached into
+a 7000-line module to ask "is the market-data client available?". Nothing about
+that question is session state — it is a fact about the install.
+
+Import form matters here and is not incidental. market_data_client keeps a
+module-level singleton, and the package is reachable under two roots whose
+module objects are distinct — so importing it as aria_code.clients.
+market_data_client would build a *second* MarketDataClient with its own
+connections and caches. Every caller in the tree currently uses the bare
+`market_data_client` shim, so there is one client today; this module uses the
+same form deliberately to keep it that way. Converging the two roots is a
+separate, repo-wide job (26 root modules use the same sys.modules shim trick).
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "MarketDataClient", "get_mdc", "HAS_MDC",
+    "HAS_BROKERS", "get_registry", "list_broker_configs", "get_broker_config",
+    "add_broker_config", "remove_broker_config", "set_default_broker",
+    "validate_broker_config", "supported_broker_types", "get_config_template",
+    "BROKERS_CONFIG_PATH",
+    "HAS_MODEL_CAP", "get_model_capability",
+    "HAS_MCP", "MCPToolRegistry", "MCP_CONFIG_PATH", "init_mcp",
+]
+
+try:
+    from market_data_client import MarketDataClient, get_mdc  # noqa: F401
+
+    HAS_MDC = True
+except ImportError:  # pragma: no cover - exercised only without the client installed
+    MarketDataClient = None  # type: ignore[assignment]
+    get_mdc = None  # type: ignore[assignment]
+    HAS_MDC = False
+
+
+# ── Brokers ──────────────────────────────────────────────────────────────────
+# Same reasoning as above, and the stakes are higher: brokers.registry keeps a
+# module-level BrokerRegistry singleton holding *live broker connections*, and
+# `brokers` / `aria_code.brokers` are distinct module objects with separate
+# singletons. Connecting through one and querying the other would report "not
+# connected" for a session that is. All 37 call sites in the tree use the bare
+# form, so there is one registry today; this module uses the same form to keep
+# it that way.
+try:
+    from brokers import (  # noqa: F401
+        BROKERS_CONFIG_PATH,
+        add_broker_config,
+        get_broker_config,
+        get_config_template,
+        get_registry,
+        list_broker_configs,
+        remove_broker_config,
+        set_default_broker,
+        supported_broker_types,
+        validate_broker_config,
+    )
+
+    HAS_BROKERS = True
+except ImportError:  # pragma: no cover - exercised only without the broker stack
+    HAS_BROKERS = False
+    BROKERS_CONFIG_PATH = None  # type: ignore[assignment]
+
+    # aria_cli's version of this block only supplied three of the ten fallbacks,
+    # so a build without the broker stack would raise NameError rather than
+    # degrade — on add/remove/validate/template, i.e. exactly the paths a user
+    # hits while trying to set a broker up. All ten are covered here.
+    def get_registry():  # type: ignore[misc]
+        return None
+
+    def list_broker_configs():  # type: ignore[misc]
+        return []
+
+    def get_broker_config(broker_id: str):  # type: ignore[misc]
+        return None
+
+    def add_broker_config(cfg):  # type: ignore[misc]
+        raise RuntimeError("Broker support is not installed")
+
+    def remove_broker_config(broker_id: str):  # type: ignore[misc]
+        raise RuntimeError("Broker support is not installed")
+
+    def set_default_broker(broker_id: str):  # type: ignore[misc]
+        raise RuntimeError("Broker support is not installed")
+
+    def validate_broker_config(cfg):  # type: ignore[misc]
+        return ["Broker support is not installed"]
+
+    def supported_broker_types():  # type: ignore[misc]
+        return []
+
+    def get_config_template(broker_type: str):  # type: ignore[misc]
+        return None
+
+
+# ── Model capability registry ────────────────────────────────────────────────
+# Another guarded import that happened to live in aria_cli. Used by the model
+# and UI commands to describe a community Ollama model that is not in the
+# MODELS table.
+try:
+    from model_capability import get_model_capability  # noqa: F401
+
+    HAS_MODEL_CAP = True
+except ImportError:  # pragma: no cover - exercised only without model_capability
+    get_model_capability = None  # type: ignore[assignment]
+    HAS_MODEL_CAP = False
+
+
+# ── MCP ──────────────────────────────────────────────────────────────────────
+try:
+    from mcp_client import MCP_CONFIG_PATH, MCPToolRegistry, init_mcp  # noqa: F401
+
+    HAS_MCP = True
+except ImportError:  # pragma: no cover - exercised only without mcp_client
+    MCPToolRegistry = None  # type: ignore[assignment]
+    MCP_CONFIG_PATH = None  # type: ignore[assignment]
+    init_mcp = None  # type: ignore[assignment]
+    HAS_MCP = False

aria_code/apps/cli/bootstrap.py

@@ -0,0 +1,145 @@
+"""CLI bootstrap utilities shared by legacy and packaged entrypoints."""
+
+from __future__ import annotations
+
+import os
+import socket
+import urllib.parse
+from pathlib import Path
+
+from aria_code.apps.cli.config_paths import resolve_paths
+
+
+def load_aria_env(env_file: Path | None = None) -> None:
+    """Load persisted CLI environment values without overriding the process."""
+    target = env_file or (Path.home() / ".aria" / ".env")
+    if not target.exists():
+        return
+    try:
+        for line in target.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, value = line.partition("=")
+            key = key.strip()
+            value = value.strip()
+            if key and value:
+                os.environ.setdefault(key, value)
+    except Exception:
+        return
+
+
+def disable_broken_proxy(timeout: float = 1.5) -> None:
+    """Unset proxy variables when the configured proxy cannot be reached."""
+    proxy = (
+        os.environ.get("HTTPS_PROXY")
+        or os.environ.get("https_proxy")
+        or os.environ.get("HTTP_PROXY")
+        or os.environ.get("http_proxy")
+    )
+    if not proxy:
+        return
+    try:
+        parsed = urllib.parse.urlparse(proxy if "://" in proxy else f"http://{proxy}")
+        host = parsed.hostname
+        port = parsed.port or 80
+        if not host:
+            return
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(timeout)
+        alive = sock.connect_ex((host, port)) == 0
+        sock.close()
+    except Exception:
+        alive = False
+    if not alive:
+        for name in ("HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy", "ALL_PROXY", "all_proxy"):
+            os.environ.pop(name, None)
+
+
+def use_system_trust_store() -> bool:
+    """Verify TLS against the OS trust store instead of certifi's bundle.
+
+    Corporate and local TLS-intercepting proxies present their own CA. That CA
+    is installed in the system keychain — which is why ``curl`` works on such a
+    machine — but Python verifies against certifi, which has never heard of it,
+    so every HTTPS call fails with CERTIFICATE_VERIFY_FAILED.
+
+    This was not hypothetical: on a machine behind an intercepting proxy,
+    ``oauth2.googleapis.com`` failed 5 times out of 5 from Python and returned
+    404 from curl, so roughly a third of Vertex turns died fetching an OAuth
+    token. Trusting the OS store fixed it without disabling verification —
+    which is the tempting wrong fix, and would accept any certificate at all.
+
+    Returns whether the injection happened, and never raises: an environment
+    without ``truststore`` keeps certifi's behaviour exactly as before.
+    """
+    try:
+        import truststore
+
+        truststore.inject_into_ssl()
+        return True
+    except Exception:
+        return False
+
+
+def initialize_cli_environment() -> None:
+    os.environ.setdefault("TQDM_DISABLE", "1")
+    load_aria_env()
+    disable_broken_proxy()
+    use_system_trust_store()
+
+
+# The model used when nothing has been configured yet.
+#
+# This exists so there is ONE place that answers "which model by default".
+# Call sites used to spell their own fallback — `config.get("model",
+# "qwen2.5:7b")`, ten times over — which quietly made Ollama the answer
+# whenever a config key was missing, no matter what the user had chosen.
+# Provider configuration is the user's to make (that is what `/model` and
+# `.ariarc` are for); the code's job is to have a sane default and then get
+# out of the way.
+DEFAULT_MODEL = os.getenv("ARIA_DEFAULT_MODEL", "google/gemini-2.5-pro")
+
+
+def default_config() -> dict:
+    return {
+        "api_url": os.getenv(
+            "ARTHERA_API_URL",
+            "http://localhost:8000",
+        ),
+        "local_url": "http://localhost:8000",
+        "ollama_url": os.getenv("OLLAMA_URL", "http://localhost:11434"),
+        # Which backend serves a bare, unprefixed model name. Only consulted
+        # for names that do not name their own provider ("qwen2.5:7b"); a
+        # prefixed id like "google/gemini-2.5-pro" always wins.
+        "local_provider": os.getenv("ARIA_LLM_PROVIDER", "ollama"),
+        "provider_fallback": "configured",
+        "model": DEFAULT_MODEL,
+        "thinking_mode": "auto",
+        "watchlist": ["AAPL", "MSFT", "GOOGL", "TSLA", "NVDA"],
+        "auth_token": None,
+        "user_id": None,
+        "last_session_id": None,
+        "auto_save_sessions": True,
+        "auto_compact_context": True,
+        "auto_compact_threshold": 0.78,
+        "command_policy": "safe",
+        "permission_mode": "workspace-write",
+        "network_enabled": True,
+        "data_sharing": False,
+        "feedback_upload": False,
+        "write_policy": "desktop_only",
+        "lsp_autocheck": False,
+        "input_style": "panel",
+        "input_theme": "auto",
+        "response_footer": "compact",
+        "report_agent_timeout": 40.0,
+        "report_synthesis_timeout": 20.0,
+        "local_mode": False,
+        "conversation_history": [],
+        "ui_lang": "",
+    }
+
+
+def runtime_paths():
+    return resolve_paths()