Merge remote-tracking branch 'upstream/main' into remote-fix

Author: conversun

.goreleaser.yml

@@ -19,6 +19,8 @@ builds:
 archives:
   - id: "cli-proxy-api-plus"
     format: tar.gz
+    name_template: >-
+      {{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{- if eq .Arch "arm64" -}}aarch64{{- else -}}{{ .Arch }}{{- end -}}
     format_overrides:
       - goos: windows
         format: zip

internal/api/handlers/management/api_key_usage.go

@@ -0,0 +1,86 @@
+package management
+
+import (
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	coreauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
+)
+
+func mergeRecentRequestBuckets(dst, src []coreauth.RecentRequestBucket) []coreauth.RecentRequestBucket {
+	if len(dst) == 0 {
+		return src
+	}
+	if len(src) == 0 {
+		return dst
+	}
+	if len(dst) != len(src) {
+		n := len(dst)
+		if len(src) < n {
+			n = len(src)
+		}
+		for i := 0; i < n; i++ {
+			dst[i].Success += src[i].Success
+			dst[i].Failed += src[i].Failed
+		}
+		return dst
+	}
+	for i := range dst {
+		dst[i].Success += src[i].Success
+		dst[i].Failed += src[i].Failed
+	}
+	return dst
+}
+
+// GetAPIKeyUsage returns recent request buckets for all in-memory api_key auths,
+// grouped by provider and keyed by the raw api-key value.
+func (h *Handler) GetAPIKeyUsage(c *gin.Context) {
+	if h == nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "handler not initialized"})
+		return
+	}
+
+	h.mu.Lock()
+	manager := h.authManager
+	h.mu.Unlock()
+	if manager == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "core auth manager unavailable"})
+		return
+	}
+
+	now := time.Now()
+	out := make(map[string]map[string][]coreauth.RecentRequestBucket)
+	for _, auth := range manager.List() {
+		if auth == nil {
+			continue
+		}
+		kind, apiKey := auth.AccountInfo()
+		if !strings.EqualFold(strings.TrimSpace(kind), "api_key") {
+			continue
+		}
+		apiKey = strings.TrimSpace(apiKey)
+		if apiKey == "" {
+			continue
+		}
+		provider := strings.ToLower(strings.TrimSpace(auth.Provider))
+		if provider == "" {
+			provider = "unknown"
+		}
+
+		recent := auth.RecentRequestsSnapshot(now)
+		providerBucket, ok := out[provider]
+		if !ok {
+			providerBucket = make(map[string][]coreauth.RecentRequestBucket)
+			out[provider] = providerBucket
+		}
+		if existing, exists := providerBucket[apiKey]; exists {
+			providerBucket[apiKey] = mergeRecentRequestBuckets(existing, recent)
+			continue
+		}
+		providerBucket[apiKey] = recent
+	}
+
+	c.JSON(http.StatusOK, out)
+}

internal/api/handlers/management/api_key_usage_test.go

