HarborForge.Cli/internal/commands/monitor.go

package commands

import (
	"bytes"
	"encoding/json"
	"fmt"

	"git.hangman-lab.top/zhi/HarborForge.Cli/internal/client"
	"git.hangman-lab.top/zhi/HarborForge.Cli/internal/config"
	"git.hangman-lab.top/zhi/HarborForge.Cli/internal/output"
)

// monitorOverviewResponse matches the backend monitor overview schema.
type monitorOverviewResponse struct {
	Tasks       interface{}             `json:"tasks"`
	Providers   interface{}             `json:"providers"`
	Servers     []monitorServerResponse `json:"servers"`
	GeneratedAt string                  `json:"generated_at"`
}

// monitorServerResponse matches the backend monitor server schema.
type monitorServerResponse struct {
	ID          int     `json:"id"`
	Identifier  string  `json:"identifier"`
	DisplayName *string `json:"display_name"`
	Status      string  `json:"status"`
	LastSeen    *string `json:"last_seen"`
	CreatedAt   string  `json:"created_at"`
}

// monitorAPIKeyResponse matches the backend monitor API key schema.
type monitorAPIKeyResponse struct {
	ServerID int    `json:"server_id"`
	APIKey   string `json:"api_key"`
	Message  string `json:"message"`
}

func monitorServerList(c *client.Client) []monitorServerResponse {
	data, err := c.Get("/monitor/admin/servers")
	if err != nil {
		output.Errorf("failed to list monitor servers: %v", err)
	}
	var servers []monitorServerResponse
	if err := json.Unmarshal(data, &servers); err != nil {
		output.Errorf("cannot parse server list: %v", err)
	}
	return servers
}

func resolveMonitorServerID(c *client.Client, identifier string) int {
	servers := monitorServerList(c)
	for _, s := range servers {
		if s.Identifier == identifier {
			return s.ID
		}
	}
	output.Errorf("monitor server not found: %s", identifier)
	return 0
}

