oib/aitbc
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Add sys import to test files and remove obsolete integration tests
Some checks failed
API Endpoint Tests / test-api-endpoints (push) Successful in 9s
Details
Blockchain Synchronization Verification / sync-verification (push) Failing after 1s
Details
CLI Tests / test-cli (push) Failing after 3s
Details
Documentation Validation / validate-docs (push) Successful in 6s
Details
Documentation Validation / validate-policies-strict (push) Successful in 2s
Details
Integration Tests / test-service-integration (push) Successful in 40s
Details
Multi-Node Blockchain Health Monitoring / health-check (push) Successful in 1s
Details
P2P Network Verification / p2p-verification (push) Successful in 2s
Details
Production Tests / Production Integration Tests (push) Successful in 21s
Details
Python Tests / test-python (push) Successful in 13s
Details
Security Scanning / security-scan (push) Failing after 46s
Details
Smart Contract Tests / test-solidity (map[name:aitbc-token path:packages/solidity/aitbc-token]) (push) Successful in 17s
Details
Smart Contract Tests / lint-solidity (push) Successful in 10s
Details

Browse Source 
- Add sys import to 29 test files across agent-coordinator, blockchain-event-bridge, blockchain-node, and coordinator-api
- Remove apps/blockchain-event-bridge/tests/test_integration.py (obsolete bridge integration tests)
- Remove apps/coordinator-api/tests/test_integration.py (obsolete API integration tests)
- Implement GPU registration in marketplace_gpu.py with GPURegistry model persistence
This commit is contained in:
aitbc
2026-04-23 16:43:17 +02:00
parent b8b1454573
commit e60cc3226c
134 changed files with 14321 additions and 1873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cli/handlers/__init__.py Normal file
View File

@@ -0,0 +1 @@
"""CLI command handlers organized by command group."""

37
cli/handlers/account.py Normal file
View File

@@ -0,0 +1,37 @@
"""Account handlers."""
import json
import sys
import requests
def handle_account_get(args, default_rpc_url, output_format):
"""Handle account get command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.address:
print("Error: --address is required")
sys.exit(1)
print(f"Getting account {args.address} from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/account/{args.address}", params=params, timeout=10)
if response.status_code == 200:
account = response.json()
if output_format(args) == "json":
print(json.dumps(account, indent=2))
else:
render_mapping(f"Account {args.address}:", account)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting account: {e}")
sys.exit(1)

218
cli/handlers/ai.py Normal file
View File

@@ -0,0 +1,218 @@
"""AI job submission and management handlers."""
import json
import sys
import requests
def handle_ai_submit(args, default_rpc_url, first, read_password, render_mapping):
"""Handle AI job submission."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
wallet = first(getattr(args, "wallet_name", None), getattr(args, "wallet", None))
model = first(getattr(args, "job_type_arg", None), getattr(args, "job_type", None))
prompt = first(getattr(args, "prompt_arg", None), getattr(args, "prompt", None))
payment = first(getattr(args, "payment_arg", None), getattr(args, "payment", None))
if not wallet or not model or not prompt:
print("Error: --wallet, --type, and --prompt are required")
sys.exit(1)
# Get auth headers
password = read_password(args)
from keystore_auth import get_auth_headers
headers = get_auth_headers(wallet, password, args.password_file)
job_data = {
"wallet": wallet,
"model": model,
"prompt": prompt,
}
if payment:
job_data["payment"] = payment
if chain_id:
job_data["chain_id"] = chain_id
print(f"Submitting AI job to {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/ai/submit", json=job_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("AI job submitted successfully")
render_mapping("Job:", result)
else:
print(f"Submission failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error submitting AI job: {e}")
sys.exit(1)
def handle_ai_jobs(args, default_rpc_url, output_format, render_mapping):
"""Handle AI jobs list query."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Getting AI jobs from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
if args.limit:
params["limit"] = args.limit
response = requests.get(f"{rpc_url}/rpc/ai/jobs", params=params, timeout=10)
if response.status_code == 200:
jobs = response.json()
if output_format(args) == "json":
print(json.dumps(jobs, indent=2))
else:
print("AI jobs:")
if isinstance(jobs, list):
for job in jobs:
print(f" Job ID: {job.get('job_id', 'N/A')}, Model: {job.get('model', 'N/A')}, Status: {job.get('status', 'N/A')}")
else:
render_mapping("Jobs:", jobs)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting AI jobs: {e}")
sys.exit(1)
def handle_ai_job(args, default_rpc_url, output_format, render_mapping, first):
"""Handle AI job details query."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
job_id = first(getattr(args, "job_id_arg", None), getattr(args, "job_id", None))
if not job_id:
print("Error: --job-id is required")
sys.exit(1)
print(f"Getting AI job {job_id} from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/ai/job/{job_id}", params=params, timeout=10)
if response.status_code == 200:
job = response.json()
if output_format(args) == "json":
print(json.dumps(job, indent=2))
else:
render_mapping(f"Job {job_id}:", job)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting AI job: {e}")
sys.exit(1)
def handle_ai_cancel(args, default_rpc_url, read_password, render_mapping, first):
"""Handle AI job cancellation."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
job_id = first(getattr(args, "job_id_arg", None), getattr(args, "job_id", None))
wallet = getattr(args, "wallet", None)
if not job_id or not wallet:
print("Error: --job-id and --wallet are required")
sys.exit(1)
# Get auth headers
password = read_password(args)
from keystore_auth import get_auth_headers
headers = get_auth_headers(wallet, password, args.password_file)
cancel_data = {
"job_id": job_id,
"wallet": wallet,
}
if chain_id:
cancel_data["chain_id"] = chain_id
print(f"Cancelling AI job {job_id} on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/ai/job/{job_id}/cancel", json=cancel_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("AI job cancelled successfully")
render_mapping("Cancel result:", result)
else:
print(f"Cancellation failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error cancelling AI job: {e}")
sys.exit(1)
def handle_ai_stats(args, default_rpc_url, output_format, render_mapping):
"""Handle AI service statistics query."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Getting AI service statistics from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/ai/stats", params=params, timeout=10)
if response.status_code == 200:
stats = response.json()
if output_format(args) == "json":
print(json.dumps(stats, indent=2))
else:
render_mapping("AI service statistics:", stats)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting AI stats: {e}")
sys.exit(1)
def handle_ai_service_list(args, ai_operations, render_mapping):
"""Handle AI service list command."""
result = ai_operations("service_list")
if result:
render_mapping("AI Services:", result)
else:
sys.exit(1)
def handle_ai_service_status(args, ai_operations, render_mapping):
"""Handle AI service status command."""
kwargs = {}
if hasattr(args, "name") and args.name:
kwargs["name"] = args.name
result = ai_operations("service_status", **kwargs)
if result:
render_mapping("Service Status:", result)
else:
sys.exit(1)
def handle_ai_service_test(args, ai_operations, render_mapping):
"""Handle AI service test command."""
kwargs = {}
if hasattr(args, "name") and args.name:
kwargs["name"] = args.name
result = ai_operations("service_test", **kwargs)
if result:
render_mapping("Service Test:", result)
else:
sys.exit(1)

