Cloud Integrations

server/connectors/
├── gcp_connector/
│   ├── README.md          # OAuth setup guide
│   ├── connector.py       # GCP authentication logic
│   └── service_account.json  # Service account credentials
├── aws_connector/
│   ├── README.md          # IAM Role setup guide
│   └── connector.py       # AWS authentication logic
├── azure_connector/
│   ├── README.md          # Service Principal guide
│   └── connector.py       # Azure authentication logic
├── ovh_connector/
│   ├── README.md          # OVH OAuth guide
│   └── connector.py       # OVH multi-region auth
└── README.md              # Connector overview

# Reference stored in database
user_tokens.token = "vault:kv/data/aurora/users/user_abc123/gcp"

# Retrieved at runtime
from utils.vault.vault_client import vault_get
credentials = vault_get(user_tokens.token)
# Returns: {"access_token": "...", "refresh_token": "...", "project_id": "..."}

# server/chat/backend/agent/tools/cloud_tools.py
@tool("cloud_tool")
def cloud_tool(
    provider: str,
    command: str,
    selected_project_id: Optional[str] = None,
    confirmation_id: Optional[str] = None
) -> str:
    """
    Execute cloud provider CLI commands.
    
    Args:
        provider: Cloud provider - gcp, aws, azure, scaleway, tailscale, ovh
        command: Command to execute (e.g., 'gcloud compute instances list')
        selected_project_id: Project/account ID to scope command
        confirmation_id: ID for user confirmation on write operations
    
    Returns:
        JSON with command output, status, and metadata
    """
    # Validation
    if provider not in SUPPORTED_PROVIDERS:
        return {"error": f"Unsupported provider: {provider}"}
    
    # Read-only check in Ask mode
    if mode == "ask" and not is_read_only_command(command):
        return {"error": "Write operations not allowed in Ask mode"}
    
    # Require confirmation for destructive operations
    if is_destructive_command(command) and not confirmation_id:
        return {"requires_confirmation": True, "confirmation_id": generate_id()}
    
    # Execute command
    result = execute_cloud_command(provider, command, user_id, selected_project_id)
    return result

def is_read_only_command(command: str) -> bool:
    """Check if command is read-only (safe in Ask mode)."""
    read_only_patterns = [
        r'^gcloud .* (list|describe|get|show)',
        r'^aws .* (describe|list|get)',
        r'^az .* (list|show|get)',
        r'^kubectl (get|describe)',
    ]
    
    for pattern in read_only_patterns:
        if re.match(pattern, command.strip()):
            return True
    return False

def is_destructive_command(command: str) -> bool:
    """Check if command requires user confirmation."""
    destructive_patterns = [
        r'delete', r'remove', r'destroy', r'terminate',
        r'drop', r'truncate', r'--force'
    ]
    
    return any(re.search(pattern, command.lower()) for pattern in destructive_patterns)

You: "List all GCP compute instances in my production project"

Aurora: I'll check your GCP instances.

[Executing: gcloud compute instances list --project=prod-123]

NAME          ZONE        MACHINE_TYPE   STATUS
api-server-1  us-west1-a  n1-standard-4  RUNNING
api-server-2  us-west1-b  n1-standard-4  RUNNING
db-primary    us-west1-a  n1-highmem-8   RUNNING

You have 3 instances running in production.

You: "Delete the test-instance in GCP"

Aurora: I cannot execute delete operations in Ask mode. 
Switch to Agent mode to perform this action.

You: "Compare my GCP and AWS instance counts"

Aurora: Let me check both providers.

[Executing: gcloud compute instances list --format=json]
[Executing: aws ec2 describe-instances --output json]

GCP: 12 instances across 3 projects
AWS: 8 instances across 2 regions

Total: 20 instances across both clouds.

// Frontend sends provider preference with each message
webSocket.send(JSON.stringify({
  query: "List all instances",
  provider_preference: ["gcp", "aws"],  // Only use these providers
  selected_project_id: "my-gcp-project"  // Scope to specific project
}));

# Prevent command injection
def sanitize_command(command: str) -> str:
    """Remove dangerous characters from command."""
    if any(c in command for c in [';', '&&', '||', '|', '>', '<', '`', '$']):
        raise ValueError("Command contains forbidden characters")
    return command.strip()

GET /api/auth/{provider}

GET /api/auth/{provider}/callback?code={auth_code}

GET /api/user/connected-providers

{
  "providers": ["gcp", "aws", "azure"],
  "default_provider": "gcp"
}

DELETE /api/auth/{provider}/disconnect