brawny 0.1.13__py3-none-any.whl

brawny/cli/commands/networks.py

@@ -0,0 +1,253 @@
+"""Network management CLI commands (Brownie-compatible).
+
+Usage:
+    brawny networks list
+    brawny networks add <type> <id> <settings...>
+    brawny networks delete <id>
+
+These commands manage ~/.brawny/network-config.yaml (Brownie-compatible format).
+This is separate from the project-level config.yaml networks section.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+import yaml
+
+
+def _get_config_path() -> Path:
+    """Get user network config path."""
+    return Path.home() / ".brawny" / "network-config.yaml"
+
+
+def _load_config() -> dict[str, Any]:
+    """Load user network config."""
+    path = _get_config_path()
+    if path.exists():
+        with open(path) as f:
+            return yaml.safe_load(f) or {}
+    return {"live": [], "development": []}
+
+
+def _save_config(config: dict[str, Any]) -> None:
+    """Save user network config."""
+    path = _get_config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+
+@click.group("networks")
+def networks_cli() -> None:
+    """Manage Brownie-compatible network configurations.
+
+    These networks are stored in ~/.brawny/network-config.yaml and used
+    by `network.connect()` in scripts and console.
+    """
+    pass
+
+
+def _redact_api_keys(url: str) -> str:
+    """Redact API keys from URLs for safe display.
+
+    Matches common patterns:
+    - /v2/abc123... → /v2/abc1...
+    - /v3/abc123... → /v3/abc1...
+    - ?apikey=... → ?apikey=...
+    """
+    import re
+    # Redact Alchemy/Infura-style path keys (show first 4 chars)
+    url = re.sub(r"(/v[23]/)([a-zA-Z0-9_-]{4})([a-zA-Z0-9_-]+)", r"\1\2...", url)
+    # Redact query param API keys
+    url = re.sub(r"([\?&]api[_-]?key=)([a-zA-Z0-9_-]{4})([a-zA-Z0-9_-]+)", r"\1\2...", url, flags=re.I)
+    return url
+
+
+@networks_cli.command("list")
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed info (redacts API keys)")
+def list_networks(verbose: bool) -> None:
+    """List available networks."""
+    from brawny.networks.config import load_networks
+
+    networks = load_networks()
+
+    live = [(n.id, n) for n in networks.values() if not n.is_development]
+    dev = [(n.id, n) for n in networks.values() if n.is_development]
+
+    click.echo("\nLive Networks:")
+    if not live:
+        click.echo("  (none configured)")
+    for net_id, net in sorted(live):
+        if verbose:
+            # Redact API keys in displayed hosts for security
+            redacted_hosts = [_redact_api_keys(h) for h in net.hosts[:2]]
+            hosts_str = ", ".join(redacted_hosts)
+            if len(net.hosts) > 2:
+                hosts_str += f" (+{len(net.hosts) - 2} more)"
+            click.echo(f"  {net_id}: chainid={net.chainid} hosts=[{hosts_str}]")
+        else:
+            click.echo(f"  - {net_id} (chainid: {net.chainid})")
+
+    click.echo("\nDevelopment Networks:")
+    for net_id, net in sorted(dev):
+        fork_info = " (fork)" if net.is_fork else ""
+        if verbose:
+            click.echo(f"  {net_id}: cmd={net.cmd} port={net.cmd_settings.get('port', 8545)}{fork_info}")
+        else:
+            click.echo(f"  - {net_id}{fork_info}")
+
+
+@networks_cli.command("add")
+@click.argument("network_type", type=click.Choice(["live", "development"]))
+@click.argument("network_id")
+@click.argument("settings", nargs=-1)
+def add_network(network_type: str, network_id: str, settings: tuple[str, ...]) -> None:
+    """Add a new network to ~/.brawny/network-config.yaml.
+
+    Examples:
+
+        brawny networks add live mainnet-custom host=https://... chainid=1
+
+        # Multiple hosts for failover (RPC pool):
+        brawny networks add live mainnet host=https://eth.llamarpc.com host=https://eth-mainnet.g.alchemy.com/v2/KEY chainid=1
+
+        brawny networks add development my-fork cmd=anvil port=9545 fork=mainnet
+    """
+    from brawny.networks.config import load_networks
+
+    # Check if network ID already exists
+    existing = load_networks()
+    if network_id in existing:
+        raise click.ClickException(
+            f"Network '{network_id}' already exists. "
+            f"Delete it first with: brawny networks delete {network_id}"
+        )
+
+    config = _load_config()
+
+    # Parse key=value settings - collect repeated keys as lists
+    params: dict[str, Any] = {}
+    multi_keys: dict[str, list[str]] = {}  # For repeated keys like host=...
+
+    for s in settings:
+        if "=" not in s:
+            raise click.ClickException(f"Invalid: {s}. Use key=value format.")
+        key, value_str = s.split("=", 1)
+
+        # Special handling for 'host' - can be repeated for multi-host
+        if key == "host":
+            multi_keys.setdefault("host", []).append(value_str)
+            continue
+
+        # Parse integers and floats for other keys
+        value: Any = value_str
+        try:
+            value = int(value_str)
+        except ValueError:
+            try:
+                value = float(value_str)
+            except ValueError:
+                pass
+        params[key] = value
+
+    # Convert multi-host to single or list as needed
+    if "host" in multi_keys:
+        hosts = multi_keys["host"]
+        params["host"] = hosts if len(hosts) > 1 else hosts[0]
+
+    if network_type == "live":
+        if "host" not in params:
+            raise click.ClickException("Live networks require 'host'")
+        if "chainid" not in params:
+            raise click.ClickException("Live networks require 'chainid'")
+
+        # Ensure live section exists with at least one group
+        if "live" not in config or not config["live"]:
+            config["live"] = [{"name": "Custom", "networks": []}]
+
+        # Find Custom group or use first group
+        group = config["live"][0]
+        for g in config["live"]:
+            if g.get("name") == "Custom":
+                group = g
+                break
+
+        net_config = {"id": network_id, **params}
+        group.setdefault("networks", []).append(net_config)
+
+    else:  # development
+        if "cmd" not in params:
+            raise click.ClickException("Development networks require 'cmd'")
+
+        # Separate cmd_settings from top-level params
+        cmd_keys = {"port", "fork", "fork_block", "accounts", "balance", "chain_id", "mnemonic", "block_time"}
+        cmd_settings = {k: params.pop(k) for k in list(params.keys()) if k in cmd_keys}
+
+        net_config: dict[str, Any] = {
+            "id": network_id,
+            "host": params.pop("host", "http://127.0.0.1"),
+            "cmd": params.pop("cmd"),
+            **params,
+        }
+        if cmd_settings:
+            net_config["cmd_settings"] = cmd_settings
+
+        config.setdefault("development", []).append(net_config)
+
+    _save_config(config)
+    click.echo(f"Added {network_type} network: {network_id}")
+
+
+@networks_cli.command("delete")
+@click.argument("network_id")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation")
+def delete_network(network_id: str, force: bool) -> None:
+    """Delete a network from user config."""
+    # Don't allow deleting built-in defaults
+    builtin = {"development", "mainnet-fork"}
+    if network_id in builtin:
+        raise click.ClickException(
+            f"Cannot delete built-in network '{network_id}'. "
+            "You can override it by adding a network with the same ID."
+        )
+
+    config = _load_config()
+    found = False
+
+    # Check live networks
+    for group in config.get("live", []):
+        networks = group.get("networks", [])
+        for i, net in enumerate(networks):
+            if net["id"] == network_id:
+                if not force:
+                    click.confirm(f"Delete '{network_id}'?", abort=True)
+                networks.pop(i)
+                found = True
+                break
+        if found:
+            break
+
+    # Check development networks
+    if not found:
+        dev = config.get("development", [])
+        for i, net in enumerate(dev):
+            if net["id"] == network_id:
+                if not force:
+                    click.confirm(f"Delete '{network_id}'?", abort=True)
+                dev.pop(i)
+                found = True
+                break
+
+    if not found:
+        raise click.ClickException(f"Network '{network_id}' not found in user config")
+
+    _save_config(config)
+    click.echo(f"Deleted: {network_id}")
+
+
+def register(main) -> None:
+    """Register networks command with main CLI."""
+    main.add_command(networks_cli)

brawny/cli/commands/run.py

@@ -0,0 +1,249 @@
+"""Runner command."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+import click
+
+
+@click.command()
+@click.option("--once", is_flag=True, help="Process once and exit")
+@click.option("--workers", type=int, help="Worker count override")
+@click.option("--dry-run", is_flag=True, help="Create intents but don't execute")
+@click.option(
+    "--jobs-module",
+    "jobs_modules",
+    multiple=True,
+    help="Additional job module(s) to load",
+)
+@click.option("--config", "config_path", default="./config.yaml", help="Path to config.yaml")
+@click.option(
+    "--no-strict",
+    is_flag=True,
+    help="Don't exit on job validation errors (warn only)",
+)
+def start(
+    once: bool,
+    workers: int | None,
+    dry_run: bool,
+    jobs_modules: tuple[str, ...],
+    config_path: str,
+    no_strict: bool,
+) -> None:
+    """Start the brawny daemon (job runner and transaction executor)."""
+    from brawny.config import Config
+    from brawny.daemon import BrawnyDaemon, RuntimeOverrides
+    from brawny.logging import setup_logging, set_runtime_logging, get_logger
+    from brawny.model.enums import LogFormat
+    from brawny.metrics import (
+        PrometheusMetricsProvider,
+        set_metrics_provider,
+        start_metrics_server,
+    )
+    from brawny.model.enums import IntentStatus
+    from brawny.scheduler.shutdown import ShutdownContext, ShutdownHandler
+
+    if not config_path or not os.path.exists(config_path):
+        click.echo(
+            f"Config file is required for run and was not found: {config_path}",
+            err=True,
+        )
+        sys.exit(1)
+
+    config = Config.from_yaml(config_path)
+    config, overrides_applied = config.apply_env_overrides()
+
+    log_level = os.environ.get("BRAWNY_LOG_LEVEL", "INFO")
+    # Start in startup mode (human-readable, warnings only)
+    setup_logging(log_level, LogFormat.JSON, config.chain_id, mode="startup")
+
+    click.echo(f"Config: {config_path}")
+    metrics_bind = f"127.0.0.1:{config.metrics_port}"
+    try:
+        provider = PrometheusMetricsProvider()
+        set_metrics_provider(provider)
+        start_metrics_server(metrics_bind, provider)
+        click.echo(f"Metrics: http://{metrics_bind}/metrics")
+    except Exception as e:
+        click.echo(click.style(f"Failed to start metrics server: {e}", fg="red"), err=True)
+        sys.exit(1)
+
+    # Build runtime overrides
+    runtime_overrides = RuntimeOverrides(
+        dry_run=dry_run,
+        once=once,
+        worker_count=workers,
+        strict_validation=not no_strict,
+    )
+
+    click.echo("Starting brawny runner...")
+    click.echo(f"  Chain ID: {config.chain_id}")
+    if config.rpc_groups:
+        from brawny.config.routing import resolve_default_group
+
+        default_group = resolve_default_group(config)
+        click.echo(f"  RPC Default Group: {default_group}")
+        click.echo(f"  RPC Endpoints: {len(config.rpc_groups[default_group].endpoints)}")
+    click.echo(f"  Workers: {workers or config.worker_count}")
+    if dry_run:
+        click.echo("  Mode: DRY RUN (no transactions)")
+    if once:
+        click.echo("  Mode: Single iteration")
+
+    # Initialize daemon
+    daemon = BrawnyDaemon(
+        config,
+        overrides=runtime_overrides,
+        extra_modules=list(jobs_modules),
+    )
+
+    validation_errors, routing_errors, startup_messages = daemon.initialize()
+
+    # Show signers
+    if daemon.keystore:
+        signers = daemon.keystore.list_keys()
+        if signers:
+            click.echo(f"  Signers: {len(signers)} ({', '.join(signers)})")
+
+    # Show startup warnings/errors
+    for msg in startup_messages:
+        color = "yellow" if msg.level == "warning" else "red"
+        symbol = "\u26a0" if msg.level == "warning" else "\u2717"
+        text = f"  {symbol} {msg.message}"
+        if msg.fix:
+            text += click.style(f" \u2192 {msg.fix}", dim=True)
+        click.echo(click.style(text, fg=color))
+
+    # Report validation errors
+    if validation_errors:
+        click.echo("")
+        click.echo(click.style("Job validation errors:", fg="red", bold=True))
+        for job_id, errors in validation_errors.items():
+            click.echo(f"  {job_id}:")
+            for error in errors:
+                click.echo(f"    - {error}")
+
+        click.echo("")
+        click.echo(click.style("Tip:", dim=True) + " Remove the @job decorator to hide incomplete jobs from discovery.")
+
+        if runtime_overrides.strict_validation:
+            click.echo("")
+            click.echo(
+                "Exiting due to validation errors. Use --no-strict to continue anyway.",
+                err=True,
+            )
+            sys.exit(1)
+        else:
+            click.echo("")
+            click.echo(
+                click.style("Continuing despite validation errors (--no-strict)", fg="yellow"),
+            )
+
+    # Report routing errors
+    if routing_errors:
+        click.echo("")
+        click.echo(click.style("Job routing configuration errors:", fg="red", bold=True))
+        for error in routing_errors:
+            click.echo(f"  - {error}")
+
+        if runtime_overrides.strict_validation:
+            click.echo("")
+            click.echo(
+                "Exiting due to routing errors. Use --no-strict to continue anyway.",
+                err=True,
+            )
+            sys.exit(1)
+        else:
+            click.echo("")
+            click.echo(
+                click.style("Continuing despite routing errors (--no-strict)", fg="yellow"),
+            )
+
+    # Show discovered jobs
+    jobs = daemon.jobs
+    if not jobs:
+        click.echo("  Jobs discovered: 0")
+    else:
+        click.echo(f"  Jobs discovered: {len(jobs)}")
+        job_items = list(jobs.items())[:20]
+        for job_id, job in job_items:
+            click.echo(f"    - {job_id}: {job.name}")
+        if len(jobs) > 20:
+            click.echo(click.style(f"    ... and {len(jobs) - 20} more", dim=True))
+
+    # Check for orphaned jobs
+    db = daemon.db
+    db_jobs = db.list_all_jobs()
+    discovered_job_ids = set(jobs.keys())
+    orphaned = [j for j in db_jobs if j.job_id not in discovered_job_ids and j.enabled]
+    if orphaned:
+        click.echo("")
+        click.echo(
+            click.style("Orphaned jobs", fg="yellow", bold=True)
+            + click.style(" (in database but not discovered):", fg="yellow")
+        )
+        for j in orphaned:
+            click.echo(click.style(f"    - {j.job_id}", fg="yellow"))
+        click.echo(click.style("  These won't run. Check: --jobs-module or ./jobs/", dim=True))
+
+    # Warn if no jobs registered
+    if not jobs:
+        pending_intents = db.get_intents_by_status(
+            IntentStatus.PENDING.value, chain_id=config.chain_id
+        )
+        pending_count = len(pending_intents)
+
+        click.echo("")
+        if pending_count > 0:
+            click.echo(
+                click.style(f"No jobs registered but {pending_count} pending intent(s) found.", fg="yellow"),
+            )
+            click.echo(
+                click.style("  Continuing to monitor pending transactions.", dim=True),
+            )
+        else:
+            modules = list(jobs_modules)
+            if modules:
+                click.echo(
+                    click.style("No jobs registered.", fg="yellow")
+                    + " Ensure --jobs-module values are correct and jobs use @job.",
+                )
+            else:
+                click.echo(
+                    click.style("No jobs registered.", fg="yellow")
+                    + " Add jobs under ./jobs or use --jobs-module.",
+                )
+
+    click.echo("\n--- Starting brawny ---")
+
+    # Switch to runtime logging (full structured JSON)
+    set_runtime_logging()
+    log = get_logger(__name__)
+
+    # Create shutdown handler
+    nonce_manager = daemon._executor.nonce_manager if daemon._executor else None
+    shutdown_handler = ShutdownHandler(config, db, daemon.rpc, nonce_manager=nonce_manager)
+    shutdown_handler.register_callback(lambda: daemon.stop(timeout=5.0))
+
+    with ShutdownContext(shutdown_handler):
+        if once:
+            try:
+                daemon.run(blocking=True)
+                click.echo("Single iteration complete.")
+            except Exception as e:
+                click.echo(f"Error: {e}", err=True)
+                sys.exit(1)
+        else:
+            click.echo("Polling for new blocks... (Ctrl+C to stop)")
+            try:
+                daemon.run(blocking=True)
+            except KeyboardInterrupt:
+                click.echo("\nShutdown requested...")
+
+    click.echo("Shutdown complete.")
+
+
+def register(main) -> None:
+    main.add_command(start)