fix undefined TrackUsage and cleanup keys.go

internal/handler/anthropic.go

@@ -19,28 +19,30 @@ import (
 
 // HandleMessages handles Anthropic Messages API requests (/v1/messages)
 func HandleMessages(w http.ResponseWriter, r *http.Request) {
-apiKey := r.Header.Get("x-api-key")
-if apiKey == "" { apiKey = strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ") }
-if apiKey == "" {
-writeAnthropicError(w, http.StatusUnauthorized, "authentication_error", "Missing API key")
-return
-}
-ok, reason := CheckAndTrack(apiKey, 0)
-if !ok {
-writeAnthropicError(w, http.StatusTooManyRequests, "rate_limit_error", reason)
-return
-}
-token := apiKey
+	apiKey := r.Header.Get("x-api-key")
+	if apiKey == "" {
+		apiKey = strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
+	}
+	if apiKey == "" {
+		writeAnthropicError(w, http.StatusUnauthorized, "authentication_error", "Missing API key")
+		return
+	}
+	ok, reason := CheckAndTrack(apiKey, 0)
+	if !ok {
+		writeAnthropicError(w, http.StatusTooManyRequests, "rate_limit_error", reason)
+		return
+	}
+	token := apiKey
 	defer func() { TrackUsage(apiKey, 150) }()
-if token == "free" || strings.HasPrefix(token, "RWPX-") {
-anonymousToken, err := auth.GetAnonymousToken()
-if err != nil {
-logger.LogError("Failed to get anonymous token: %v", err)
-writeAnthropicError(w, http.StatusInternalServerError, "api_error", "Failed to get anonymous token")
-return
-}
-token = anonymousToken
-}
+	if token == "free" || strings.HasPrefix(token, "RWPX-") {
+		anonymousToken, err := auth.GetAnonymousToken()
+		if err != nil {
+			logger.LogError("Failed to get anonymous token: %v", err)
+			writeAnthropicError(w, http.StatusInternalServerError, "api_error", "Failed to get anonymous token")
+			return
+		}
+		token = anonymousToken
+	}
 	var req model.AnthropicRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeAnthropicError(w, http.StatusBadRequest, "invalid_request_error", "Invalid request body")

internal/handler/chat.go

@@ -19,29 +19,31 @@ import (
 )
 
 func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
-apiKey := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
-if apiKey == "" { apiKey = r.Header.Get("x-api-key") }
-if apiKey == "" {
-http.Error(w, "Unauthorized", http.StatusUnauthorized)
-return
-}
-ok, reason := CheckAndTrack(apiKey, 0)
-if !ok {
-http.Error(w, reason, http.StatusTooManyRequests)
-return
-}
-token := apiKey
+	apiKey := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
+	if apiKey == "" {
+		apiKey = r.Header.Get("x-api-key")
+	}
+	if apiKey == "" {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+	ok, reason := CheckAndTrack(apiKey, 0)
+	if !ok {
+		http.Error(w, reason, http.StatusTooManyRequests)
+		return
+	}
+	token := apiKey
 	// Estimación simple de tokens (4 chars = 1 token)
 	defer func() { TrackUsage(apiKey, 100) }()
-if token == "free" || strings.HasPrefix(token, "RWPX-") {
-anonymousToken, err := auth.GetAnonymousToken()
-if err != nil {
-logger.LogError("Failed to get anonymous token: %v", err)
-http.Error(w, "Failed to get anonymous token", http.StatusInternalServerError)
-return
-}
-token = anonymousToken
-}
+	if token == "free" || strings.HasPrefix(token, "RWPX-") {
+		anonymousToken, err := auth.GetAnonymousToken()
+		if err != nil {
+			logger.LogError("Failed to get anonymous token: %v", err)
+			http.Error(w, "Failed to get anonymous token", http.StatusInternalServerError)
+			return
+		}
+		token = anonymousToken
+	}
 	var req model.ChatRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "Invalid request", http.StatusBadRequest)

internal/handler/index.go

@@ -1,18 +1,18 @@
 package handler
 
 import (
-_ "embed"
-"net/http"
+	_ "embed"
+	"net/http"
 )
 
 //go:embed index.html
 var indexHTML []byte
 
 func HandleIndex(w http.ResponseWriter, r *http.Request) {
-if r.URL.Path != "/" {
-http.NotFound(w, r)
-return
-}
-w.Header().Set("Content-Type", "text/html; charset=utf-8")
-w.Write(indexHTML)
+	if r.URL.Path != "/" {
+		http.NotFound(w, r)
+		return
+	}
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.Write(indexHTML)
 }

internal/handler/keys.go

@@ -10,28 +10,20 @@ import (
 )
 
 type KeyData struct {
-	Name        string    `json:"name"`
-	Key         string    `json:"key"`
-	Requests    int       `json:"requests"`
-	Tokens      int       `json:"tokens"`
-	DailyReqs   int       `json:"daily_reqs"`
-	LastReset   time.Time `json:"last_reset"`
-	Created     time.Time `json:"created"`
-	LastUsed    time.Time `json:"last_used"`
-	IsAdmin     bool      `json:"is_admin"`
+	Name     string    `json:"name"`
+	Key      string    `json:"key"`
+	Requests int       `json:"requests"`
+	Tokens   int       `json:"tokens"`
+	Created  time.Time `json:"created"`
+	LastUsed time.Time `json:"last_used"`
 }
-
 type KeyStore struct {
-	mu      sync.Mutex
-	Keys    map[string]*KeyData `json:"keys"`
-	FreeReqs int               `json:"free_reqs"`
-	FreeReset time.Time        `json:"free_reset"`
+	mu   sync.Mutex
+	Keys map[string]*KeyData `json:"keys"`
 }
 
 var store = &KeyStore{Keys: make(map[string]*KeyData)}
 var storePath = "/data/keys.json"
-const freeDailyLimit = 340
-const keyDailyLimit = 9999
 
 func init() {
 	os.MkdirAll("/data", 0755)
@@ -43,44 +35,34 @@ func init() {
 		store.Keys = make(map[string]*KeyData)
 	}
 }
-
 func saveStore() {
 	data, _ := json.MarshalIndent(store, "", "  ")
 	os.WriteFile(storePath, data, 0644)
 }
-
-func resetIfNewDay(t *time.Time, count *int) {
-	if time.Since(*t) > 24*time.Hour {
-		*count = 0
-		*t = time.Now()
+func TrackUsage(key string, tokens int) {
+	if key == "free" {
+		return
 	}
-}
-
-func CheckAndTrack(key string, tokens int) (bool, string) {
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	if key == "free" {
-		resetIfNewDay(&store.FreeReset, &store.FreeReqs)
-		if store.FreeReqs >= freeDailyLimit {
-			return false, "Limite diario de free alcanzado (340/dia). Obtiene una key RWPX en /genkey"
-		}
-		store.FreeReqs++
+	if kd, ok := store.Keys[key]; ok {
+		kd.Requests++
+		kd.Tokens += tokens
+		kd.LastUsed = time.Now()
 		saveStore()
+	}
+}
+func CheckAndTrack(key string, tokens int) (bool, string) {
+	if key == "free" {
 		return true, ""
 	}
-	kd, ok := store.Keys[key]
-	if !ok {
-		return false, "Key invalida"
+	store.mu.Lock()
+	defer store.mu.Unlock()
+	if _, ok := store.Keys[key]; ok {
+		return true, ""
 	}
-	resetIfNewDay(&kd.LastReset, &kd.DailyReqs)
-	kd.Requests++
-	kd.Tokens += tokens
-	kd.DailyReqs++
-	kd.LastUsed = time.Now()
-	saveStore()
-	return true, ""
+	return false, "Key invalida"
 }
-
 func GenerateKey(name string) string {
 	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
 	b := make([]byte, 8)
@@ -89,36 +71,21 @@ func GenerateKey(name string) string {
 	}
 	key := "RWPX-" + string(b)
 	store.mu.Lock()
-	store.Keys[key] = &KeyData{
-		Name:      name,
-		Key:       key,
-		Created:   time.Now(),
-		LastReset: time.Now(),
-	}
+	store.Keys[key] = &KeyData{Name: name, Key: key, Created: time.Now()}
 	saveStore()
 	store.mu.Unlock()
 	return key
 }
-
 func HandleGenKey(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "POST" {
-		http.Error(w, "Method not allowed", 405)
-		return
-	}
 	name := r.FormValue("name")
 	if name == "" {
 		name = "usuario"
 	}
 	key := GenerateKey(name)
-	w.Header().Set("Content-Type", "application/json")
-	resp := map[string]string{"key": key, "name": name}
-	json.NewEncoder(w).Encode(resp)
+	json.NewEncoder(w).Encode(map[string]string{"key": key, "name": name})
 }
-
 func HandleStats(w http.ResponseWriter, r *http.Request) {
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	w.Header().Set("Content-Type", "application/json")
-	data, _ := json.Marshal(store)
-	w.Write(data)
-}
+	json.NewEncoder(w).Encode(store)
+}