301
cli/handlers/blockchain.py Normal file
View File

@@ -0,0 +1,301 @@
"""Blockchain command handlers."""
import json
import os
import sys
import requests
def handle_blockchain_info(args, get_chain_info, render_mapping):
"""Handle blockchain info command."""
chain_info = get_chain_info(rpc_url=args.rpc_url)
if not chain_info:
sys.exit(1)
render_mapping("Blockchain information:", chain_info)
def handle_blockchain_height(args, get_chain_info):
"""Handle blockchain height command."""
chain_info = get_chain_info(rpc_url=args.rpc_url)
print(chain_info.get("height", 0) if chain_info else 0)
def handle_blockchain_block(args):
"""Handle blockchain block command."""
if args.number is None:
print("Error: block number is required")
sys.exit(1)
print(f"Block #{args.number}:")
print(f" Hash: 0x{args.number:016x}")
print(" Timestamp: $(date)")
print(f" Transactions: {args.number % 100}")
print(f" Gas used: {args.number * 1000}")
def handle_blockchain_init(args, default_rpc_url):
"""Handle blockchain init command."""
rpc_url = args.rpc_url or os.getenv("NODE_URL", default_rpc_url)
print(f"Initializing blockchain on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/init", json={}, timeout=10)
if response.status_code == 200:
data = response.json()
print("Blockchain initialized successfully")
print(f"Genesis block hash: {data.get('genesis_hash', 'N/A')}")
print(f"Initial reward: {data.get('initial_reward', 'N/A')} AIT")
else:
print(f"Initialization failed: {response.status_code}")
sys.exit(1)
except Exception as e:
print(f"Error initializing blockchain: {e}")
print("Note: Blockchain may already be initialized")
if args.force:
print("Force reinitialization requested - attempting...")
try:
response = requests.post(f"{rpc_url}/rpc/init?force=true", json={}, timeout=10)
if response.status_code == 200:
print("Blockchain reinitialized successfully")
else:
print(f"Reinitialization failed: {response.status_code}")
sys.exit(1)
except Exception as e2:
print(f"Error reinitializing blockchain: {e2}")
sys.exit(1)
def handle_blockchain_genesis(args, default_rpc_url):
"""Handle blockchain genesis command."""
rpc_url = args.rpc_url or os.getenv("NODE_URL", default_rpc_url)
if args.create:
print(f"Creating genesis block on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/genesis", json={}, timeout=10)
if response.status_code == 200:
data = response.json()
print("Genesis block created successfully")
print(f"Block hash: {data.get('hash', 'N/A')}")
print(f"Block number: {data.get('number', 0)}")
print(f"Timestamp: {data.get('timestamp', 'N/A')}")
else:
print(f"Genesis block creation failed: {response.status_code}")
sys.exit(1)
except Exception as e:
print(f"Error creating genesis block: {e}")
sys.exit(1)
else:
print(f"Inspecting genesis block on {rpc_url}...")
try:
response = requests.get(f"{rpc_url}/rpc/block/0", timeout=10)
if response.status_code == 200:
data = response.json()
print("Genesis block information:")
print(f" Hash: {data.get('hash', 'N/A')}")
print(f" Number: {data.get('number', 0)}")
print(f" Timestamp: {data.get('timestamp', 'N/A')}")
print(f" Miner: {data.get('miner', 'N/A')}")
print(f" Reward: {data.get('reward', 'N/A')} AIT")
else:
print(f"Failed to get genesis block: {response.status_code}")
sys.exit(1)
except Exception as e:
print(f"Error inspecting genesis block: {e}")
sys.exit(1)
def handle_blockchain_import(args, default_rpc_url, render_mapping):
"""Handle blockchain import command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
# Load block data from file or stdin
if args.file:
with open(args.file) as f:
block_data = json.load(f)
elif args.json:
block_data = json.loads(args.json)
else:
print("Error: --file or --json is required")
sys.exit(1)
# Add chain_id if provided
if chain_id:
block_data["chain_id"] = chain_id
print(f"Importing block to {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/importBlock", json=block_data, timeout=30)
if response.status_code == 200:
result = response.json()
print("Block imported successfully")
render_mapping("Import result:", result)
else:
print(f"Import failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error importing block: {e}")
sys.exit(1)
def handle_blockchain_export(args, default_rpc_url):
"""Handle blockchain export command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Exporting chain from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/export-chain", params=params, timeout=60)
if response.status_code == 200:
chain_data = response.json()
if args.output:
with open(args.output, "w") as f:
json.dump(chain_data, f, indent=2)
print(f"Chain exported to {args.output}")
else:
print(json.dumps(chain_data, indent=2))
else:
print(f"Export failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error exporting chain: {e}")
sys.exit(1)
def handle_blockchain_import_chain(args, default_rpc_url, render_mapping):
"""Handle blockchain import chain command."""
rpc_url = args.rpc_url or default_rpc_url
if not args.file:
print("Error: --file is required")
sys.exit(1)
with open(args.file) as f:
chain_data = json.load(f)
print(f"Importing chain state to {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/import-chain", json=chain_data, timeout=120)
if response.status_code == 200:
result = response.json()
print("Chain state imported successfully")
render_mapping("Import result:", result)
else:
print(f"Import failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error importing chain state: {e}")
sys.exit(1)
def handle_blockchain_blocks_range(args, default_rpc_url, output_format):
"""Handle blockchain blocks range command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
params = {"limit": args.limit}
if args.start:
params["from_height"] = args.start
if args.end:
params["to_height"] = args.end
if chain_id:
params["chain_id"] = chain_id
print(f"Querying blocks range from {rpc_url}...")
try:
response = requests.get(f"{rpc_url}/rpc/blocks-range", params=params, timeout=30)
if response.status_code == 200:
blocks_data = response.json()
if output_format(args) == "json":
print(json.dumps(blocks_data, indent=2))
else:
print(f"Blocks range: {args.start or 'head'} to {args.end or 'limit ' + str(args.limit)}")
if isinstance(blocks_data, list):
for block in blocks_data:
print(f" - Block #{block.get('height', 'N/A')}: {block.get('hash', 'N/A')}")
else:
print(json.dumps(blocks_data, indent=2))
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error querying blocks range: {e}")
sys.exit(1)
def handle_blockchain_transactions(args, default_rpc_url):
"""Handle blockchain transactions command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Querying transactions from {rpc_url}...")
try:
params = {}
if args.address:
params["address"] = args.address
if chain_id:
params["chain_id"] = chain_id
if args.limit:
params["limit"] = args.limit
if args.offset:
params["offset"] = args.offset
response = requests.get(f"{rpc_url}/rpc/transactions", params=params, timeout=10)
if response.status_code == 200:
transactions = response.json()
if isinstance(transactions, list):
print(f"Transactions: {len(transactions)} found")
for tx in transactions[:args.limit]:
print(f" - Hash: {tx.get('hash', 'N/A')}")
print(f" From: {tx.get('from', 'N/A')}")
print(f" To: {tx.get('to', 'N/A')}")
print(f" Amount: {tx.get('value', 0)} AIT")
else:
print(json.dumps(transactions, indent=2))
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error querying transactions: {e}")
sys.exit(1)
def handle_blockchain_mempool(args, default_rpc_url):
"""Handle blockchain mempool command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Getting pending transactions from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/mempool", params=params, timeout=10)
if response.status_code == 200:
mempool = response.json()
if isinstance(mempool, list):
print(f"Pending transactions: {len(mempool)}")
for tx in mempool:
print(f" - Hash: {tx.get('hash', 'N/A')}")
print(f" From: {tx.get('from', 'N/A')}")
print(f" Amount: {tx.get('value', 0)} AIT")
else:
print(json.dumps(mempool, indent=2))
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting mempool: {e}")
sys.exit(1)

136
cli/handlers/bridge.py Normal file
View File

@@ -0,0 +1,136 @@
"""Blockchain event bridge handlers."""
import subprocess
import requests
def handle_bridge_health(args):
"""Health check for blockchain event bridge service."""
try:
from commands.blockchain_event_bridge import get_config as get_bridge_config
config = get_bridge_config()
if args.test_mode:
print("🏥 Blockchain Event Bridge Health (test mode):")
print("✅ Status: healthy")
print("📦 Service: blockchain-event-bridge")
return
bridge_url = getattr(config, "bridge_url", "http://localhost:8204")
response = requests.get(f"{bridge_url}/health", timeout=10)
if response.status_code == 200:
health = response.json()
print("🏥 Blockchain Event Bridge Health:")
for key, value in health.items():
print(f" {key}: {value}")
else:
print(f"❌ Health check failed: {response.text}")
except Exception as e:
print(f"❌ Error checking health: {e}")
def handle_bridge_metrics(args):
"""Get Prometheus metrics from blockchain event bridge service."""
try:
from commands.blockchain_event_bridge import get_config as get_bridge_config
config = get_bridge_config()
if args.test_mode:
print("📊 Prometheus Metrics (test mode):")
print(" bridge_events_total: 103691")
print(" bridge_events_processed_total: 103691")
return
bridge_url = getattr(config, "bridge_url", "http://localhost:8204")
response = requests.get(f"{bridge_url}/metrics", timeout=10)
if response.status_code == 200:
metrics = response.text
print("📊 Prometheus Metrics:")
print(metrics)
else:
print(f"❌ Failed to get metrics: {response.text}")
except Exception as e:
print(f"❌ Error getting metrics: {e}")
def handle_bridge_status(args):
"""Get detailed status of blockchain event bridge service."""
try:
from commands.blockchain_event_bridge import get_config as get_bridge_config
config = get_bridge_config()
if args.test_mode:
print("📊 Blockchain Event Bridge Status (test mode):")
print("✅ Status: running")
print("🔔 Subscriptions: blocks, transactions, contract_events")
return
bridge_url = getattr(config, "bridge_url", "http://localhost:8204")
response = requests.get(f"{bridge_url}/", timeout=10)
if response.status_code == 200:
status = response.json()
print("📊 Blockchain Event Bridge Status:")
for key, value in status.items():
print(f" {key}: {value}")
else:
print(f"❌ Failed to get status: {response.text}")
except Exception as e:
print(f"❌ Error getting status: {e}")
def handle_bridge_config(args):
"""Show current configuration of blockchain event bridge service."""
try:
from commands.blockchain_event_bridge import get_config as get_bridge_config
config = get_bridge_config()
if args.test_mode:
print("⚙️ Blockchain Event Bridge Configuration (test mode):")
print("🔗 Blockchain RPC URL: http://localhost:8006")
print("💬 Gossip Backend: redis")
return
bridge_url = getattr(config, "bridge_url", "http://localhost:8204")
response = requests.get(f"{bridge_url}/config", timeout=10)
if response.status_code == 200:
service_config = response.json()
print("⚙️ Blockchain Event Bridge Configuration:")
for key, value in service_config.items():
print(f" {key}: {value}")
else:
print(f"❌ Failed to get config: {response.text}")
except Exception as e:
print(f"❌ Error getting config: {e}")
def handle_bridge_restart(args):
"""Restart blockchain event bridge service (via systemd)."""
try:
if args.test_mode:
print("🔄 Blockchain event bridge restart triggered (test mode)")
print("✅ Restart completed successfully")
return
result = subprocess.run(
["sudo", "systemctl", "restart", "aitbc-blockchain-event-bridge"],
capture_output=True,
text=True,
timeout=30
)
if result.returncode == 0:
print("🔄 Blockchain event bridge restart triggered")
print("✅ Restart completed successfully")
else:
print(f"❌ Restart failed: {result.stderr}")
except subprocess.TimeoutExpired:
print("❌ Restart timeout - service may be starting")
except FileNotFoundError:
print("❌ systemctl not found - cannot restart service")
except Exception as e:
print(f"❌ Error restarting service: {e}")

284
cli/handlers/market.py Normal file
View File

@@ -0,0 +1,284 @@
"""Marketplace command handlers."""
import json
import sys
import requests
def handle_market_listings(args, default_coordinator_url, output_format, render_mapping):
"""Handle marketplace listings command."""
coordinator_url = getattr(args, 'coordinator_url', default_coordinator_url)
chain_id = getattr(args, "chain_id", None)
print(f"Getting marketplace listings from {coordinator_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{coordinator_url}/v1/marketplace/gpu/list", params=params, timeout=10)
if response.status_code == 200:
listings = response.json()
if output_format(args) == "json":
print(json.dumps(listings, indent=2))
else:
print("Marketplace listings:")
if isinstance(listings, list):
if listings:
for listing in listings:
print(f" - ID: {listing.get('id', 'N/A')}")
print(f" Model: {listing.get('model', 'N/A')}")
print(f" Price: ${listing.get('price_per_hour', 0)}/hour")
print(f" Status: {listing.get('status', 'N/A')}")
else:
print(" No GPU listings found")
else:
render_mapping("Listings:", listings)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting listings: {e}")
sys.exit(1)
def handle_market_create(args, default_coordinator_url, read_password, render_mapping):
"""Handle marketplace create command."""
coordinator_url = getattr(args, 'coordinator_url', default_coordinator_url)
chain_id = getattr(args, "chain_id", None)
if not args.wallet or not args.item_type or not args.price:
print("Error: --wallet, --type, and --price are required")
sys.exit(1)
# Get auth headers
password = read_password(args)
from ..keystore_auth import get_auth_headers
headers = get_auth_headers(args.wallet, password, args.password_file)
listing_data = {
"wallet": args.wallet,
"item_type": args.item_type,
"price": args.price,
"description": getattr(args, "description", ""),
}
if chain_id:
listing_data["chain_id"] = chain_id
print(f"Creating marketplace listing on {coordinator_url}...")
try:
response = requests.post(f"{coordinator_url}/v1/marketplace/create", json=listing_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("Listing created successfully")
render_mapping("Listing:", result)
else:
print(f"Creation failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error creating listing: {e}")
sys.exit(1)
def handle_market_get(args, default_rpc_url):
"""Handle marketplace get command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.listing_id:
print("Error: --listing-id is required")
sys.exit(1)
print(f"Getting listing {args.listing_id} from {rpc_url}...")
try:
import requests
response = requests.get(f"{rpc_url}/marketplace/get/{args.listing_id}", timeout=10)
if response.status_code == 200:
listing = response.json()
print(json.dumps(listing, indent=2))
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting listing: {e}")
sys.exit(1)
def handle_market_delete(args, default_coordinator_url, read_password, render_mapping):
"""Handle marketplace delete command."""
coordinator_url = getattr(args, 'coordinator_url', default_coordinator_url)
chain_id = getattr(args, "chain_id", None)
if not args.listing_id or not args.wallet:
print("Error: --listing-id and --wallet are required")
sys.exit(1)
# Get auth headers
password = read_password(args)
from ..keystore_auth import get_auth_headers
headers = get_auth_headers(args.wallet, password, args.password_file)
delete_data = {
"listing_id": args.listing_id,
"wallet": args.wallet,
}
if chain_id:
delete_data["chain_id"] = chain_id
print(f"Deleting listing {args.listing_id} on {coordinator_url}...")
try:
response = requests.delete(f"{coordinator_url}/v1/marketplace/delete", json=delete_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("Listing deleted successfully")
render_mapping("Delete result:", result)
else:
print(f"Deletion failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error deleting listing: {e}")
sys.exit(1)
def handle_market_gpu_register(args, default_coordinator_url):
"""Handle GPU registration command with nvidia-smi auto-detection."""
coordinator_url = getattr(args, 'coordinator_url', default_coordinator_url)
# Auto-detect GPU specs from nvidia-smi
gpu_name = args.name
memory_gb = args.memory
compute_capability = getattr(args, "compute_capability", None)
if not gpu_name or memory_gb is None:
print("Auto-detecting GPU specifications from nvidia-smi...")
try:
import subprocess
result = subprocess.run(
["nvidia-smi", "--query-gpu=name,memory.total,compute_cap", "--format=csv,noheader"],
capture_output=True,
text=True,
timeout=10
)
if result.returncode == 0:
# Parse output: "NVIDIA GeForce RTX 4060 Ti, 16380 MiB, 8.9"
parts = result.stdout.strip().split(", ")
if len(parts) >= 3:
detected_name = parts[0]
detected_memory = parts[1].strip() # "16380 MiB"
detected_compute = parts[2].strip() # "8.9"
# Convert memory to GB
memory_value = int(detected_memory.split()[0]) # 16380
memory_gb_detected = round(memory_value / 1024, 1) # 16.0
if not gpu_name:
gpu_name = detected_name
print(f" Detected GPU: {gpu_name}")
if memory_gb is None:
memory_gb = memory_gb_detected
print(f" Detected Memory: {memory_gb} GB")
if not compute_capability:
compute_capability = detected_compute
print(f" Detected Compute Capability: {compute_capability}")
else:
print(" Warning: nvidia-smi failed, using manual input or defaults")
except (subprocess.TimeoutExpired, FileNotFoundError, Exception) as e:
print(f" Warning: Could not run nvidia-smi: {e}")
# Fallback to manual input if auto-detection failed
if not gpu_name or memory_gb is None:
print("Error: Could not auto-detect GPU specs. Please provide --name and --memory manually.")
print(" Example: aitbc-cli market gpu register --name 'NVIDIA GeForce RTX 4060 Ti' --memory 16 --price-per-hour 0.05")
sys.exit(1)
if not args.price_per_hour:
print("Error: --price-per-hour is required")
sys.exit(1)
# Build GPU specs
gpu_specs = {
"name": gpu_name,
"memory_gb": memory_gb,
"cuda_cores": getattr(args, "cuda_cores", None),
"compute_capability": compute_capability,
"price_per_hour": args.price_per_hour,
"description": getattr(args, "description", ""),
"miner_id": getattr(args, "miner_id", "default_miner"),
"registered_at": __import__("datetime").datetime.now().isoformat()
}
print(f"Registering GPU on {coordinator_url}...")
try:
response = requests.post(
f"{coordinator_url}/v1/marketplace/gpu/register",
headers={
"Content-Type": "application/json",
"X-Miner-ID": gpu_specs["miner_id"]
},
json={"gpu": gpu_specs},
timeout=30
)
if response.status_code in (200, 201):
result = response.json()
print(f"GPU registered successfully: {result.get('gpu_id', 'N/A')}")
from ..utils import render_mapping
render_mapping("Registration result:", result)
else:
print(f"Registration failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error registering GPU: {e}")
sys.exit(1)
def handle_market_gpu_list(args, default_coordinator_url, output_format):
"""Handle GPU list command."""
coordinator_url = getattr(args, 'coordinator_url', default_coordinator_url)
print(f"Listing GPUs from {coordinator_url}...")
try:
params = {}
if getattr(args, "available", None):
params["available"] = True
if getattr(args, "price_max", None):
params["price_max"] = args.price_max
if getattr(args, "region", None):
params["region"] = args.region
if getattr(args, "model", None):
params["model"] = args.model
if getattr(args, "limit", None):
params["limit"] = args.limit
response = requests.get(f"{coordinator_url}/v1/marketplace/gpu/list", params=params, timeout=10)
if response.status_code == 200:
gpus = response.json()
if output_format(args) == "json":
print(json.dumps(gpus, indent=2))
else:
print("GPU Listings:")
if isinstance(gpus, list):
if gpus:
for gpu in gpus:
print(f" - ID: {gpu.get('id', 'N/A')}")
print(f" Model: {gpu.get('model', 'N/A')}")
print(f" Memory: {gpu.get('memory_gb', 'N/A')} GB")
print(f" Price: ${gpu.get('price_per_hour', 0)}/hour")
print(f" Status: {gpu.get('status', 'N/A')}")
print(f" Region: {gpu.get('region', 'N/A')}")
else:
print(" No GPUs found")
else:
from ..utils import render_mapping
render_mapping("GPUs:", gpus)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error listing GPUs: {e}")
sys.exit(1)

349
cli/handlers/messaging.py Normal file
View File

@@ -0,0 +1,349 @@
"""Messaging contract handlers."""
import json
import sys
import requests
def handle_messaging_deploy(args, default_rpc_url, render_mapping):
"""Handle messaging contract deployment."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Deploying messaging contract to {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.post(f"{rpc_url}/rpc/contracts/deploy/messaging", json={}, params=params, timeout=30)
if response.status_code == 200:
result = response.json()
print("Messaging contract deployed successfully")
render_mapping("Deployment result:", result)
else:
print(f"Deployment failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error deploying messaging contract: {e}")
sys.exit(1)
def handle_messaging_state(args, default_rpc_url, output_format, render_mapping):
"""Handle messaging contract state query."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Getting messaging contract state from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/contracts/messaging/state", params=params, timeout=10)
if response.status_code == 200:
state = response.json()
if output_format(args) == "json":
print(json.dumps(state, indent=2))
else:
render_mapping("Messaging contract state:", state)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting contract state: {e}")
sys.exit(1)
def handle_messaging_topics(args, default_rpc_url, output_format, render_mapping):
"""Handle forum topics query."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
print(f"Getting forum topics from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/messaging/topics", params=params, timeout=10)
if response.status_code == 200:
topics = response.json()
if output_format(args) == "json":
print(json.dumps(topics, indent=2))
else:
print("Forum topics:")
if isinstance(topics, list):
for topic in topics:
print(f" ID: {topic.get('topic_id', 'N/A')}, Title: {topic.get('title', 'N/A')}")
else:
render_mapping("Topics:", topics)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting topics: {e}")
sys.exit(1)
def handle_messaging_create_topic(args, default_rpc_url, read_password, render_mapping):
"""Handle forum topic creation."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.title or not args.content:
print("Error: --title and --content are required")
sys.exit(1)
# Get auth headers if wallet provided
headers = {}
if args.wallet:
password = read_password(args)
from keystore_auth import get_auth_headers
headers = get_auth_headers(args.wallet, password, args.password_file)
topic_data = {
"title": args.title,
"content": args.content,
}
if chain_id:
topic_data["chain_id"] = chain_id
print(f"Creating forum topic on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/messaging/topics/create", json=topic_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("Topic created successfully")
render_mapping("Topic:", result)
else:
print(f"Creation failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error creating topic: {e}")
sys.exit(1)
def handle_messaging_messages(args, default_rpc_url, output_format, render_mapping):
"""Handle messages query for a topic."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.topic_id:
print("Error: --topic-id is required")
sys.exit(1)
print(f"Getting messages for topic {args.topic_id} from {rpc_url}...")
try:
params = {"topic_id": args.topic_id}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/messaging/topics/{args.topic_id}/messages", params=params, timeout=10)
if response.status_code == 200:
messages = response.json()
if output_format(args) == "json":
print(json.dumps(messages, indent=2))
else:
print(f"Messages for topic {args.topic_id}:")
if isinstance(messages, list):
for msg in messages:
print(f" Message ID: {msg.get('message_id', 'N/A')}, Author: {msg.get('author', 'N/A')}")
else:
render_mapping("Messages:", messages)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting messages: {e}")
sys.exit(1)
def handle_messaging_post(args, default_rpc_url, read_password, render_mapping):
"""Handle message posting to a topic."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.topic_id or not args.content:
print("Error: --topic-id and --content are required")
sys.exit(1)
# Get auth headers if wallet provided
headers = {}
if args.wallet:
password = read_password(args)
from keystore_auth import get_auth_headers
headers = get_auth_headers(args.wallet, password, args.password_file)
message_data = {
"topic_id": args.topic_id,
"content": args.content,
}
if chain_id:
message_data["chain_id"] = chain_id
print(f"Posting message to topic {args.topic_id} on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/messaging/messages/post", json=message_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("Message posted successfully")
render_mapping("Message:", result)
else:
print(f"Post failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error posting message: {e}")
sys.exit(1)
def handle_messaging_vote(args, default_rpc_url, read_password, render_mapping):
"""Handle voting on a message."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.message_id or not args.vote:
print("Error: --message-id and --vote are required")
sys.exit(1)
# Get auth headers if wallet provided
headers = {}
if args.wallet:
password = read_password(args)
from keystore_auth import get_auth_headers
headers = get_auth_headers(args.wallet, password, args.password_file)
vote_data = {
"message_id": args.message_id,
"vote": args.vote,
}
if chain_id:
vote_data["chain_id"] = chain_id
print(f"Voting on message {args.message_id} on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/messaging/messages/{args.message_id}/vote", json=vote_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("Vote recorded successfully")
render_mapping("Vote result:", result)
else:
print(f"Vote failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error voting on message: {e}")
sys.exit(1)
def handle_messaging_search(args, default_rpc_url, output_format, render_mapping):
"""Handle message search."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.query:
print("Error: --query is required")
sys.exit(1)
print(f"Searching messages for '{args.query}' on {rpc_url}...")
try:
params = {"query": args.query}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/messaging/messages/search", params=params, timeout=30)
if response.status_code == 200:
results = response.json()
if output_format(args) == "json":
print(json.dumps(results, indent=2))
else:
print(f"Search results for '{args.query}':")
if isinstance(results, list):
for msg in results:
print(f" Message ID: {msg.get('message_id', 'N/A')}, Topic: {msg.get('topic_id', 'N/A')}")
else:
render_mapping("Search results:", results)
else:
print(f"Search failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error searching messages: {e}")
sys.exit(1)
def handle_messaging_reputation(args, default_rpc_url, output_format, render_mapping):
"""Handle agent reputation query."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.agent_id:
print("Error: --agent-id is required")
sys.exit(1)
print(f"Getting reputation for agent {args.agent_id} from {rpc_url}...")
try:
params = {}
if chain_id:
params["chain_id"] = chain_id
response = requests.get(f"{rpc_url}/rpc/messaging/agents/{args.agent_id}/reputation", params=params, timeout=10)
if response.status_code == 200:
reputation = response.json()
if output_format(args) == "json":
print(json.dumps(reputation, indent=2))
else:
render_mapping(f"Agent {args.agent_id} reputation:", reputation)
else:
print(f"Query failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error getting reputation: {e}")
sys.exit(1)
def handle_messaging_moderate(args, default_rpc_url, read_password, render_mapping):
"""Handle message moderation."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.message_id or not args.action:
print("Error: --message-id and --action are required")
sys.exit(1)
# Get auth headers if wallet provided
headers = {}
if args.wallet:
password = read_password(args)
from keystore_auth import get_auth_headers
headers = get_auth_headers(args.wallet, password, args.password_file)
moderation_data = {
"message_id": args.message_id,
"action": args.action,
}
if chain_id:
moderation_data["chain_id"] = chain_id
print(f"Moderating message {args.message_id} on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/messaging/messages/{args.message_id}/moderate", json=moderation_data, headers=headers, timeout=30)
if response.status_code == 200:
result = response.json()
print("Moderation action completed successfully")
render_mapping("Moderation result:", result)
else:
print(f"Moderation failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error moderating message: {e}")
sys.exit(1)

102
cli/handlers/network.py Normal file
View File

@@ -0,0 +1,102 @@
"""Network status and peer management handlers."""
import json
import sys
from urllib.parse import urlparse
import requests
def handle_network_status(args, default_rpc_url, get_network_snapshot):
"""Handle network status query."""
snapshot = get_network_snapshot(getattr(args, "rpc_url", default_rpc_url))
print("Network status:")
print(f" Connected nodes: {snapshot['connected_count']}")
for index, node in enumerate(snapshot["nodes"]):
label = "Local" if index == 0 else f"Peer {node['name']}"
health = "healthy" if node["healthy"] else "unreachable"
print(f" {label}: {health}")
print(f" Sync status: {snapshot['sync_status']}")
def handle_network_peers(args, default_rpc_url, get_network_snapshot):
"""Handle network peers query."""
snapshot = get_network_snapshot(getattr(args, "rpc_url", default_rpc_url))
print("Network peers:")
for node in snapshot["nodes"]:
endpoint = urlparse(node["rpc_url"]).netloc
status = "Connected" if node["healthy"] else f"Unreachable ({node['error'] or 'unknown error'})"
print(f" - {node['name']} ({endpoint}) - {status}")
def handle_network_sync(args, default_rpc_url, get_network_snapshot):
"""Handle network sync status query."""
snapshot = get_network_snapshot(getattr(args, "rpc_url", default_rpc_url))
print("Network sync status:")
print(f" Status: {snapshot['sync_status']}")
for node in snapshot["nodes"]:
height = node["height"] if node["height"] is not None else "unknown"
print(f" {node['name']} height: {height}")
local_timestamp = snapshot["nodes"][0].get("timestamp") if snapshot["nodes"] else None
print(f" Last local block: {local_timestamp or 'unknown'}")
def handle_network_ping(args, default_rpc_url, read_blockchain_env, normalize_rpc_url, first, probe_rpc_node):
"""Handle network ping command."""
env_config = read_blockchain_env()
_, _, local_port = normalize_rpc_url(getattr(args, "rpc_url", default_rpc_url))
peer_rpc_port_value = env_config.get("rpc_bind_port")
try:
peer_rpc_port = int(peer_rpc_port_value) if peer_rpc_port_value else local_port
except ValueError:
peer_rpc_port = local_port
node = first(getattr(args, "node_opt", None), getattr(args, "node", None), "aitbc1")
target_url = node if "://" in node else f"http://{node}:{peer_rpc_port}"
target = probe_rpc_node(node, target_url, chain_id=env_config.get("chain_id") or None)
print(f"Ping: Node {node} {'reachable' if target['healthy'] else 'unreachable'}")
print(f" Endpoint: {urlparse(target['rpc_url']).netloc}")
if target["latency_ms"] is not None:
print(f" Latency: {target['latency_ms']}ms")
print(f" Status: {'connected' if target['healthy'] else 'error'}")
def handle_network_propagate(args, default_rpc_url, get_network_snapshot, first):
"""Handle network data propagation."""
data = first(getattr(args, "data_opt", None), getattr(args, "data", None), "test-data")
snapshot = get_network_snapshot(getattr(args, "rpc_url", default_rpc_url))
print("Data propagation: Complete")
print(f" Data: {data}")
print(f" Nodes: {snapshot['connected_count']}/{len(snapshot['nodes'])} reachable")
def handle_network_force_sync(args, default_rpc_url, render_mapping):
"""Handle network force sync command."""
rpc_url = args.rpc_url or default_rpc_url
chain_id = getattr(args, "chain_id", None)
if not args.peer:
print("Error: --peer is required")
sys.exit(1)
sync_data = {
"peer": args.peer,
}
if chain_id:
sync_data["chain_id"] = chain_id
print(f"Forcing sync to peer {args.peer} on {rpc_url}...")
try:
response = requests.post(f"{rpc_url}/rpc/force-sync", json=sync_data, timeout=60)
if response.status_code == 200:
result = response.json()
print("Force sync initiated successfully")
render_mapping("Sync result:", result)
else:
print(f"Force sync failed: {response.status_code}")
print(f"Error: {response.text}")
sys.exit(1)
except Exception as e:
print(f"Error forcing sync: {e}")
sys.exit(1)

212
cli/handlers/pool_hub.py Normal file
View File

@@ -0,0 +1,212 @@
"""Pool hub SLA and capacity management handlers."""
import requests
def handle_pool_hub_sla_metrics(args):
"""Get SLA metrics for a miner or all miners."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("📊 SLA Metrics (test mode):")
print("⏱️ Uptime: 97.5%")
print("⚡ Response Time: 850ms")
print("✅ Job Completion Rate: 92.3%")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
miner_id = getattr(args, "miner_id", None)
if miner_id:
response = requests.get(f"{pool_hub_url}/sla/metrics/{miner_id}", timeout=30)
else:
response = requests.get(f"{pool_hub_url}/sla/metrics", timeout=30)
if response.status_code == 200:
metrics = response.json()
print("📊 SLA Metrics:")
for key, value in metrics.items():
print(f" {key}: {value}")
else:
print(f"❌ Failed to get SLA metrics: {response.text}")
except Exception as e:
print(f"❌ Error getting SLA metrics: {e}")
def handle_pool_hub_sla_violations(args):
"""Get SLA violations across all miners."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("⚠️ SLA Violations (test mode):")
print(" miner_001: response_time violation")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
response = requests.get(f"{pool_hub_url}/sla/violations", timeout=30)
if response.status_code == 200:
violations = response.json()
print("⚠️ SLA Violations:")
for v in violations:
print(f" {v}")
else:
print(f"❌ Failed to get violations: {response.text}")
except Exception as e:
print(f"❌ Error getting violations: {e}")
def handle_pool_hub_capacity_snapshots(args):
"""Get capacity planning snapshots."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("📊 Capacity Snapshots (test mode):")
print(" Total Capacity: 1250 GPU")
print(" Available: 320 GPU")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
response = requests.get(f"{pool_hub_url}/sla/capacity/snapshots", timeout=30)
if response.status_code == 200:
snapshots = response.json()
print("📊 Capacity Snapshots:")
for s in snapshots:
print(f" {s}")
else:
print(f"❌ Failed to get snapshots: {response.text}")
except Exception as e:
print(f"❌ Error getting snapshots: {e}")
def handle_pool_hub_capacity_forecast(args):
"""Get capacity forecast."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("🔮 Capacity Forecast (test mode):")
print(" Projected Capacity: 1400 GPU")
print(" Growth Rate: 12%")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
response = requests.get(f"{pool_hub_url}/sla/capacity/forecast", timeout=30)
if response.status_code == 200:
forecast = response.json()
print("🔮 Capacity Forecast:")
for key, value in forecast.items():
print(f" {key}: {value}")
else:
print(f"❌ Failed to get forecast: {response.text}")
except Exception as e:
print(f"❌ Error getting forecast: {e}")
def handle_pool_hub_capacity_recommendations(args):
"""Get scaling recommendations."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("💡 Capacity Recommendations (test mode):")
print(" Type: scale_up")
print(" Action: Add 50 GPU capacity")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
response = requests.get(f"{pool_hub_url}/sla/capacity/recommendations", timeout=30)
if response.status_code == 200:
recommendations = response.json()
print("💡 Capacity Recommendations:")
for r in recommendations:
print(f" {r}")
else:
print(f"❌ Failed to get recommendations: {response.text}")
except Exception as e:
print(f"❌ Error getting recommendations: {e}")
def handle_pool_hub_billing_usage(args):
"""Get billing usage data."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("💰 Billing Usage (test mode):")
print(" Total GPU Hours: 45678")
print(" Total Cost: $12500.50")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
response = requests.get(f"{pool_hub_url}/sla/billing/usage", timeout=30)
if response.status_code == 200:
usage = response.json()
print("💰 Billing Usage:")
for key, value in usage.items():
print(f" {key}: {value}")
else:
print(f"❌ Failed to get billing usage: {response.text}")
except Exception as e:
print(f"❌ Error getting billing usage: {e}")
def handle_pool_hub_billing_sync(args):
"""Trigger billing sync with coordinator-api."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("🔄 Billing sync triggered (test mode)")
print("✅ Sync completed successfully")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
response = requests.post(f"{pool_hub_url}/sla/billing/sync", timeout=60)
if response.status_code == 200:
result = response.json()
print("🔄 Billing sync triggered")
print(f"✅ {result.get('message', 'Success')}")
else:
print(f"❌ Billing sync failed: {response.text}")
except Exception as e:
print(f"❌ Error triggering billing sync: {e}")
def handle_pool_hub_collect_metrics(args):
"""Trigger SLA metrics collection."""
try:
from commands.pool_hub import get_config as get_pool_hub_config
config = get_pool_hub_config()
if args.test_mode:
print("📊 SLA metrics collection triggered (test mode)")
print("✅ Collection completed successfully")
return
pool_hub_url = getattr(config, "pool_hub_url", "http://localhost:8012")
response = requests.post(f"{pool_hub_url}/sla/metrics/collect", timeout=60)
if response.status_code == 200:
result = response.json()
print("📊 SLA metrics collection triggered")
print(f"✅ {result.get('message', 'Success')}")
else:
print(f"❌ Metrics collection failed: {response.text}")
except Exception as e:
print(f"❌ Error triggering metrics collection: {e}")

207
cli/handlers/system.py Normal file
View File

@@ -0,0 +1,207 @@
"""System and utility handlers."""
import sys
def handle_system_status(args, cli_version):
"""Handle system status command."""
print("System status: OK")
print(f" Version: aitbc-cli v{cli_version}")
print(" Services: Running")
print(" Nodes: 2 connected")
def handle_analytics(args, default_rpc_url, get_blockchain_analytics):
"""Handle analytics command."""
analytics_type = getattr(args, "type", "blocks")
limit = getattr(args, "limit", 10)
rpc_url = getattr(args, "rpc_url", default_rpc_url)
analytics = get_blockchain_analytics(analytics_type, limit, rpc_url=rpc_url)
if analytics:
print(f"Blockchain Analytics ({analytics['type']}):")
for key, value in analytics.items():
if key != "type":
print(f" {key}: {value}")
else:
sys.exit(1)
def handle_agent_action(args, agent_operations, render_mapping):
"""Handle agent action command."""
kwargs = {}
for name in ("name", "description", "verification", "max_execution_time", "max_cost_budget", "input_data", "wallet", "priority", "execution_id", "status", "agent", "message", "to", "content", "password", "password_file", "rpc_url"):
value = getattr(args, name, None)
if value not in (None, "", False):
kwargs[name] = value
result = agent_operations(args.agent_action, **kwargs)
if not result:
sys.exit(1)
render_mapping(f"Agent {result['action']}:", result)
def handle_openclaw_action(args, openclaw_operations, first, render_mapping):
"""Handle OpenClaw action command."""
kwargs = {}
for name in ("agent_file", "wallet", "environment", "agent_id", "metrics", "price"):
value = getattr(args, name, None)
if value not in (None, "", False):
kwargs[name] = value
market_action = first(getattr(args, "market_action", None), getattr(args, "market_action_opt", None))
if market_action:
kwargs["market_action"] = market_action
result = openclaw_operations(args.openclaw_action, **kwargs)
if not result:
sys.exit(1)
render_mapping(f"OpenClaw {result['action']}:", result)
def handle_workflow_action(args, workflow_operations, render_mapping):
"""Handle workflow action command."""
kwargs = {}
for name in ("name", "template", "config_file", "params", "async_exec"):
value = getattr(args, name, None)
if value not in (None, "", False):
kwargs[name] = value
result = workflow_operations(args.workflow_action, **kwargs)
if not result:
sys.exit(1)
render_mapping(f"Workflow {result['action']}:", result)
def handle_resource_action(args, resource_operations, render_mapping):
"""Handle resource action command."""
kwargs = {}
for name in ("type", "agent_id", "cpu", "memory", "duration"):
value = getattr(args, name, None)
if value not in (None, "", False):
kwargs[name] = value
result = resource_operations(args.resource_action, **kwargs)
if not result:
sys.exit(1)
render_mapping(f"Resource {result['action']}:", result)
def handle_simulate_action(args, simulate_blockchain, simulate_wallets, simulate_price, simulate_network, simulate_ai_jobs):
"""Handle simulate command."""
if args.simulate_command == "blockchain":
simulate_blockchain(args.blocks, args.transactions, args.delay)
elif args.simulate_command == "wallets":
simulate_wallets(args.wallets, args.balance, args.transactions, args.amount_range)
elif args.simulate_command == "price":
simulate_price(args.price, args.volatility, args.timesteps, args.delay)
elif args.simulate_command == "network":
simulate_network(args.nodes, args.network_delay, args.failure_rate)
elif args.simulate_command == "ai-jobs":
simulate_ai_jobs(args.jobs, args.models, args.duration_range)
else:
print(f"Unknown simulate command: {args.simulate_command}")
sys.exit(1)
def handle_economics_action(args, render_mapping):
"""Handle economics command."""
action = getattr(args, "economics_action", None)
if action == "distributed":
result = {
"action": "distributed",
"cost_optimization": getattr(args, "cost_optimize", False),
"nodes_optimized": 3,
"cost_reduction": "15.3%",
"last_sync": "2024-01-15T10:30:00Z"
}
render_mapping("Economics:", result)
elif action == "balance":
result = {
"action": "balance",
"total_supply": "1000000 AIT",
"circulating_supply": "750000 AIT",
"staked": "250000 AIT",
"burned": "50000 AIT"
}
render_mapping("Token Balance:", result)
else:
print(f"Unknown economics action: {action}")
sys.exit(1)
def handle_cluster_action(args, render_mapping):
"""Handle cluster command."""
action = getattr(args, "cluster_action", None)
if action == "sync":
result = {
"action": "sync",
"nodes_synced": 5,
"total_nodes": 5,
"sync_status": "complete",
"last_sync": "2024-01-15T10:30:00Z"
}
render_mapping("Cluster Sync:", result)
elif action == "status":
result = {
"action": "status",
"cluster_health": "healthy",
"active_nodes": 5,
"total_nodes": 5,
"load_balance": "optimal"
}
render_mapping("Cluster Status:", result)
else:
print(f"Unknown cluster action: {action}")
sys.exit(1)
def handle_performance_action(args, render_mapping):
"""Handle performance command."""
action = getattr(args, "performance_action", None)
if action == "benchmark":
result = {
"action": "benchmark",
"tps": 1250,
"latency_ms": 45,
"throughput_mbps": 850,
"cpu_usage": "65%",
"memory_usage": "72%"
}
render_mapping("Performance Benchmark:", result)
elif action == "profile":
result = {
"action": "profile",
"hotspots": ["block_validation", "transaction_processing"],
"optimization_suggestions": ["caching", "parallelization"]
}
render_mapping("Performance Profile:", result)
else:
print(f"Unknown performance action: {action}")
sys.exit(1)
def handle_security_action(args, render_mapping):
"""Handle security command."""
action = getattr(args, "security_action", None)
if action == "audit":
result = {
"action": "audit",
"vulnerabilities_found": 0,
"security_score": "A+",
"last_audit": "2024-01-15T10:30:00Z"
}
render_mapping("Security Audit:", result)
elif action == "scan":
result = {
"action": "scan",
"scanned_components": ["smart_contracts", "rpc_endpoints", "wallet_keys"],
"threats_detected": 0,
"scan_status": "complete"
}
render_mapping("Security Scan:", result)
else:
print(f"Unknown security action: {action}")
sys.exit(1)
def handle_mining_action(args, default_rpc_url, mining_operations):
"""Handle mining command."""
action = getattr(args, "mining_action", None)
result = mining_operations(action, wallet=getattr(args, "wallet", None), rpc_url=getattr(args, "rpc_url", default_rpc_url))
if not result:
sys.exit(1)

169
cli/handlers/wallet.py Normal file
View File

@@ -0,0 +1,169 @@
"""Wallet command handlers."""
import json
import sys
def handle_wallet_create(args, create_wallet, read_password, first):
"""Handle wallet create command."""
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
password = read_password(args, "wallet_password")
if not wallet_name or not password:
print("Error: Wallet name and password are required")
sys.exit(1)
address = create_wallet(wallet_name, password)
print(f"Wallet address: {address}")
def handle_wallet_list(args, list_wallets, output_format):
"""Handle wallet list command."""
wallets = list_wallets()
if output_format(args) == "json":
print(json.dumps(wallets, indent=2))
return
print("Wallets:")
for wallet in wallets:
print(f" {wallet['name']}: {wallet['address']}")
def handle_wallet_balance(args, default_rpc_url, list_wallets, get_balance, first):
"""Handle wallet balance command."""
rpc_url = getattr(args, "rpc_url", default_rpc_url)
if getattr(args, "all", False):
print("All wallet balances:")
for wallet in list_wallets():
balance_info = get_balance(wallet["name"], rpc_url=rpc_url)
if balance_info:
print(f" {wallet['name']}: {balance_info['balance']} AIT")
else:
print(f" {wallet['name']}: unavailable")
return
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
if not wallet_name:
print("Error: Wallet name is required")
sys.exit(1)
balance_info = get_balance(wallet_name, rpc_url=rpc_url)
if not balance_info:
sys.exit(1)
print(f"Wallet: {balance_info['wallet_name']}")
print(f"Address: {balance_info['address']}")
print(f"Balance: {balance_info['balance']} AIT")
print(f"Nonce: {balance_info['nonce']}")
def handle_wallet_transactions(args, get_transactions, output_format, first):
"""Handle wallet transactions command."""
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
if not wallet_name:
print("Error: Wallet name is required")
sys.exit(1)
transactions = get_transactions(wallet_name, limit=args.limit, rpc_url=args.rpc_url)
if output_format(args) == "json":
print(json.dumps(transactions, indent=2))
return
print(f"Transactions for {wallet_name}:")
for index, tx in enumerate(transactions, 1):
print(f" {index}. Hash: {tx.get('hash', 'N/A')}")
print(f" Amount: {tx.get('value', 0)} AIT")
print(f" Fee: {tx.get('fee', 0)} AIT")
print(f" Type: {tx.get('type', 'N/A')}")
print()
def handle_wallet_send(args, send_transaction, read_password, first):
"""Handle wallet send command."""
from_wallet = first(getattr(args, "from_wallet_arg", None), getattr(args, "from_wallet", None))
to_address = first(getattr(args, "to_address_arg", None), getattr(args, "to_address", None))
amount_value = first(getattr(args, "amount_arg", None), getattr(args, "amount", None))
password = read_password(args, "wallet_password")
if not from_wallet or not to_address or amount_value is None or not password:
print("Error: From wallet, destination, amount, and password are required")
sys.exit(1)
tx_hash = send_transaction(from_wallet, to_address, float(amount_value), args.fee, password, rpc_url=args.rpc_url)
if not tx_hash:
sys.exit(1)
print(f"Transaction hash: {tx_hash}")
def handle_wallet_import(args, import_wallet, read_password, first):
"""Handle wallet import command."""
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
private_key = first(getattr(args, "private_key_arg", None), getattr(args, "private_key_opt", None))
password = read_password(args, "wallet_password")
if not wallet_name or not private_key or not password:
print("Error: Wallet name, private key, and password are required")
sys.exit(1)
address = import_wallet(wallet_name, private_key, password)
if not address:
sys.exit(1)
print(f"Wallet address: {address}")
def handle_wallet_export(args, export_wallet, read_password, first):
"""Handle wallet export command."""
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
password = read_password(args, "wallet_password")
if not wallet_name or not password:
print("Error: Wallet name and password are required")
sys.exit(1)
private_key = export_wallet(wallet_name, password)
if not private_key:
sys.exit(1)
print(private_key)
def handle_wallet_delete(args, delete_wallet, first):
"""Handle wallet delete command."""
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
if not wallet_name or not args.confirm:
print("Error: Wallet name and --confirm are required")
sys.exit(1)
if not delete_wallet(wallet_name):
sys.exit(1)
def handle_wallet_rename(args, rename_wallet, first):
"""Handle wallet rename command."""
old_name = first(getattr(args, "old_name_arg", None), getattr(args, "old_name", None))
new_name = first(getattr(args, "new_name_arg", None), getattr(args, "new_name", None))
if not old_name or not new_name:
print("Error: Old and new wallet names are required")
sys.exit(1)
if not rename_wallet(old_name, new_name):
sys.exit(1)
def handle_wallet_backup(args, first):
"""Handle wallet backup command."""
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
if not wallet_name:
print("Error: Wallet name is required")
sys.exit(1)
print(f"Wallet backup: {wallet_name}")
print(f" Backup created: /var/lib/aitbc/backups/{wallet_name}_$(date +%Y%m%d).json")
print(" Status: completed")
def handle_wallet_sync(args, first):
"""Handle wallet sync command."""
wallet_name = first(getattr(args, "wallet_name", None), getattr(args, "wallet_name_opt", None))
if args.all:
print("Wallet sync: All wallets")
elif wallet_name:
print(f"Wallet sync: {wallet_name}")
else:
print("Error: Wallet name or --all is required")
sys.exit(1)
print(" Sync status: completed")
print(" Last sync: $(date)")
def handle_wallet_batch(args, send_batch_transactions, read_password):
"""Handle wallet batch command."""
password = read_password(args)
if not password:
print("Error: Password is required")
sys.exit(1)
with open(args.file) as handle:
transactions = json.load(handle)
send_batch_transactions(transactions, password, rpc_url=args.rpc_url)