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

// kiroClient.js
export class KiroClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.kirocloud.de/api/v1';
  }

  async _request(method, endpoint, body = null) {
    const headers = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json'
    };

    const options = { method, headers };
    if (body) {
      options.body = JSON.stringify(body);
    }

    const response = await fetch(`${this.baseUrl}${endpoint}`, options);
    const data = await response.json();

    if (!response.ok) {
      throw new Error(`KiroCloud API Error: ${response.status} - ${data.statusMessage || JSON.stringify(data)}`);
    }

    return data;
  }

  // --- System & Metriken (Scope: system:read) ---
  
  async getDiagnostics() {
    return this._request('GET', '/admin/devs/diagnostics');
  }
  
  async getHealth() {
    return this._request('GET', '/admin/system/health');
  }

  // --- Tickets (Scopes: tickets:read, tickets:write) ---
  
  async getTickets() {
    return this._request('GET', '/admin/tickets');
  }
  
  async getUnreadTickets() {
    return this._request('GET', '/admin/tickets/unread');
  }
  
  async closeTicket(ticketId) {
    return this._request('POST', `/admin/tickets/${ticketId}/close`);
  }
  
  async getTicketNotes(ticketId) {
    return this._request('GET', `/admin/tickets/${ticketId}/notes`);
  }
  
  async addTicketNote(ticketId, content) {
    return this._request('POST', `/admin/tickets/${ticketId}/notes`, { content });
  }
  
  async assignTicket(ticketId, userId) {
    return this._request('POST', `/admin/tickets/${ticketId}/assign`, { userId });
  }

  // --- Bots (Scopes: bots:read, bots:write) ---
  
  async getBotLogs(botId) {
    return this._request('GET', `/admin/bots/${botId}/logs`);
  }
  
  async setBotPower(botId, action) {
    // action: 'start' | 'stop' | 'restart' | 'kill'
    return this._request('POST', `/admin/bots/${botId}/power`, { action });
  }
  
  async bulkActionBots(botIds, action) {
    return this._request('POST', '/admin/bots/bulk', { botIds, action });
  }

  // --- Users (Scopes: users:read, users:write) ---
  
  async getUsers() {
    return this._request('GET', '/admin/users');
  }
  
  async searchUsers(query) {
    return this._request('GET', `/admin/users/search?q=${encodeURIComponent(query)}`);
  }
  
  async getUserProfile(userId) {
    return this._request('GET', `/admin/users/${userId}`);
  }
  
  async banUser(userId, reason) {
    return this._request('POST', `/admin/users/${userId}/ban`, { reason });
  }
}

# kiro_client.py
import requests

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

    def _request(self, method: str, endpoint: str, json_data=None):
        url = f"{self.base_url}{endpoint}"
        response = requests.request(method, url, headers=self.headers, json=json_data)
        
        if not response.ok:
            raise Exception(f"KiroCloud API Error: {response.status_code} - {response.text}")
            
        return response.json()

    # --- System ---
    def get_diagnostics(self):
        return self._request("GET", "/admin/devs/diagnostics")
        
    def get_health(self):
        return self._request("GET", "/admin/system/health")

    # --- Tickets ---
    def get_tickets(self):
        return self._request("GET", "/admin/tickets")
        
    def get_unread_tickets(self):
        return self._request("GET", "/admin/tickets/unread")
        
    def close_ticket(self, ticket_id: str):
        return self._request("POST", f"/admin/tickets/{ticket_id}/close")
        
    def add_ticket_note(self, ticket_id: str, content: str):
        return self._request("POST", f"/admin/tickets/{ticket_id}/notes", {"content": content})
        
    def assign_ticket(self, ticket_id: str, user_id: str):
        return self._request("POST", f"/admin/tickets/{ticket_id}/assign", {"userId": user_id})

    # --- Bots ---
    def get_bot_logs(self, bot_id: str):
        return self._request("GET", f"/admin/bots/{bot_id}/logs")
        
    def set_bot_power(self, bot_id: str, action: str):
        return self._request("POST", f"/admin/bots/{bot_id}/power", {"action": action})
        
    def bulk_action_bots(self, bot_ids: list, action: str):
        return self._request("POST", "/admin/bots/bulk", {"botIds": bot_ids, "action": action})

    # --- Users ---
    def search_users(self, query: str):
        return self._request("GET", f"/admin/users/search?q={query}")
        
    def get_user(self, user_id: str):
        return self._request("GET", f"/admin/users/{user_id}")
        
    def ban_user(self, user_id: str, reason: str):
        return self._request("POST", f"/admin/users/{user_id}/ban", {"reason": reason})

<?php
class KiroClient {
    private $apiKey;
    private $baseUrl = 'https://api.kirocloud.de/api/v1';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    private function request($method, $endpoint, $data = null) {
        $ch = curl_init($this->baseUrl . $endpoint);
        
        $headers = [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json',
            'Accept: application/json'
        ];
        
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
        
        if ($data) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode >= 400) {
            throw new Exception("KiroCloud API Error: $httpCode - $response");
        }
        
        return json_decode($response, true);
    }

    public function getDiagnostics() {
        return $this->request('GET', '/admin/devs/diagnostics');
    }
    
    public function getTickets() {
        return $this->request('GET', '/admin/tickets');
    }
    
    public function setBotPower($botId, $action) {
        return $this->request('POST', "/admin/bots/$botId/power", ['action' => $action]);
    }
    
    public function banUser($userId, $reason) {
        return $this->request('POST', "/admin/users/$userId/ban", ['reason' => $reason]);
    }
}

package main

import (
 "bytes"
 "encoding/json"
 "fmt"
 "io"
 "net/http"
)

type KiroClient struct {
 APIKey  string
 BaseURL string
 Client  *http.Client
}

func NewKiroClient(apiKey string) *KiroClient {
 return &KiroClient{
  APIKey:  apiKey,
  BaseURL: "https://api.kirocloud.de/api/v1",
  Client:  &http.Client{},
 }
}

func (k *KiroClient) Request(method, endpoint string, bodyData interface{}) ([]byte, error) {
 var reqBody io.Reader
 if bodyData != nil {
  jsonBody, _ := json.Marshal(bodyData)
  reqBody = bytes.NewBuffer(jsonBody)
 }

 req, err := http.NewRequest(method, k.BaseURL+endpoint, reqBody)
 if err != nil {
  return nil, err
 }

 req.Header.Set("Authorization", "Bearer "+k.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := k.Client.Do(req)
 if err != nil {
  return nil, err
 }
 defer resp.Body.Close()

 bodyBytes, _ := io.ReadAll(resp.Body)
 if resp.StatusCode >= 400 {
  return nil, fmt.Errorf("API Error %d: %s", resp.StatusCode, string(bodyBytes))
 }
 
 return bodyBytes, nil
}

#!/bin/bash
API_KEY="kiro_adm_DEIN_SCHLUESSEL_HIER"
BASE_URL="https://api.kirocloud.de/api/v1"

# 1. System Health abfragen
curl -s -X GET "$BASE_URL/admin/system/health" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Accept: application/json" | jq '.'

# 2. Bot neustarten
curl -s -X POST "$BASE_URL/admin/bots/1234567890/power" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action":"restart"}' | jq '.'