15427c96c0
- Change file mode from 644 to 755 for all project files - Add chain_id parameter to get_balance RPC endpoint with default "ait-devnet" - Rename Miner.extra_meta_data to extra_metadata for consistency
604 lines
20 KiB
Python
Executable File
604 lines
20 KiB
Python
Executable File
"""OpenClaw integration commands for AITBC CLI"""
|
|
|
|
import click
|
|
import httpx
|
|
import json
|
|
import time
|
|
from typing import Optional, Dict, Any, List
|
|
from ..utils import output, error, success, warning
|
|
|
|
|
|
@click.group()
|
|
def openclaw():
|
|
"""OpenClaw integration with edge computing deployment"""
|
|
pass
|
|
|
|
|
|
@click.group()
|
|
def deploy():
|
|
"""Agent deployment operations"""
|
|
pass
|
|
|
|
|
|
openclaw.add_command(deploy)
|
|
|
|
|
|
@deploy.command()
|
|
@click.argument("agent_id")
|
|
@click.option("--region", required=True, help="Deployment region")
|
|
@click.option("--instances", default=1, help="Number of instances to deploy")
|
|
@click.option("--instance-type", default="standard", help="Instance type")
|
|
@click.option("--edge-locations", help="Comma-separated edge locations")
|
|
@click.option("--auto-scale", is_flag=True, help="Enable auto-scaling")
|
|
@click.pass_context
|
|
def deploy_agent(ctx, agent_id: str, region: str, instances: int, instance_type: str,
|
|
edge_locations: Optional[str], auto_scale: bool):
|
|
"""Deploy agent to OpenClaw network"""
|
|
config = ctx.obj['config']
|
|
|
|
deployment_data = {
|
|
"agent_id": agent_id,
|
|
"region": region,
|
|
"instances": instances,
|
|
"instance_type": instance_type,
|
|
"auto_scale": auto_scale
|
|
}
|
|
|
|
if edge_locations:
|
|
deployment_data["edge_locations"] = [loc.strip() for loc in edge_locations.split(',')]
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/deploy",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
json=deployment_data
|
|
)
|
|
|
|
if response.status_code == 202:
|
|
deployment = response.json()
|
|
success(f"Agent deployment started: {deployment['id']}")
|
|
output(deployment, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to start deployment: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@click.argument("deployment_id")
|
|
@click.option("--instances", required=True, type=int, help="New number of instances")
|
|
@click.option("--auto-scale", is_flag=True, help="Enable auto-scaling")
|
|
@click.option("--min-instances", default=1, help="Minimum instances for auto-scaling")
|
|
@click.option("--max-instances", default=10, help="Maximum instances for auto-scaling")
|
|
@click.pass_context
|
|
def scale(ctx, deployment_id: str, instances: int, auto_scale: bool, min_instances: int, max_instances: int):
|
|
"""Scale agent deployment"""
|
|
config = ctx.obj['config']
|
|
|
|
scale_data = {
|
|
"instances": instances,
|
|
"auto_scale": auto_scale,
|
|
"min_instances": min_instances,
|
|
"max_instances": max_instances
|
|
}
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/deployments/{deployment_id}/scale",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
json=scale_data
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
success(f"Deployment scaled successfully")
|
|
output(result, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to scale deployment: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@deploy.command()
|
|
@click.argument("deployment_id")
|
|
@click.option("--objective", default="cost",
|
|
type=click.Choice(["cost", "performance", "latency", "efficiency"]),
|
|
help="Optimization objective")
|
|
@click.pass_context
|
|
def optimize(ctx, deployment_id: str, objective: str):
|
|
"""Optimize agent deployment"""
|
|
config = ctx.obj['config']
|
|
|
|
optimization_data = {"objective": objective}
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/deployments/{deployment_id}/optimize",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
json=optimization_data
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
success(f"Deployment optimization completed")
|
|
output(result, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to optimize deployment: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@click.group()
|
|
def monitor():
|
|
"""OpenClaw monitoring operations"""
|
|
pass
|
|
|
|
|
|
openclaw.add_command(monitor)
|
|
|
|
|
|
@monitor.command()
|
|
@click.argument("deployment_id")
|
|
@click.option("--metrics", default="latency,cost", help="Comma-separated metrics to monitor")
|
|
@click.option("--real-time", is_flag=True, help="Show real-time metrics")
|
|
@click.option("--interval", default=10, help="Update interval for real-time monitoring")
|
|
@click.pass_context
|
|
def monitor_metrics(ctx, deployment_id: str, metrics: str, real_time: bool, interval: int):
|
|
"""Monitor OpenClaw agent performance"""
|
|
config = ctx.obj['config']
|
|
|
|
params = {"metrics": [m.strip() for m in metrics.split(',')]}
|
|
|
|
def get_metrics():
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.get(
|
|
f"{config.coordinator_url}/openclaw/deployments/{deployment_id}/metrics",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
params=params
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
return response.json()
|
|
else:
|
|
error(f"Failed to get metrics: {response.status_code}")
|
|
return None
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
return None
|
|
|
|
if real_time:
|
|
click.echo(f"Monitoring deployment {deployment_id} (Ctrl+C to stop)...")
|
|
while True:
|
|
metrics_data = get_metrics()
|
|
if metrics_data:
|
|
click.clear()
|
|
click.echo(f"Deployment ID: {deployment_id}")
|
|
click.echo(f"Status: {metrics_data.get('status', 'Unknown')}")
|
|
click.echo(f"Instances: {metrics_data.get('instances', 'N/A')}")
|
|
|
|
metrics_list = metrics_data.get('metrics', {})
|
|
for metric in [m.strip() for m in metrics.split(',')]:
|
|
if metric in metrics_list:
|
|
value = metrics_list[metric]
|
|
click.echo(f"{metric.title()}: {value}")
|
|
|
|
if metrics_data.get('status') in ['terminated', 'failed']:
|
|
break
|
|
|
|
time.sleep(interval)
|
|
else:
|
|
metrics_data = get_metrics()
|
|
if metrics_data:
|
|
output(metrics_data, ctx.obj['output_format'])
|
|
|
|
|
|
@monitor.command()
|
|
@click.argument("deployment_id")
|
|
@click.pass_context
|
|
def status(ctx, deployment_id: str):
|
|
"""Get deployment status"""
|
|
config = ctx.obj['config']
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.get(
|
|
f"{config.coordinator_url}/openclaw/deployments/{deployment_id}/status",
|
|
headers={"X-Api-Key": config.api_key or ""}
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
status_data = response.json()
|
|
output(status_data, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to get deployment status: {response.status_code}")
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@click.group()
|
|
def edge():
|
|
"""Edge computing operations"""
|
|
pass
|
|
|
|
|
|
openclaw.add_command(edge)
|
|
|
|
|
|
@edge.command()
|
|
@click.argument("agent_id")
|
|
@click.option("--locations", required=True, help="Comma-separated edge locations")
|
|
@click.option("--strategy", default="latency",
|
|
type=click.Choice(["latency", "cost", "availability", "hybrid"]),
|
|
help="Edge deployment strategy")
|
|
@click.option("--replicas", default=1, help="Number of replicas per location")
|
|
@click.pass_context
|
|
def deploy(ctx, agent_id: str, locations: str, strategy: str, replicas: int):
|
|
"""Deploy agent to edge locations"""
|
|
config = ctx.obj['config']
|
|
|
|
edge_data = {
|
|
"agent_id": agent_id,
|
|
"locations": [loc.strip() for loc in locations.split(',')],
|
|
"strategy": strategy,
|
|
"replicas": replicas
|
|
}
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/edge/deploy",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
json=edge_data
|
|
)
|
|
|
|
if response.status_code == 202:
|
|
deployment = response.json()
|
|
success(f"Edge deployment started: {deployment['id']}")
|
|
output(deployment, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to start edge deployment: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@edge.command()
|
|
@click.option("--location", help="Filter by location")
|
|
@click.pass_context
|
|
def resources(ctx, location: Optional[str]):
|
|
"""Manage edge resources"""
|
|
config = ctx.obj['config']
|
|
|
|
params = {}
|
|
if location:
|
|
params["location"] = location
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.get(
|
|
f"{config.coordinator_url}/openclaw/edge/resources",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
params=params
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
resources = response.json()
|
|
output(resources, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to get edge resources: {response.status_code}")
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@edge.command()
|
|
@click.argument("deployment_id")
|
|
@click.option("--latency-target", type=int, help="Target latency in milliseconds")
|
|
@click.option("--cost-budget", type=float, help="Cost budget")
|
|
@click.option("--availability", type=float, help="Target availability (0.0-1.0)")
|
|
@click.pass_context
|
|
def optimize(ctx, deployment_id: str, latency_target: Optional[int],
|
|
cost_budget: Optional[float], availability: Optional[float]):
|
|
"""Optimize edge deployment performance"""
|
|
config = ctx.obj['config']
|
|
|
|
optimization_data = {}
|
|
if latency_target:
|
|
optimization_data["latency_target_ms"] = latency_target
|
|
if cost_budget:
|
|
optimization_data["cost_budget"] = cost_budget
|
|
if availability:
|
|
optimization_data["availability_target"] = availability
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/edge/deployments/{deployment_id}/optimize",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
json=optimization_data
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
success(f"Edge optimization completed")
|
|
output(result, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to optimize edge deployment: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@edge.command()
|
|
@click.argument("deployment_id")
|
|
@click.option("--standards", help="Comma-separated compliance standards")
|
|
@click.pass_context
|
|
def compliance(ctx, deployment_id: str, standards: Optional[str]):
|
|
"""Check edge security compliance"""
|
|
config = ctx.obj['config']
|
|
|
|
params = {}
|
|
if standards:
|
|
params["standards"] = [s.strip() for s in standards.split(',')]
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.get(
|
|
f"{config.coordinator_url}/openclaw/edge/deployments/{deployment_id}/compliance",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
params=params
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
compliance_data = response.json()
|
|
output(compliance_data, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to check compliance: {response.status_code}")
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@click.group()
|
|
def routing():
|
|
"""Agent skill routing and job offloading"""
|
|
pass
|
|
|
|
|
|
openclaw.add_command(routing)
|
|
|
|
|
|
@routing.command()
|
|
@click.argument("deployment_id")
|
|
@click.option("--algorithm", default="load-balanced",
|
|
type=click.Choice(["load-balanced", "skill-based", "cost-based", "latency-based"]),
|
|
help="Routing algorithm")
|
|
@click.option("--weights", help="Comma-separated weights for routing factors")
|
|
@click.pass_context
|
|
def optimize(ctx, deployment_id: str, algorithm: str, weights: Optional[str]):
|
|
"""Optimize agent skill routing"""
|
|
config = ctx.obj['config']
|
|
|
|
routing_data = {"algorithm": algorithm}
|
|
if weights:
|
|
routing_data["weights"] = [w.strip() for w in weights.split(',')]
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/routing/deployments/{deployment_id}/optimize",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
json=routing_data
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
success(f"Routing optimization completed")
|
|
output(result, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to optimize routing: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@routing.command()
|
|
@click.argument("deployment_id")
|
|
@click.pass_context
|
|
def status(ctx, deployment_id: str):
|
|
"""Get routing status and statistics"""
|
|
config = ctx.obj['config']
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.get(
|
|
f"{config.coordinator_url}/openclaw/routing/deployments/{deployment_id}/status",
|
|
headers={"X-Api-Key": config.api_key or ""}
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
status_data = response.json()
|
|
output(status_data, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to get routing status: {response.status_code}")
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@click.group()
|
|
def ecosystem():
|
|
"""OpenClaw ecosystem development"""
|
|
pass
|
|
|
|
|
|
openclaw.add_command(ecosystem)
|
|
|
|
|
|
@ecosystem.command()
|
|
@click.option("--name", required=True, help="Solution name")
|
|
@click.option("--type", required=True,
|
|
type=click.Choice(["agent", "workflow", "integration", "tool"]),
|
|
help="Solution type")
|
|
@click.option("--description", default="", help="Solution description")
|
|
@click.option("--package", type=click.File('rb'), help="Solution package file")
|
|
@click.pass_context
|
|
def create(ctx, name: str, type: str, description: str, package):
|
|
"""Create OpenClaw ecosystem solution"""
|
|
config = ctx.obj['config']
|
|
|
|
solution_data = {
|
|
"name": name,
|
|
"type": type,
|
|
"description": description
|
|
}
|
|
|
|
files = {}
|
|
if package:
|
|
files["package"] = package.read()
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/ecosystem/solutions",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
data=solution_data,
|
|
files=files
|
|
)
|
|
|
|
if response.status_code == 201:
|
|
solution = response.json()
|
|
success(f"OpenClaw solution created: {solution['id']}")
|
|
output(solution, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to create solution: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@ecosystem.command()
|
|
@click.option("--type", help="Filter by solution type")
|
|
@click.option("--category", help="Filter by category")
|
|
@click.option("--limit", default=20, help="Number of solutions to list")
|
|
@click.pass_context
|
|
def list(ctx, type: Optional[str], category: Optional[str], limit: int):
|
|
"""List OpenClaw ecosystem solutions"""
|
|
config = ctx.obj['config']
|
|
|
|
params = {"limit": limit}
|
|
if type:
|
|
params["type"] = type
|
|
if category:
|
|
params["category"] = category
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.get(
|
|
f"{config.coordinator_url}/openclaw/ecosystem/solutions",
|
|
headers={"X-Api-Key": config.api_key or ""},
|
|
params=params
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
solutions = response.json()
|
|
output(solutions, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to list solutions: {response.status_code}")
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@ecosystem.command()
|
|
@click.argument("solution_id")
|
|
@click.pass_context
|
|
def install(ctx, solution_id: str):
|
|
"""Install OpenClaw ecosystem solution"""
|
|
config = ctx.obj['config']
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.post(
|
|
f"{config.coordinator_url}/openclaw/ecosystem/solutions/{solution_id}/install",
|
|
headers={"X-Api-Key": config.api_key or ""}
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
success(f"Solution installed successfully")
|
|
output(result, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to install solution: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|
|
|
|
|
|
@openclaw.command()
|
|
@click.argument("deployment_id")
|
|
@click.pass_context
|
|
def terminate(ctx, deployment_id: str):
|
|
"""Terminate OpenClaw deployment"""
|
|
config = ctx.obj['config']
|
|
|
|
if not click.confirm(f"Terminate deployment {deployment_id}? This action cannot be undone."):
|
|
click.echo("Operation cancelled")
|
|
return
|
|
|
|
try:
|
|
with httpx.Client() as client:
|
|
response = client.delete(
|
|
f"{config.coordinator_url}/openclaw/deployments/{deployment_id}",
|
|
headers={"X-Api-Key": config.api_key or ""}
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
result = response.json()
|
|
success(f"Deployment {deployment_id} terminated")
|
|
output(result, ctx.obj['output_format'])
|
|
else:
|
|
error(f"Failed to terminate deployment: {response.status_code}")
|
|
if response.text:
|
|
error(response.text)
|
|
ctx.exit(1)
|
|
except Exception as e:
|
|
error(f"Network error: {e}")
|
|
ctx.exit(1)
|