brawny 0.1.13__py3-none-any.whl

brawny/cli/commands/jobs.py

@@ -0,0 +1,308 @@
+"""Jobs management commands."""
+
+from __future__ import annotations
+
+import click
+
+
+@click.group()
+def jobs() -> None:
+    """Manage jobs."""
+    pass
+
+
+@jobs.command("list")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def jobs_list(config_path: str | None) -> None:
+    """List all registered jobs.
+
+    Shows jobs discovered from code, with status from database.
+    """
+    # Suppress logging FIRST before any brawny imports
+    from brawny.cli.helpers import suppress_logging
+
+    suppress_logging()
+
+    from brawny.cli.helpers import discover_jobs_for_cli, get_config, get_db
+    from brawny.jobs.registry import get_registry
+
+    # Discover jobs from code (same logic as brawny start)
+    config = get_config(config_path)
+    discover_jobs_for_cli(config)
+
+    registry = get_registry()
+    code_jobs = {job.job_id: job for job in registry.get_all()}
+
+    # Get DB status for discovered jobs
+    db = get_db(config_path)
+    try:
+        db_jobs = {j.job_id: j for j in db.list_all_jobs()}
+
+        if not code_jobs:
+            click.echo(click.style("No jobs discovered.", dim=True))
+            click.echo("  Check: ./jobs/ directory or use --jobs-module.")
+
+            # Show orphaned jobs if any
+            if db_jobs:
+                click.echo()
+                click.echo(click.style("Jobs in database (not discovered):", fg="yellow"))
+                for job_id, job in sorted(db_jobs.items()):
+                    status = "enabled" if job.enabled else "disabled"
+                    click.echo(f"    - {job_id} ({status})")
+            return
+
+        click.echo()
+        for job_id in sorted(code_jobs.keys()):
+            job = code_jobs[job_id]
+            db_job = db_jobs.get(job_id)
+
+            # Get interval from code (authoritative)
+            interval = str(job.check_interval_blocks)
+
+            # Get enabled status from DB, default to True for new jobs
+            enabled = db_job.enabled if db_job else True
+
+            # Status indicator
+            if enabled:
+                status = click.style("✓ enabled ", fg="green")
+            else:
+                status = click.style("✗ disabled", fg="red")
+
+            click.echo(f"  {status}  {job_id}  {click.style(f'every {interval} blocks', dim=True)}")
+
+        click.echo()
+
+        # Warn about orphaned jobs (in DB but not discovered)
+        orphaned = set(db_jobs.keys()) - set(code_jobs.keys())
+        if orphaned:
+            click.echo(click.style(f"Warning: {len(orphaned)} job(s) in database but not discovered:", fg="yellow"))
+            for job_id in sorted(orphaned):
+                job = db_jobs[job_id]
+                status = "enabled" if job.enabled else "disabled"
+                click.echo(f"    - {job_id} ({status})")
+            click.echo()
+            click.echo("  To remove orphaned jobs from database:")
+            click.echo(click.style("    brawny jobs remove <job_id>", fg="cyan"))
+            click.echo()
+
+    finally:
+        db.close()
+
+
+@jobs.command("validate")
+@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")
+def jobs_validate(jobs_modules: tuple[str, ...], config_path: str) -> None:
+    """Validate job definitions including signer configuration."""
+    import os
+    import sys
+
+    from brawny.config import Config
+    from brawny.jobs.registry import get_registry
+    from brawny.jobs.discovery import auto_discover_jobs, discover_jobs
+    from brawny.jobs.job_validation import validate_all_jobs
+    from brawny.keystore import create_keystore
+
+    if not config_path or not os.path.exists(config_path):
+        click.echo(f"Config file not found: {config_path}", err=True)
+        sys.exit(1)
+
+    config = Config.from_yaml(config_path)
+    config, _ = config.apply_env_overrides()
+    registry = get_registry()
+    registry.clear()
+
+    modules = list(jobs_modules)
+    if modules:
+        discover_jobs(modules)
+    else:
+        auto_discover_jobs()
+    all_jobs = registry.get_all()
+
+    if not all_jobs:
+        click.echo("No jobs discovered.", err=True)
+        click.echo("  Add jobs under ./jobs or use --jobs-module", err=True)
+        sys.exit(1)
+
+    # Try to load keystore for signer validation
+    keystore = None
+    try:
+        keystore = create_keystore(
+            config.keystore_type,
+            keystore_path=config.keystore_path,
+            allowed_signers=[],
+        )
+    except Exception as e:
+        click.echo(click.style(f"Warning: Could not load keystore ({e})", fg="yellow"))
+        click.echo("  Signer validation will be skipped.")
+        click.echo()
+
+    click.echo(f"Validating {len(all_jobs)} job(s)...")
+    click.echo("-" * 50)
+
+    errors = validate_all_jobs({job.job_id: job for job in all_jobs}, keystore=keystore)
+
+    passed = 0
+    failed = 0
+    for job in all_jobs:
+        job_id = job.job_id
+        if job_id in errors:
+            click.echo(click.style(f"  ✗ {job_id}", fg="red"))
+            for error in errors[job_id]:
+                click.echo(f"      - {error}")
+            failed += 1
+        else:
+            click.echo(click.style(f"  ✓ {job_id}", fg="green"))
+            passed += 1
+
+    click.echo("-" * 50)
+    if failed > 0:
+        click.echo(click.style(f"{passed} passed, {failed} failed", fg="red"))
+        click.echo()
+        click.echo(click.style("Tip:", dim=True) + " Remove the @job decorator to hide incomplete jobs from discovery.")
+        sys.exit(1)
+    else:
+        click.echo(click.style(f"{passed} passed", fg="green"))
+
+
+@jobs.command("enable")
+@click.argument("job_id")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def jobs_enable(job_id: str, config_path: str | None) -> None:
+    """Enable a job."""
+    from brawny.cli.helpers import get_db
+
+    db = get_db(config_path)
+    try:
+        updated = db.set_job_enabled(job_id, True)
+        if updated:
+            click.echo(f"Job '{job_id}' enabled.")
+        else:
+            click.echo(f"Job '{job_id}' not found.", err=True)
+    finally:
+        db.close()
+
+
+@jobs.command("disable")
+@click.argument("job_id")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def jobs_disable(job_id: str, config_path: str | None) -> None:
+    """Disable a job."""
+    from brawny.cli.helpers import get_db
+
+    db = get_db(config_path)
+    try:
+        updated = db.set_job_enabled(job_id, False)
+        if updated:
+            click.echo(f"Job '{job_id}' disabled.")
+        else:
+            click.echo(f"Job '{job_id}' not found.", err=True)
+    finally:
+        db.close()
+
+
+@jobs.command("remove")
+@click.argument("job_id")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+@click.option("--force", "-f", is_flag=True, help="Skip confirmation prompt")
+def jobs_remove(job_id: str, config_path: str | None, force: bool) -> None:
+    """Remove a job from the database.
+
+    Use this to clean up orphaned jobs (jobs in database but not discovered from code).
+    """
+    from brawny.cli.helpers import get_db
+
+    db = get_db(config_path)
+    try:
+        # Check if job exists
+        job = db.get_job(job_id)
+        if not job:
+            click.echo(f"Job '{job_id}' not found in database.", err=True)
+            return
+
+        # Confirm unless --force
+        if not force:
+            click.echo(f"This will remove job '{job_id}' and its key-value data from the database.")
+            if not click.confirm("Continue?"):
+                click.echo("Cancelled.")
+                return
+
+        deleted = db.delete_job(job_id)
+        if deleted:
+            click.echo(f"Job '{job_id}' removed.")
+        else:
+            click.echo(f"Failed to remove job '{job_id}'.", err=True)
+    finally:
+        db.close()
+
+
+@jobs.command("status")
+@click.argument("job_id")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def jobs_status(job_id: str, config_path: str | None) -> None:
+    """Show status for a job."""
+    from brawny.cli.helpers import get_db
+
+    db = get_db(config_path)
+    try:
+        job = db.get_job(job_id)
+        if not job:
+            click.echo(f"Job '{job_id}' not found.", err=True)
+            return
+        click.echo(f"\nJob: {job.job_id}")
+        click.echo("-" * 40)
+        click.echo(f"  Name: {job.job_name}")
+        click.echo(f"  Enabled: {job.enabled}")
+        click.echo(f"  Check Interval: {job.check_interval_blocks} blocks")
+        click.echo(f"  Last Checked Block: {job.last_checked_block_number or 'Never'}")
+        click.echo(f"  Last Triggered Block: {job.last_triggered_block_number or 'Never'}")
+        click.echo(f"  Created: {job.created_at}")
+        click.echo(f"  Updated: {job.updated_at}")
+        click.echo()
+    finally:
+        db.close()
+
+
+@jobs.command("run")
+@click.argument("job_id")
+@click.option("--at-block", type=int, help="Run check/build against this block")
+@click.option("--dry-run", is_flag=True, help="Run check only (skip build_intent)")
+@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")
+def jobs_run(
+    job_id: str,
+    at_block: int | None,
+    dry_run: bool,
+    jobs_modules: tuple[str, ...],
+    config_path: str,
+) -> None:
+    """Run check/build for a single job without sending transactions.
+
+    Developer utility for testing jobs locally.
+    """
+    # Import the implementation from job_dev
+    from brawny.cli.commands.job_dev import job_run as _job_run_impl
+    # Use Click's context to invoke the command
+    ctx = click.get_current_context()
+    ctx.invoke(
+        _job_run_impl,
+        job_id=job_id,
+        at_block=at_block,
+        dry_run=dry_run,
+        jobs_modules=jobs_modules,
+        config_path=config_path,
+    )
+
+
+def register(main) -> None:
+    main.add_command(jobs)

