fix: core database stability and crash prevention

internal/handler/keys.go

@@ -9,120 +9,62 @@ import (
     "time"
 )
 type KeyData struct {
-    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"`
+    Name     string `json:"name"`
+    Key      string `json:"key"`
+    Requests int    `json:"requests"`
+    Tokens   int    `json:"tokens"`
 }
 type KeyStore struct {
-    mu   sync.Mutex
+    mu   sync.RWMutex
     Keys map[string]*KeyData `json:"keys"`
 }
 var store = &KeyStore{Keys: make(map[string]*KeyData)}
-var storePath = "/data/keys.json"
+const storePath = "/data/keys.json"
 func init() {
     os.MkdirAll("/data", 0755)
-    data, err := os.ReadFile(storePath)
-    if err == nil { json.Unmarshal(data, store) }
+    if _, err := os.Stat(storePath); err == nil {
+        data, _ := os.ReadFile(storePath)
+        json.Unmarshal(data, store)
+    }
     if store.Keys == nil { store.Keys = make(map[string]*KeyData) }
 }
-func saveStore() {
-    data, _ := json.MarshalIndent(store, "", "  ")
+func save() {
+    data, _ := json.Marshal(store)
     os.WriteFile(storePath, data, 0644)
 }
-func TrackUsage(key string, tokens int) {
-    if key == "free" { return }
-    store.mu.Lock()
-    defer store.mu.Unlock()
-    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, "" }
-    store.mu.Lock()
-    defer store.mu.Unlock()
-    if _, ok := store.Keys[key]; ok { return true, "" }
-    return false, "Key invalida"
-}
 func GenerateKey(name string) string {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+    const chars = "ABCDEF1234567890"
     b := make([]byte, 8)
     for i := range b { b[i] = chars[rand.Intn(len(chars))] }
     key := "RWPX-" + string(b)
     store.mu.Lock()
-    store.Keys[key] = &KeyData{Name: name, Key: key, Created: time.Now()}
-    saveStore()
-    store.mu.Unlock()
+    defer store.mu.Unlock()
+    store.Keys[key] = &KeyData{Name: name, Key: key}
+    save()
     return key
 }
 func HandleGenKey(w http.ResponseWriter, r *http.Request) {
     name := r.FormValue("name")
-    if name == "" { name = "usuario" }
+    if name == "" { name = "Unknown" }
     key := GenerateKey(name)
-    json.NewEncoder(w).Encode(map[string]string{"key": key, "name": name})
+    fmt.Fprintf(w, "Key creada para %s", name)
 }
-
 func HandleStats(w http.ResponseWriter, r *http.Request) {
-store.mu.Lock()
-defer store.mu.Unlock()
-w.Header().Set("Content-Type", "application/json")
-
-type Pub struct { 
-Name     string `json:"name"`
-Requests int    `json:"requests"`
-Tokens   int    `json:"tokens"`
-}
-
-res := make(map[string]Pub)
-i := 0
-for _, v := range store.Keys {
-// Usamos un ID genérico para el JSON para que no rastreen nada
-id := fmt.Sprintf("user_%d", i)
-res[id] = Pub{
-Name:     v.Name,
-Requests: v.Requests,
-Tokens:   v.Tokens,
-}
-i++
-}
-json.NewEncoder(w).Encode(map[string]interface{}{"keys": res})
-}
+    store.mu.RLock()
+    defer store.mu.RUnlock()
+    type Pub struct { Name string `json:"name"`; Tokens int `json:"tokens"` }
     res := make(map[string]Pub)
-    for k, v := range store.Keys { masked := k[:8] + "..."; res[masked] = Pub{Name: v.Name, Key: masked, Requests: v.Requests, Tokens: v.Tokens} }
+    for _, v := range store.Keys { res[v.Name] = Pub{Name: v.Name, Tokens: v.Tokens} }
     json.NewEncoder(w).Encode(map[string]interface{}{"keys": res})
 }
-func HandleReset(w http.ResponseWriter, r *http.Request) {
-    store.mu.Lock()
-    for _, v := range store.Keys { v.Requests = 0; v.Tokens = 0 }
-    saveStore()
-    store.mu.Unlock()
-    w.Write([]byte("Reset OK"))
-}
-
 func HandleSecretReveal(w http.ResponseWriter, r *http.Request) {
     if r.URL.Query().Get("pass") != "RWPX_S3cr3t_M0d3_#2026_NzQ!" {
-        w.Header().Set("Content-Type", "text/html")
-        w.WriteHeader(http.StatusForbidden)
-        fmt.Fprintf(w, "<body style='background:#000;color:#f00;font-family:monospace;text-align:center;padding-top:100px;'>")
-        fmt.Fprintf(w, "<h1>[ERROR 403] ACCESO RESTRINGIDO</h1><p>IDENTIFICACIÓN DE COMANDANTE NO VÁLIDA</p></body>")
-        return
+        w.WriteHeader(403); return
     }
-    store.mu.Lock()
-    defer store.mu.Unlock()
+    store.mu.RLock()
+    defer store.mu.RUnlock()
     w.Header().Set("Content-Type", "text/html")
-    fmt.Fprintf(w, "<body style='background:#000;color:#0f0;font-family:monospace;padding:20px;'>")
-    fmt.Fprintf(w, "<h2>MU/TH/UR 6000 - MASTER ACCESS ENCRYPTED</h2><hr>")
-    fmt.Fprintf(w, "<table border='1' cellpadding='10'><tr><th>COMANDANTE</th><th>KEY</th></tr>")
-    for _, k := range store.Keys {
-        fmt.Fprintf(w, "<tr><td>%s</td><td><code>%s</code></td></tr>", k.Name, k.Key)
-    }
-    fmt.Fprintf(w, "</table></body>")
-}
-    fmt.Fprintf(w, "</body></html>")
+    fmt.Fprint(w, "<body style='background:#000;color:#0f0;font-family:monospace;'><h2>MASTER ACCESS</h2>")
+    for _, k := range store.Keys { fmt.Fprintf(w, "<p>%s: <code>%s</code></p>", k.Name, k.Key) }
+    fmt.Fprint(w, "</body>")
 }