// RunMonitorOverview implements `hf monitor overview`.
func RunMonitorOverview(tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	data, err := c.Get("/monitor/public/overview")
	if err != nil {
		output.Errorf("failed to get monitor overview: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	var o monitorOverviewResponse
	if err := json.Unmarshal(data, &o); err != nil {
		output.Errorf("cannot parse monitor overview: %v", err)
	}

	online := 0
	for _, s := range o.Servers {
		if s.Status == "online" {
			online++
		}
	}
	output.PrintKeyValue(
		"total-servers", fmt.Sprintf("%d", len(o.Servers)),
		"online-servers", fmt.Sprintf("%d", online),
		"generated-at", o.GeneratedAt,
	)
}

// RunMonitorServerList implements `hf monitor server list`.
func RunMonitorServerList(tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	data, err := c.Get("/monitor/admin/servers")
	if err != nil {
		output.Errorf("failed to list monitor servers: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	var servers []monitorServerResponse
	if err := json.Unmarshal(data, &servers); err != nil {
		output.Errorf("cannot parse server list: %v", err)
	}

	headers := []string{"IDENTIFIER", "NAME", "STATUS", "LAST SEEN"}
	var rows [][]string
	for _, s := range servers {
		name := ""
		if s.DisplayName != nil {
			name = *s.DisplayName
		}
		lastSeen := ""
		if s.LastSeen != nil {
			lastSeen = *s.LastSeen
		}
		rows = append(rows, []string{s.Identifier, name, s.Status, lastSeen})
	}
	output.PrintTable(headers, rows)
}

// RunMonitorServerGet implements `hf monitor server get <identifier>`.
func RunMonitorServerGet(identifier, tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	servers := monitorServerList(c)
	var found *monitorServerResponse
	for i := range servers {
		if servers[i].Identifier == identifier {
			found = &servers[i]
			break
		}
	}
	if found == nil {
		output.Errorf("failed to get server: not found: %s", identifier)
	}

	if output.JSONMode {
		output.PrintJSON(found)
		return
	}

	name := ""
	if found.DisplayName != nil {
		name = *found.DisplayName
	}
	lastSeen := ""
	if found.LastSeen != nil {
		lastSeen = *found.LastSeen
	}
	output.PrintKeyValue(
		"identifier", found.Identifier,
		"name", name,
		"status", found.Status,
		"last-seen", lastSeen,
		"created", found.CreatedAt,
	)
}

// RunMonitorServerCreate implements `hf monitor server create --identifier <identifier>`.
func RunMonitorServerCreate(args []string, tokenFlag string) {
	token := ResolveToken(tokenFlag)

	identifier, name := "", ""
	for i := 0; i < len(args); i++ {
		switch args[i] {
		case "--identifier":
			if i+1 >= len(args) {
				output.Error("--identifier requires a value")
			}
			i++
			identifier = args[i]
		case "--name":
			if i+1 >= len(args) {
				output.Error("--name requires a value")
			}
			i++
			name = args[i]
		default:
			output.Errorf("unknown flag: %s", args[i])
		}
	}

	if identifier == "" {
		output.Error("usage: hf monitor server create --identifier <identifier>")
	}

	payload := map[string]interface{}{
		"identifier": identifier,
	}
	if name != "" {
		payload["display_name"] = name
	}

	body, err := json.Marshal(payload)
	if err != nil {
		output.Errorf("cannot marshal payload: %v", err)
	}

	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	data, err := c.Post("/monitor/admin/servers", bytes.NewReader(body))
	if err != nil {
		output.Errorf("failed to create server: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	fmt.Printf("monitor server created: %s\n", identifier)
	_ = data
}

// RunMonitorServerDelete implements `hf monitor server delete <identifier>`.
func RunMonitorServerDelete(identifier, tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	serverID := resolveMonitorServerID(c, identifier)
	_, err = c.Delete(fmt.Sprintf("/monitor/admin/servers/%d", serverID))
	if err != nil {
		output.Errorf("failed to delete server: %v", err)
	}
	fmt.Printf("monitor server deleted: %s\n", identifier)
}

// RunMonitorAPIKeyGenerate implements `hf monitor api-key generate <identifier>`.
func RunMonitorAPIKeyGenerate(identifier, tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	serverID := resolveMonitorServerID(c, identifier)
	data, err := c.Post(fmt.Sprintf("/monitor/admin/servers/%d/api-key", serverID), nil)
	if err != nil {
		output.Errorf("failed to generate API key: %v", err)
	}

	if output.JSONMode {
		var raw json.RawMessage
		if err := json.Unmarshal(data, &raw); err != nil {
			output.Errorf("invalid JSON response: %v", err)
		}
		output.PrintJSON(raw)
		return
	}

	var k monitorAPIKeyResponse
	if err := json.Unmarshal(data, &k); err != nil {
		fmt.Printf("API key generated for: %s\n", identifier)
		return
	}
	output.PrintKeyValue(
		"server-id", fmt.Sprintf("%d", k.ServerID),
		"api-key", k.APIKey,
		"message", k.Message,
	)
}

// RunMonitorAPIKeyRevoke implements `hf monitor api-key revoke <identifier>`.
func RunMonitorAPIKeyRevoke(identifier, tokenFlag string) {
	token := ResolveToken(tokenFlag)
	cfg, err := config.Load()
	if err != nil {
		output.Errorf("config error: %v", err)
	}
	c := client.New(cfg.BaseURL, token)
	serverID := resolveMonitorServerID(c, identifier)
	_, err = c.Delete(fmt.Sprintf("/monitor/admin/servers/%d/api-key", serverID))
	if err != nil {
		output.Errorf("failed to revoke API key: %v", err)
	}
	fmt.Printf("API key revoked for: %s\n", identifier)
}