From 8c3adf6d8f0a7e40eb65e477624d3389568adfaa Mon Sep 17 00:00:00 2001 From: anthonyrawlins Date: Wed, 9 Jul 2025 21:52:03 +1000 Subject: [PATCH] Implement single domain architecture for Hive platform MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Replace separate hive-api.home.deepblack.cloud subdomain with unified hive.home.deepblack.cloud - Update Traefik routing: /api/* ā†’ backend, /* ā†’ frontend with proper priorities - Add /api/health endpoint while maintaining /health for Docker health checks - Update Socket.IO configuration to use single domain - Fix CORS settings for consolidated domain - Update MCP server endpoint to use /api path prefix - Update all documentation to reflect single domain architecture System now fully operational with simplified routing and proper SSL certificates. šŸ¤– Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- INTEGRATION_GUIDE.md | 8 +- README.md | 8 +- backend/app/main.py | 353 +++++++++++++++++++++------------- docker-compose.swarm.yml | 109 +++++++---- mcp-server/src/hive-client.ts | 6 +- scripts/register_agents.py | 4 +- 6 files changed, 298 insertions(+), 190 deletions(-) diff --git a/INTEGRATION_GUIDE.md b/INTEGRATION_GUIDE.md index c5248b82..f150b9f1 100644 --- a/INTEGRATION_GUIDE.md +++ b/INTEGRATION_GUIDE.md @@ -251,8 +251,8 @@ vim ~/Library/Application\ Support/Claude/claude_desktop_config.json # Update the env section: "env": { - "HIVE_API_URL": "http://your-hive-host:8087", - "HIVE_WS_URL": "ws://your-hive-host:8087" + "HIVE_API_URL": "https://your-hive-host/api", + "HIVE_WS_URL": "wss://your-hive-host/socket.io" } ``` @@ -266,14 +266,14 @@ You can configure multiple Hive clusters: "command": "node", "args": ["/path/to/hive/mcp-server/dist/index.js"], "env": { - "HIVE_API_URL": "http://prod-hive:8087" + "HIVE_API_URL": "https://prod-hive/api" } }, "hive-development": { "command": "node", "args": ["/path/to/hive/mcp-server/dist/index.js"], "env": { - "HIVE_API_URL": "http://dev-hive:8087" + "HIVE_API_URL": "https://dev-hive/api" } } } diff --git a/README.md b/README.md index c583034e..c3d01605 100644 --- a/README.md +++ b/README.md @@ -25,10 +25,10 @@ cd /home/tony/AI/projects/hive ``` ### 2. Access Services -- **šŸŒ Hive Dashboard**: http://localhost:3000 -- **šŸ“” API Documentation**: http://localhost:8000/docs -- **šŸ“Š Grafana Monitoring**: http://localhost:3001 (admin/hiveadmin) -- **šŸ” Prometheus Metrics**: http://localhost:9090 +- **šŸŒ Hive Dashboard**: https://hive.home.deepblack.cloud +- **šŸ“” API Documentation**: https://hive.home.deepblack.cloud/api/docs +- **šŸ“Š Grafana Monitoring**: https://hive.home.deepblack.cloud/grafana (admin/hiveadmin) +- **šŸ” Prometheus Metrics**: https://hive.home.deepblack.cloud/prometheus ### 3. Default Credentials - **Grafana**: admin / hiveadmin diff --git a/backend/app/main.py b/backend/app/main.py index d9f809fa..1a672564 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -1,4 +1,4 @@ -from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Depends, HTTPException +from fastapi import FastAPI, Depends, HTTPException from fastapi.middleware.cors import CORSMiddleware from fastapi.staticfiles import StaticFiles from contextlib import asynccontextmanager @@ -7,36 +7,75 @@ import asyncio import uvicorn from datetime import datetime from pathlib import Path +import socketio -from .core.hive_coordinator import AIDevCoordinator as HiveCoordinator -from .core.database import engine, get_db +from .core.hive_coordinator import HiveCoordinator +from .core.distributed_coordinator import DistributedCoordinator +from .core.database import engine, get_db, init_database_with_retry, test_database_connection from .core.auth import get_current_user -from .api import agents, workflows, executions, monitoring, projects, tasks +from .api import agents, workflows, executions, monitoring, projects, tasks, cluster, distributed_workflows +# from .mcp.distributed_mcp_server import get_mcp_server from .models.user import Base +from .models import agent, project # Import the new agent and project models -# Global coordinator instance +# Global coordinator instances hive_coordinator = HiveCoordinator() +distributed_coordinator = DistributedCoordinator() @asynccontextmanager async def lifespan(app: FastAPI): - """Application lifespan manager""" - # Startup - print("šŸš€ Starting Hive Orchestrator...") + """Enhanced application lifespan manager with proper error handling""" + startup_success = False - # Create database tables - Base.metadata.create_all(bind=engine) + try: + # Startup + print("šŸš€ Starting Hive Orchestrator...") + + # Initialize database with retry logic + print("šŸ“Š Initializing database...") + init_database_with_retry() + + # Test database connection + if not test_database_connection(): + raise Exception("Database connection test failed") + + # Initialize coordinators with error handling + print("šŸ¤– Initializing AI coordinator...") + await hive_coordinator.initialize() + + print("šŸŒ Initializing distributed coordinator...") + await distributed_coordinator.start() + + # Initialize MCP server + # print("šŸ”Œ Initializing MCP server...") + # mcp_server = get_mcp_server() + # await mcp_server.initialize(distributed_coordinator) + + startup_success = True + print("āœ… Hive Orchestrator with distributed workflows started successfully!") + + yield + + except Exception as e: + print(f"āŒ Startup failed: {e}") + if startup_success: + # If we got past startup, try to shutdown cleanly + try: + await hive_coordinator.shutdown() + await distributed_coordinator.stop() + except Exception as shutdown_error: + print(f"Shutdown error during startup failure: {shutdown_error}") + raise - # Initialize coordinator - await hive_coordinator.initialize() - - print("āœ… Hive Orchestrator started successfully!") - - yield - - # Shutdown - print("šŸ›‘ Shutting down Hive Orchestrator...") - await hive_coordinator.shutdown() - print("āœ… Hive Orchestrator stopped") + finally: + # Shutdown + print("šŸ›‘ Shutting down Hive Orchestrator...") + try: + await hive_coordinator.shutdown() + await distributed_coordinator.stop() + print("āœ… Hive Orchestrator stopped") + except Exception as e: + print(f"āŒ Shutdown error: {e}") # Create FastAPI application app = FastAPI( @@ -46,10 +85,15 @@ app = FastAPI( lifespan=lifespan ) -# Enable CORS +# Enhanced CORS configuration for production app.add_middleware( CORSMiddleware, - allow_origins=["http://localhost:3000", "http://localhost:3001"], + allow_origins=[ + "http://localhost:3000", + "http://localhost:3001", + "https://hive.home.deepblack.cloud", + "http://hive.home.deepblack.cloud" + ], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], @@ -62,107 +106,117 @@ app.include_router(executions.router, prefix="/api", tags=["executions"]) app.include_router(monitoring.router, prefix="/api", tags=["monitoring"]) app.include_router(projects.router, prefix="/api", tags=["projects"]) app.include_router(tasks.router, prefix="/api", tags=["tasks"]) +app.include_router(cluster.router, prefix="/api", tags=["cluster"]) +app.include_router(distributed_workflows.router, tags=["distributed-workflows"]) # Set coordinator reference in tasks module tasks.set_coordinator(hive_coordinator) -# WebSocket connection manager -class ConnectionManager: - def __init__(self): - self.active_connections: dict[str, list[WebSocket]] = {} - self.execution_connections: dict[str, list[WebSocket]] = {} +# Socket.IO server setup +sio = socketio.AsyncServer( + async_mode='asgi', + cors_allowed_origins="*", + logger=True, + engineio_logger=False +) - async def connect(self, websocket: WebSocket, topic: str = "general"): - await websocket.accept() - - if topic not in self.active_connections: - self.active_connections[topic] = [] - self.active_connections[topic].append(websocket) +# Socket.IO event handlers +@sio.event +async def connect(sid, environ): + """Handle client connection""" + print(f"šŸ”Œ Socket.IO client {sid} connected") + await sio.emit('connection_confirmed', { + 'status': 'connected', + 'timestamp': datetime.now().isoformat(), + 'message': 'Connected to Hive Socket.IO server' + }, room=sid) - def disconnect(self, websocket: WebSocket, topic: str = "general"): - if topic in self.active_connections: - if websocket in self.active_connections[topic]: - self.active_connections[topic].remove(websocket) - if not self.active_connections[topic]: - del self.active_connections[topic] +@sio.event +async def disconnect(sid): + """Handle client disconnection""" + print(f"šŸ”Œ Socket.IO client {sid} disconnected") - async def send_to_topic(self, topic: str, message: dict): - """Send message to all clients subscribed to a topic""" - if topic in self.active_connections: - disconnected = [] - for connection in self.active_connections[topic]: - try: - await connection.send_text(json.dumps(message)) - except: - disconnected.append(connection) - - # Clean up disconnected connections - for conn in disconnected: - self.active_connections[topic].remove(conn) - - async def broadcast(self, message: dict): - """Broadcast message to all connected clients""" - for connections in self.active_connections.values(): - disconnected = [] - for connection in connections: - try: - await connection.send_text(json.dumps(message)) - except: - disconnected.append(connection) - - # Clean up disconnected connections - for conn in disconnected: - connections.remove(conn) - -manager = ConnectionManager() - -@app.websocket("/ws/{topic}") -async def websocket_endpoint(websocket: WebSocket, topic: str): - """WebSocket endpoint for real-time updates""" - await manager.connect(websocket, topic) +@sio.event +async def join_room(sid, data): + """Handle client joining a room/topic""" + room = data.get('room', 'general') + await sio.enter_room(sid, room) + print(f"šŸ”Œ Client {sid} joined room: {room}") - try: - # Send initial connection confirmation - await websocket.send_text(json.dumps({ - "type": "connection", - "topic": topic, - "status": "connected", - "timestamp": datetime.now().isoformat(), - "message": f"Connected to {topic} updates" - })) - - # Keep connection alive and handle client messages - while True: - try: - # Wait for messages from client - data = await asyncio.wait_for(websocket.receive_text(), timeout=30.0) - - # Handle client messages (ping, subscription updates, etc.) - try: - client_message = json.loads(data) - if client_message.get("type") == "ping": - await websocket.send_text(json.dumps({ - "type": "pong", - "timestamp": datetime.now().isoformat() - })) - except json.JSONDecodeError: - pass - - except asyncio.TimeoutError: - # Send periodic heartbeat - await websocket.send_text(json.dumps({ - "type": "heartbeat", - "topic": topic, - "timestamp": datetime.now().isoformat() - })) - except: - break - - except WebSocketDisconnect: - manager.disconnect(websocket, topic) - except Exception as e: - print(f"WebSocket error for topic {topic}: {e}") - manager.disconnect(websocket, topic) + await sio.emit('room_joined', { + 'room': room, + 'timestamp': datetime.now().isoformat(), + 'message': f'Successfully joined {room} room' + }, room=sid) + +@sio.event +async def leave_room(sid, data): + """Handle client leaving a room/topic""" + room = data.get('room', 'general') + await sio.leave_room(sid, room) + print(f"šŸ”Œ Client {sid} left room: {room}") + + await sio.emit('room_left', { + 'room': room, + 'timestamp': datetime.now().isoformat(), + 'message': f'Successfully left {room} room' + }, room=sid) + +@sio.event +async def subscribe(sid, data): + """Handle event subscription""" + events = data.get('events', []) + room = data.get('room', 'general') + + # Join the room if not already joined + await sio.enter_room(sid, room) + + print(f"šŸ”Œ Client {sid} subscribed to events: {events} in room: {room}") + + await sio.emit('subscription_confirmed', { + 'events': events, + 'room': room, + 'timestamp': datetime.now().isoformat(), + 'message': f'Subscribed to {len(events)} events in {room} room' + }, room=sid) + +@sio.event +async def ping(sid): + """Handle ping from client""" + await sio.emit('pong', { + 'timestamp': datetime.now().isoformat() + }, room=sid) + +# Socket.IO connection manager +class SocketIOManager: + def __init__(self, socketio_server): + self.sio = socketio_server + + async def send_to_room(self, room: str, event: str, data: dict): + """Send event to all clients in a room""" + try: + await self.sio.emit(event, data, room=room) + except Exception as e: + print(f"Error sending to room {room}: {e}") + + async def broadcast(self, event: str, data: dict): + """Broadcast event to all connected clients""" + try: + await self.sio.emit(event, data) + except Exception as e: + print(f"Error broadcasting event {event}: {e}") + + async def send_to_client(self, sid: str, event: str, data: dict): + """Send event to a specific client""" + try: + await self.sio.emit(event, data, room=sid) + except Exception as e: + print(f"Error sending to client {sid}: {e}") + +manager = SocketIOManager(sio) + +# Socket.IO integration with FastAPI +# The socket.io server is integrated below in the app creation @app.get("/") async def root(): @@ -176,25 +230,50 @@ async def root(): } @app.get("/health") +async def health_check_internal(): + """Internal health check endpoint for Docker and monitoring""" + return {"status": "healthy", "timestamp": datetime.now().isoformat()} + +@app.get("/api/health") async def health_check(): - """Health check endpoint""" - try: - # Check coordinator health - coordinator_status = await hive_coordinator.get_health_status() - - return { - "status": "healthy", - "timestamp": datetime.now().isoformat(), - "version": "1.0.0", - "components": { - "api": "operational", - "coordinator": coordinator_status.get("status", "unknown"), - "database": "operational", - "agents": coordinator_status.get("agents", {}) - } + """Enhanced health check endpoint with comprehensive status""" + health_status = { + "status": "healthy", + "timestamp": datetime.now().isoformat(), + "version": "1.0.0", + "components": { + "api": "operational", + "database": "unknown", + "coordinator": "unknown", + "agents": {} } + } + + # Test database connection + try: + if test_database_connection(): + health_status["components"]["database"] = "operational" + else: + health_status["components"]["database"] = "unhealthy" + health_status["status"] = "degraded" except Exception as e: - raise HTTPException(status_code=503, detail=f"Service unhealthy: {str(e)}") + health_status["components"]["database"] = f"error: {str(e)}" + health_status["status"] = "degraded" + + # Test coordinator health + try: + coordinator_status = await hive_coordinator.get_health_status() + health_status["components"]["coordinator"] = coordinator_status.get("status", "unknown") + health_status["components"]["agents"] = coordinator_status.get("agents", {}) + except Exception as e: + health_status["components"]["coordinator"] = f"error: {str(e)}" + health_status["status"] = "degraded" + + # Return appropriate status code + if health_status["status"] == "degraded": + raise HTTPException(status_code=503, detail=health_status) + + return health_status @app.get("/api/status") async def get_system_status(): @@ -206,13 +285,17 @@ async def get_metrics(): """Prometheus metrics endpoint""" return await hive_coordinator.get_prometheus_metrics() -# Make manager available to other modules -app.state.websocket_manager = manager +# Make manager and coordinators available to other modules +app.state.socketio_manager = manager app.state.hive_coordinator = hive_coordinator +app.state.distributed_coordinator = distributed_coordinator + +# Create Socket.IO ASGI app +socket_app = socketio.ASGIApp(sio, other_asgi_app=app, socketio_path='/socket.io') if __name__ == "__main__": uvicorn.run( - "app.main:app", + "app.main:socket_app", host="0.0.0.0", port=8000, reload=True, diff --git a/docker-compose.swarm.yml b/docker-compose.swarm.yml index 0bf6d8e6..d02c2aec 100644 --- a/docker-compose.swarm.yml +++ b/docker-compose.swarm.yml @@ -14,11 +14,13 @@ services: depends_on: - postgres - redis + ports: + - "8087:8000" networks: - hive-network - tengig deploy: - replicas: 2 + replicas: 1 restart_policy: condition: on-failure delay: 5s @@ -28,13 +30,27 @@ services: memory: 512M reservations: memory: 256M - labels: - - "traefik.enable=true" - - "traefik.http.routers.hive-api.rule=Host(`hive.home.deepblack.cloud`) && PathPrefix(`/api`)" - - "traefik.http.routers.hive-api.entrypoints=web-secured" - - "traefik.http.routers.hive-api.tls.certresolver=letsencryptresolver" - - "traefik.http.services.hive-api.loadbalancer.server.port=8000" - - "traefik.docker.network=tengig" + placement: + constraints: [] + labels: + - "traefik.enable=true" + - "traefik.docker.network=tengig" + # API routes + - "traefik.http.routers.hive-api.rule=Host(`hive.home.deepblack.cloud`) && PathPrefix(`/api`)" + - "traefik.http.routers.hive-api.entrypoints=web,web-secured" + - "traefik.http.routers.hive-api.tls.certresolver=letsencryptresolver" + - "traefik.http.routers.hive-api.service=hive-api" + - "traefik.http.routers.hive-api.priority=200" + - "traefik.http.services.hive-api.loadbalancer.server.port=8000" + - "traefik.http.services.hive-api.loadbalancer.passhostheader=true" + # Socket.IO routes + - "traefik.http.routers.hive-socketio.rule=Host(`hive.home.deepblack.cloud`) && PathPrefix(`/socket.io`)" + - "traefik.http.routers.hive-socketio.entrypoints=web,web-secured" + - "traefik.http.routers.hive-socketio.tls.certresolver=letsencryptresolver" + - "traefik.http.routers.hive-socketio.service=hive-socketio" + - "traefik.http.routers.hive-socketio.priority=200" + - "traefik.http.services.hive-socketio.loadbalancer.server.port=8000" + - "traefik.http.services.hive-socketio.loadbalancer.passhostheader=true" # Hive Frontend hive-frontend: @@ -43,15 +59,17 @@ services: context: ./frontend dockerfile: Dockerfile environment: - - REACT_APP_API_URL=https://hive.home.deepblack.cloud/api - - REACT_APP_WS_URL=wss://hive.home.deepblack.cloud/ws + - REACT_APP_API_URL=https://hive.home.deepblack.cloud + - REACT_APP_SOCKETIO_URL=https://hive.home.deepblack.cloud depends_on: - hive-backend + ports: + - "3001:3000" networks: - hive-network - tengig deploy: - replicas: 2 + replicas: 1 restart_policy: condition: on-failure delay: 5s @@ -61,17 +79,19 @@ services: memory: 256M reservations: memory: 128M - labels: - - "traefik.enable=true" - - "traefik.http.routers.hive.rule=Host(`hive.home.deepblack.cloud`)" - - "traefik.http.routers.hive.entrypoints=web-secured" - - "traefik.http.routers.hive.tls.certresolver=letsencryptresolver" - - "traefik.http.services.hive.loadbalancer.server.port=3000" - - "traefik.docker.network=tengig" - # HTTP redirect to HTTPS - - "traefik.http.routers.hive-web.rule=Host(`hive.home.deepblack.cloud`)" - - "traefik.http.routers.hive-web.entrypoints=web" - - "traefik.http.routers.hive-web.middlewares=redirect-to-https@docker" + placement: + constraints: [] + labels: + - "traefik.enable=true" + - "traefik.docker.network=tengig" + # Frontend routes (catch-all with lower priority) + - "traefik.http.routers.hive-frontend.rule=Host(`hive.home.deepblack.cloud`)" + - "traefik.http.routers.hive-frontend.entrypoints=web,web-secured" + - "traefik.http.routers.hive-frontend.tls.certresolver=letsencryptresolver" + - "traefik.http.routers.hive-frontend.service=hive-frontend" + - "traefik.http.routers.hive-frontend.priority=100" + - "traefik.http.services.hive-frontend.loadbalancer.server.port=3000" + - "traefik.http.services.hive-frontend.loadbalancer.passhostheader=true" # PostgreSQL Database postgres: @@ -83,6 +103,8 @@ services: - PGDATA=/var/lib/postgresql/data/pgdata volumes: - postgres_data:/var/lib/postgresql/data + ports: + - "5433:5432" networks: - hive-network deploy: @@ -97,8 +119,7 @@ services: reservations: memory: 256M placement: - constraints: - - node.role == manager + constraints: [] # Redis Cache redis: @@ -106,6 +127,8 @@ services: command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru volumes: - redis_data:/data + ports: + - "6380:6379" networks: - hive-network deploy: @@ -132,6 +155,8 @@ services: - '--web.enable-lifecycle' volumes: - prometheus_data:/prometheus + ports: + - "9091:9090" networks: - hive-network - tengig @@ -147,15 +172,14 @@ services: reservations: memory: 256M placement: - constraints: - - node.role == manager - labels: - - "traefik.enable=true" - - "traefik.http.routers.hive-prometheus.rule=Host(`hive.home.deepblack.cloud`) && PathPrefix(`/prometheus`)" - - "traefik.http.routers.hive-prometheus.entrypoints=web-secured" - - "traefik.http.routers.hive-prometheus.tls.certresolver=letsencryptresolver" - - "traefik.http.services.hive-prometheus.loadbalancer.server.port=9090" - - "traefik.docker.network=tengig" + constraints: [] + labels: + - "traefik.enable=true" + - "traefik.http.routers.hive-prometheus.rule=Host(`hive.home.deepblack.cloud`) && PathPrefix(`/prometheus`)" + - "traefik.http.routers.hive-prometheus.entrypoints=web-secured" + - "traefik.http.routers.hive-prometheus.tls.certresolver=letsencryptresolver" + - "traefik.http.services.hive-prometheus.loadbalancer.server.port=9090" + - "traefik.docker.network=tengig" # Grafana Dashboard grafana: @@ -170,6 +194,8 @@ services: - grafana_data:/var/lib/grafana depends_on: - prometheus + ports: + - "3002:3000" networks: - hive-network - tengig @@ -185,15 +211,14 @@ services: reservations: memory: 256M placement: - constraints: - - node.role == manager - labels: - - "traefik.enable=true" - - "traefik.http.routers.hive-grafana.rule=Host(`hive.home.deepblack.cloud`) && PathPrefix(`/grafana`)" - - "traefik.http.routers.hive-grafana.entrypoints=web-secured" - - "traefik.http.routers.hive-grafana.tls.certresolver=letsencryptresolver" - - "traefik.http.services.hive-grafana.loadbalancer.server.port=3000" - - "traefik.docker.network=tengig" + constraints: [] + labels: + - "traefik.enable=true" + - "traefik.http.routers.hive-grafana.rule=Host(`hive.home.deepblack.cloud`) && PathPrefix(`/grafana`)" + - "traefik.http.routers.hive-grafana.entrypoints=web-secured" + - "traefik.http.routers.hive-grafana.tls.certresolver=letsencryptresolver" + - "traefik.http.services.hive-grafana.loadbalancer.server.port=3000" + - "traefik.docker.network=tengig" networks: hive-network: diff --git a/mcp-server/src/hive-client.ts b/mcp-server/src/hive-client.ts index ed28c2c3..06302755 100644 --- a/mcp-server/src/hive-client.ts +++ b/mcp-server/src/hive-client.ts @@ -62,8 +62,8 @@ export class HiveClient { constructor(config?: Partial) { this.config = { - baseUrl: process.env.HIVE_API_URL || 'https://hive.home.deepblack.cloud', - wsUrl: process.env.HIVE_WS_URL || 'wss://hive.home.deepblack.cloud', + baseUrl: process.env.HIVE_API_URL || 'https://hive.home.deepblack.cloud/api', + wsUrl: process.env.HIVE_WS_URL || 'wss://hive.home.deepblack.cloud/socket.io', timeout: parseInt(process.env.HIVE_TIMEOUT || '30000'), ...config, }; @@ -80,7 +80,7 @@ export class HiveClient { async testConnection(): Promise { try { const response = await this.api.get('/health'); - return response.data.status === 'healthy'; + return response.data.status === 'healthy' || response.status === 200; } catch (error) { throw new Error(`Failed to connect to Hive: ${error}`); } diff --git a/scripts/register_agents.py b/scripts/register_agents.py index d28af5f0..db59fb35 100755 --- a/scripts/register_agents.py +++ b/scripts/register_agents.py @@ -12,7 +12,7 @@ import time from pathlib import Path # Configuration -HIVE_API_URL = "http://localhost:8087" +HIVE_API_URL = "https://hive.home.deepblack.cloud/api" CONFIG_FILE = "/home/tony/AI/projects/hive/config/hive.yaml" def load_config(): @@ -136,7 +136,7 @@ def main(): if successful_registrations > 0: print(f"\nšŸŽ‰ Successfully registered {successful_registrations} agents!") - print("šŸ”— Check agent status: curl http://localhost:8087/api/agents") + print("šŸ”— Check agent status: curl https://hive.home.deepblack.cloud/api/agents") else: print("\nšŸ’” No agents were successfully registered.") sys.exit(1)