@@ -0,0 +1,87 @@
+package management
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/router-for-me/CLIProxyAPI/v6/internal/config"
+	coreauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
+)
+
+func sumRecentRequestBuckets(buckets []coreauth.RecentRequestBucket) (int64, int64) {
+	var success int64
+	var failed int64
+	for _, bucket := range buckets {
+		success += bucket.Success
+		failed += bucket.Failed
+	}
+	return success, failed
+}
+
+func TestGetAPIKeyUsage_GroupsByProviderAndAPIKey(t *testing.T) {
+	t.Setenv("MANAGEMENT_PASSWORD", "")
+	gin.SetMode(gin.TestMode)
+
+	manager := coreauth.NewManager(nil, nil, nil)
+	if _, err := manager.Register(context.Background(), &coreauth.Auth{
+		ID:       "codex-auth",
+		Provider: "codex",
+		Attributes: map[string]string{
+			"api_key": "codex-key",
+		},
+	}); err != nil {
+		t.Fatalf("register codex auth: %v", err)
+	}
+	if _, err := manager.Register(context.Background(), &coreauth.Auth{
+		ID:       "claude-auth",
+		Provider: "claude",
+		Attributes: map[string]string{
+			"api_key": "claude-key",
+		},
+	}); err != nil {
+		t.Fatalf("register claude auth: %v", err)
+	}
+
+	manager.MarkResult(context.Background(), coreauth.Result{AuthID: "codex-auth", Provider: "codex", Model: "gpt-5", Success: true})
+	manager.MarkResult(context.Background(), coreauth.Result{AuthID: "codex-auth", Provider: "codex", Model: "gpt-5", Success: false})
+	manager.MarkResult(context.Background(), coreauth.Result{AuthID: "claude-auth", Provider: "claude", Model: "claude-4", Success: true})
+
+	h := NewHandlerWithoutConfigFilePath(&config.Config{AuthDir: t.TempDir()}, manager)
+
+	rec := httptest.NewRecorder()
+	ginCtx, _ := gin.CreateTestContext(rec)
+	req := httptest.NewRequest(http.MethodGet, "/v0/management/api-key-usage", nil)
+	ginCtx.Request = req
+	h.GetAPIKeyUsage(ginCtx)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want %d body=%s", rec.Code, http.StatusOK, rec.Body.String())
+	}
+
+	var payload map[string]map[string][]coreauth.RecentRequestBucket
+	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode payload: %v", err)
+	}
+
+	codexBuckets := payload["codex"]["codex-key"]
+	if len(codexBuckets) != 20 {
+		t.Fatalf("codex buckets len = %d, want 20", len(codexBuckets))
+	}
+	codexSuccess, codexFailed := sumRecentRequestBuckets(codexBuckets)
+	if codexSuccess != 1 || codexFailed != 1 {
+		t.Fatalf("codex totals = %d/%d, want 1/1", codexSuccess, codexFailed)
+	}
+
+	claudeBuckets := payload["claude"]["claude-key"]
+	if len(claudeBuckets) != 20 {
+		t.Fatalf("claude buckets len = %d, want 20", len(claudeBuckets))
+	}
+	claudeSuccess, claudeFailed := sumRecentRequestBuckets(claudeBuckets)
+	if claudeSuccess != 1 || claudeFailed != 0 {
+		t.Fatalf("claude totals = %d/%d, want 1/0", claudeSuccess, claudeFailed)
+	}
+}

internal/api/handlers/management/auth_files.go

@@ -399,6 +399,7 @@ func (h *Handler) buildAuthFileEntry(auth *coreauth.Auth) gin.H {
 		"source":         "memory",
 		"size":           int64(0),
 	}
+	entry["recent_requests"] = auth.RecentRequestsSnapshot(time.Now())
 	if email := authEmail(auth); email != "" {
 		entry["email"] = email
 	}

internal/api/handlers/management/auth_files_recent_requests_test.go