brawny/cli/commands/logs.py

@@ -0,0 +1,87 @@
+"""Job logs commands."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta
+
+import click
+
+
+@click.group()
+def logs() -> None:
+    """View and manage job logs."""
+    pass
+
+
+@logs.command("list")
+@click.option("--job", "job_id", help="Filter by job ID")
+@click.option("--latest", is_flag=True, help="Show only latest per job")
+@click.option("--limit", default=20, help="Max entries to show")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def list_logs(
+    job_id: str | None,
+    latest: bool,
+    limit: int,
+    as_json: bool,
+    config_path: str | None,
+) -> None:
+    """List job logs."""
+    from brawny.cli.helpers import suppress_logging
+
+    suppress_logging()
+
+    from brawny.cli.helpers import get_config, get_db
+    from brawny.db.ops import logs as log_ops
+
+    config = get_config(config_path)
+    db = get_db(config_path)
+
+    if latest:
+        entries = log_ops.list_latest_logs(db, config.chain_id)
+    elif job_id:
+        entries = log_ops.list_logs(db, config.chain_id, job_id, limit)
+    else:
+        entries = log_ops.list_all_logs(db, config.chain_id, limit)
+
+    if not entries:
+        click.echo("No logs found.")
+        return
+
+    if as_json:
+        click.echo(json.dumps(entries, default=str, indent=2))
+        return
+
+    for entry in entries:
+        ts = entry["ts"]
+        if isinstance(ts, datetime):
+            ts = ts.strftime("%Y-%m-%d %H:%M:%S")
+        level = entry["level"]
+        level_color = "yellow" if level == "warn" else ("red" if level == "error" else None)
+        level_str = click.style(f"({level})", fg=level_color) if level_color else f"({level})"
+        click.echo(f"[{ts}] {entry['job_id']} {level_str}: {entry['fields']}")
+
+
+@logs.command("cleanup")
+@click.option("--older-than", default=7, type=int, help="Delete logs older than N days")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def cleanup_logs(older_than: int, config_path: str | None) -> None:
+    """Delete old job logs."""
+    from brawny.cli.helpers import suppress_logging
+
+    suppress_logging()
+
+    from brawny.cli.helpers import get_config, get_db
+    from brawny.db.ops import logs as log_ops
+
+    config = get_config(config_path)
+    db = get_db(config_path)
+    cutoff = datetime.utcnow() - timedelta(days=older_than)
+    deleted = log_ops.delete_old_logs(db, config.chain_id, cutoff)
+    click.echo(f"Deleted {deleted} logs older than {older_than} days.")
+
+
+def register(main: click.Group) -> None:
+    """Register logs commands."""
+    main.add_command(logs)

brawny/cli/commands/maintenance.py

@@ -0,0 +1,182 @@
+"""Maintenance commands."""
+
+from __future__ import annotations
+
+import click
+
+from brawny.cli.helpers import get_config, get_db
+
+
+@click.command()
+def reconcile() -> None:
+    """Run nonce reconciliation."""
+    from brawny.config import get_config
+    from brawny.db import create_database
+    from brawny._rpc import RPCManager
+    from brawny.tx.nonce import NonceManager
+
+    click.echo("Running nonce reconciliation...")
+
+    config = get_config()
+    db = create_database(
+        config.database_url,
+        pool_size=config.database_pool_size,
+        pool_max_overflow=config.database_pool_max_overflow,
+        pool_timeout=config.database_pool_timeout_seconds,
+        circuit_breaker_failures=config.db_circuit_breaker_failures,
+        circuit_breaker_seconds=config.db_circuit_breaker_seconds,
+    )
+    db.connect()
+
+    try:
+        rpc = RPCManager.from_config(config)
+        nonce_manager = NonceManager(db, rpc, config.chain_id)
+        nonce_manager.reconcile()
+        click.echo("Nonce reconciliation complete.")
+
+    finally:
+        db.close()
+
+
+@click.command()
+@click.option("--older-than", default="30d", help="Delete intents older than (e.g., 30d)")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def cleanup(older_than: str, config_path: str | None) -> None:
+    """Clean up old data."""
+    if older_than.endswith("d"):
+        days = int(older_than[:-1])
+    else:
+        days = int(older_than)
+
+    db = get_db(config_path)
+    try:
+        deleted = db.cleanup_old_intents(days)
+        click.echo(f"Deleted {deleted} old intents.")
+    finally:
+        db.close()
+
+@click.command("audit-intents")
+@click.option("--max-age-seconds", type=int, default=None, help="Max age for sending intents")
+@click.option("--limit", default=100, help="Limit results")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def audit_intents(max_age_seconds: int | None, limit: int, config_path: str | None) -> None:
+    """Audit intent state invariants and report inconsistencies."""
+    from brawny.config import Config
+    from brawny.metrics import INTENT_STATE_INCONSISTENT, get_metrics
+
+    if config_path:
+        config = Config.from_yaml(config_path)
+        config, _ = config.apply_env_overrides()
+    else:
+        from brawny.config import get_config
+
+        config = get_config()
+
+    db = get_db(config_path)
+    try:
+        age_seconds = max_age_seconds or config.claim_timeout_seconds
+        issues = db.list_intent_inconsistencies(
+            max_age_seconds=age_seconds,
+            limit=limit,
+            chain_id=config.chain_id,
+        )
+        if not issues:
+            click.echo("No intent inconsistencies found.")
+            return
+
+        click.echo("\nIntent inconsistencies:")
+        click.echo("-" * 90)
+        click.echo(f"{'Intent ID':<38} {'Status':<12} {'Reason':<30}")
+        click.echo("-" * 90)
+        counts: dict[str, int] = {}
+        for issue in issues:
+            intent_id = str(issue["intent_id"])[:36]
+            status = issue.get("status", "")
+            reason = issue.get("reason", "")
+            counts[reason] = counts.get(reason, 0) + 1
+            click.echo(f"{intent_id:<38} {status:<12} {reason:<30}")
+
+        metrics = get_metrics()
+        for reason, count in counts.items():
+            metrics.counter(INTENT_STATE_INCONSISTENT).inc(
+                count,
+                chain_id=config.chain_id,
+                reason=reason,
+            )
+
+        click.echo(f"\n(Showing {len(issues)} of {limit} max)")
+    finally:
+        db.close()
+
+
+@click.command("repair-claims")
+@click.option("--older-than", type=int, default=10, help="Minutes threshold")
+@click.option("--execute", is_flag=True, help="Actually perform repair (dry-run by default)")
+@click.option("--limit", type=int, default=100, help="Max intents to repair")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def repair_claims(
+    older_than: int,
+    execute: bool,
+    limit: int,
+    config_path: str | None,
+) -> None:
+    """Release stuck CLAIMED intents with zero attempts."""
+    config = get_config(config_path)
+    db = get_db(config_path)
+    try:
+        if db.dialect == "sqlite":
+            query = """
+                SELECT i.intent_id, i.job_id, i.claimed_at
+                FROM tx_intents i
+                WHERE i.chain_id = ?
+                  AND i.status = 'claimed'
+                  AND (i.claimed_at IS NULL OR datetime(i.claimed_at) < datetime('now', ? || ' minutes'))
+                  AND NOT EXISTS (SELECT 1 FROM tx_attempts a WHERE a.intent_id = i.intent_id)
+                ORDER BY (i.claimed_at IS NOT NULL), i.claimed_at ASC
+                LIMIT ?
+            """
+            stuck = db.execute_returning(query, (config.chain_id, -older_than, limit))
+        else:
+            query = """
+                SELECT i.intent_id, i.job_id, i.claimed_at
+                FROM tx_intents i
+                WHERE i.chain_id = %s
+                  AND i.status = 'claimed'
+                  AND (i.claimed_at IS NULL OR i.claimed_at < NOW() - make_interval(mins => %s))
+                  AND NOT EXISTS (SELECT 1 FROM tx_attempts a WHERE a.intent_id = i.intent_id)
+                ORDER BY i.claimed_at ASC NULLS FIRST
+                LIMIT %s
+            """
+            stuck = db.execute_returning(query, (config.chain_id, older_than, limit))
+
+        if not stuck:
+            click.echo("No stuck claims found matching criteria.")
+            return
+
+        click.echo(f"Found {len(stuck)} stuck claims (no attempts):")
+        for row in stuck[:10]:
+            click.echo(
+                f"  - {row['intent_id']} (job={row['job_id']}, claimed={row['claimed_at']})"
+            )
+        if len(stuck) > 10:
+            click.echo(f"  ... and {len(stuck) - 10} more")
+
+        if not execute:
+            click.echo("\nDry-run mode. Use --execute to repair.")
+            return
+
+        repaired = 0
+        for row in stuck:
+            if db.release_intent_claim(row["intent_id"]):
+                repaired += 1
+
+        click.echo(f"\nRepaired {repaired}/{len(stuck)} intents.")
+    finally:
+        db.close()
+
+
+def register(main) -> None:
+    main.add_command(reconcile)
+    main.add_command(cleanup)
+    main.add_command(audit_intents)
+    main.add_command(repair_claims)

brawny/cli/commands/migrate.py

@@ -0,0 +1,51 @@
+"""Database migration commands."""
+
+from __future__ import annotations
+
+import click
+
+from brawny.cli.helpers import get_db
+
+
+@click.command()
+@click.option("--status", is_flag=True, help="Show migration status only")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def migrate(status: bool, config_path: str | None) -> None:
+    """Run database migrations."""
+    from brawny.db.migrate import Migrator, verify_critical_schema
+
+    db = get_db(config_path)
+    try:
+        migrator = Migrator(db)
+
+        if status:
+            migrations = migrator.status()
+            if not migrations:
+                click.echo("No migrations found.")
+                return
+
+            click.echo("\nMigration Status:")
+            click.echo("-" * 60)
+            for m in migrations:
+                status_icon = "[x]" if m["applied"] else "[ ]"
+                applied = f" ({m['applied_at']})" if m["applied_at"] else ""
+                click.echo(f"  {status_icon} {m['version']} - {m['filename']}{applied}")
+            click.echo()
+        else:
+            pending = migrator.pending()
+            if not pending:
+                verify_critical_schema(db)
+                click.echo("No pending migrations.")
+                return
+
+            click.echo(f"Running {len(pending)} migration(s)...")
+            applied = migrator.migrate()
+            for m in applied:
+                click.echo(f"  Applied: {m.version} - {m.filename}")
+            click.echo(f"\nSuccessfully applied {len(applied)} migration(s).")
+    finally:
+        db.close()
+
+
+def register(main) -> None:
+    main.add_command(migrate)