Authorization: Bearer kiro_sec_DEIN_API_SCHLUESSEL
Content-Type: application/json
Accept: application/json

// kiroClient.ts
export interface BotStatusResponse {
  success: boolean;
  data: {
    id: string;
    name: string;
    status: 'online' | 'offline' | 'starting' | 'error';
    runtimeExpiresAt: string;
    uptimeSeconds: number;
  };
}

export class KiroClient {
  private baseUrl: string;
  private apiKey: string;

  constructor(apiKey: string, baseUrl = 'https://api.kirocloud.de/api/v1') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  private async request<T>(method: string, endpoint: string, body?: unknown): Promise<T> {
    const headers: Record<string, string> = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    };

    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      method,
      headers,
      body: body ? JSON.stringify(body) : undefined,
    });

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({}));
      throw new Error(`KiroCloud API Error [${response.status}]: ${errorData.message || response.statusText}`);
    }

    return response.json() as Promise<T>;
  }

  // --- Public Status & Platform Health ---

  async getPlatformStatus() {
    return this.request<{ success: boolean; data: Record<string, unknown> }>('GET', '/public/status');
  }

  async getPlatformStats() {
    return this.request<{ success: boolean; data: { activeBots: number; activeServers: number; uptime: number } }>('GET', '/public/stats');
  }

  // --- Bot Management (Scope: bots:read, bots:write) ---

  async listBots() {
    return this.request<{ success: boolean; data: Array<{ id: string; name: string; status: string }> }>('GET', '/bots');
  }

  async getBot(botId: string) {
    return this.request<BotStatusResponse>('GET', `/bots/${botId}`);
  }

  async startBot(botId: string) {
    return this.request<{ success: boolean; message: string }>('POST', `/bots/${botId}/start`);
  }

  async stopBot(botId: string) {
    return this.request<{ success: boolean; message: string }>('POST', `/bots/${botId}/stop`);
  }

  async restartBot(botId: string) {
    return this.request<{ success: boolean; message: string }>('POST', `/bots/${botId}/restart`);
  }

  async sendEmbed(botId: string, payload: { channelId: string; embed: Record<string, unknown> }) {
    return this.request<{ success: boolean; messageId: string }>('POST', `/bots/${botId}/send-embed`, payload);
  }

  // --- Support Tickets (Scope: tickets:read, tickets:write) ---

  async listTickets() {
    return this.request<{ success: boolean; data: Array<{ id: string; subject: string; status: string }> }>('GET', '/tickets');
  }

  async createTicket(payload: { subject: string; message: string; priority?: 'low' | 'normal' | 'high' }) {
    return this.request<{ success: boolean; ticketId: string }>('POST', '/tickets', payload);
  }
}

# kiro_client.py
import requests
from typing import Optional, Dict, Any, List

class KiroClient:
    def __init__(self, api_key: str, base_url: str = "https://api.kirocloud.de/api/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
            "Accept": "application/json",
        }

    def _request(self, method: str, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        url = f"{self.base_url}{endpoint}"
        resp = requests.request(method, url, headers=self.headers, json=data, timeout=10)
        if not resp.ok:
            raise Exception(f"KiroCloud API Error [{resp.status_code}]: {resp.text}")
        return resp.json()

    # --- System Status ---
    def get_status(self) -> Dict[str, Any]:
        return self._request("GET", "/public/status")

    def get_stats(self) -> Dict[str, Any]:
        return self._request("GET", "/public/stats")

    # --- Bots ---
    def list_bots(self) -> List[Dict[str, Any]]:
        return self._request("GET", "/bots").get("data", [])

    def get_bot(self, bot_id: str) -> Dict[str, Any]:
        return self._request("GET", f"/bots/{bot_id}")

    def restart_bot(self, bot_id: str) -> Dict[str, Any]:
        return self._request("POST", f"/bots/{bot_id}/restart")

    def send_embed(self, bot_id: str, channel_id: str, embed_data: Dict[str, Any]) -> Dict[str, Any]:
        return self._request("POST", f"/bots/{bot_id}/send-embed", {
            "channelId": channel_id,
            "embed": embed_data,
        })

#!/bin/bash
set -euo pipefail

API_KEY="kiro_sec_YOUR_API_KEY_HERE"
BASE_URL="https://api.kirocloud.de/api/v1"
BOT_ID="00000000-0000-0000-0000-000000000000"

echo "Checking platform health..."
curl -s -f -X GET "$BASE_URL/public/status" \
  -H "Accept: application/json" | jq .

echo "Restarting bot instance after deployment..."
curl -s -f -X POST "$BASE_URL/bots/$BOT_ID/restart" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" | jq .

{
  "success": true,
  "data": {
    "overall": "operational",
    "services": {
      "database": "operational",
      "botEngine": "operational",
      "minecraftNodes": "operational"
    },
    "timestamp": "2026-10-09T00:00:00.000Z"
  }
}

{
  "channelId": "123456789012345678",
  "embed": {
    "title": "Wartungsarbeiten abgeschlossen",
    "description": "Alle Systeme laufen wieder mit voller Leistung.",
    "color": 3447003
  }
}

{
  "subject": "Frage zur Bot-Skalierung",
  "message": "Wie kann ich die Shard-Anzahl für meinen Bot dynamisch anpassen?",
  "priority": "normal"
}