@@ -0,0 +1,87 @@
+package management
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/router-for-me/CLIProxyAPI/v6/internal/config"
+	coreauth "github.com/router-for-me/CLIProxyAPI/v6/sdk/cliproxy/auth"
+)
+
+func TestListAuthFiles_IncludesRecentRequestsBuckets(t *testing.T) {
+	t.Setenv("MANAGEMENT_PASSWORD", "")
+	gin.SetMode(gin.TestMode)
+
+	manager := coreauth.NewManager(nil, nil, nil)
+	record := &coreauth.Auth{
+		ID:       "runtime-only-auth-1",
+		Provider: "codex",
+		Attributes: map[string]string{
+			"runtime_only": "true",
+		},
+		Metadata: map[string]any{
+			"type": "codex",
+		},
+	}
+	if _, errRegister := manager.Register(context.Background(), record); errRegister != nil {
+		t.Fatalf("failed to register auth record: %v", errRegister)
+	}
+
+	h := NewHandlerWithoutConfigFilePath(&config.Config{AuthDir: t.TempDir()}, manager)
+	h.tokenStore = &memoryAuthStore{}
+
+	rec := httptest.NewRecorder()
+	ginCtx, _ := gin.CreateTestContext(rec)
+	req := httptest.NewRequest(http.MethodGet, "/v0/management/auth-files", nil)
+	ginCtx.Request = req
+
+	h.ListAuthFiles(ginCtx)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected list status %d, got %d with body %s", http.StatusOK, rec.Code, rec.Body.String())
+	}
+
+	var payload map[string]any
+	if errUnmarshal := json.Unmarshal(rec.Body.Bytes(), &payload); errUnmarshal != nil {
+		t.Fatalf("failed to decode list payload: %v", errUnmarshal)
+	}
+	filesRaw, ok := payload["files"].([]any)
+	if !ok {
+		t.Fatalf("expected files array, payload: %#v", payload)
+	}
+	if len(filesRaw) != 1 {
+		t.Fatalf("expected 1 auth entry, got %d", len(filesRaw))
+	}
+
+	fileEntry, ok := filesRaw[0].(map[string]any)
+	if !ok {
+		t.Fatalf("expected file entry object, got %#v", filesRaw[0])
+	}
+
+	recentRaw, ok := fileEntry["recent_requests"].([]any)
+	if !ok {
+		t.Fatalf("expected recent_requests array, got %#v", fileEntry["recent_requests"])
+	}
+	if len(recentRaw) != 20 {
+		t.Fatalf("expected 20 recent_requests buckets, got %d", len(recentRaw))
+	}
+	for idx, item := range recentRaw {
+		bucket, ok := item.(map[string]any)
+		if !ok {
+			t.Fatalf("expected bucket object at %d, got %#v", idx, item)
+		}
+		if _, ok := bucket["time"].(string); !ok {
+			t.Fatalf("expected bucket time string at %d, got %#v", idx, bucket["time"])
+		}
+		if _, ok := bucket["success"].(float64); !ok {
+			t.Fatalf("expected bucket success number at %d, got %#v", idx, bucket["success"])
+		}
+		if _, ok := bucket["failed"].(float64); !ok {
+			t.Fatalf("expected bucket failed number at %d, got %#v", idx, bucket["failed"])
+		}
+	}
+}

internal/api/server.go

@@ -596,6 +596,7 @@ func (s *Server) registerManagementRoutes() {
 		mgmt.PUT("/api-keys", s.mgmt.PutAPIKeys)
 		mgmt.PATCH("/api-keys", s.mgmt.PatchAPIKeys)
 		mgmt.DELETE("/api-keys", s.mgmt.DeleteAPIKeys)
+		mgmt.GET("/api-key-usage", s.mgmt.GetAPIKeyUsage)
 
 		mgmt.GET("/gemini-api-key", s.mgmt.GetGeminiKeys)
 		mgmt.PUT("/gemini-api-key", s.mgmt.PutGeminiKeys)

internal/logging/requestmeta.go

@@ -0,0 +1,62 @@
+package logging
+
+import (
+	"context"
+	"sync/atomic"
+)
+
+type endpointKey struct{}
+type responseStatusKey struct{}
+
+type responseStatusHolder struct {
+	status atomic.Int32
+}
+
+func WithEndpoint(ctx context.Context, endpoint string) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, endpointKey{}, endpoint)
+}
+
+func GetEndpoint(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	if endpoint, ok := ctx.Value(endpointKey{}).(string); ok {
+		return endpoint
+	}
+	return ""
+}
+
+func WithResponseStatusHolder(ctx context.Context) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if holder, ok := ctx.Value(responseStatusKey{}).(*responseStatusHolder); ok && holder != nil {
+		return ctx
+	}
+	return context.WithValue(ctx, responseStatusKey{}, &responseStatusHolder{})
+}
+
+func SetResponseStatus(ctx context.Context, status int) {
+	if ctx == nil || status <= 0 {
+		return
+	}
+	holder, ok := ctx.Value(responseStatusKey{}).(*responseStatusHolder)
+	if !ok || holder == nil {
+		return
+	}
+	holder.status.Store(int32(status))
+}
+
+func GetResponseStatus(ctx context.Context) int {
+	if ctx == nil {
+		return 0
+	}
+	holder, ok := ctx.Value(responseStatusKey{}).(*responseStatusHolder)
+	if !ok || holder == nil {
+		return 0
+	}
+	return int(holder.status.Load())
+}