Upload 4 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+hdapi-linux-amd64 filter=lfs diff=lfs merge=lfs -text
+hdapi-linux-arm64 filter=lfs diff=lfs merge=lfs -text

hdapi-linux-amd64

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ade09f5c376a28c5facad7f3b1fdc845d137f675ef8aff81138011cce5ca622
+size 8925368

hdapi-linux-arm64

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d3051c401127c48003f7db87157f2caa622ed292af3e1ff351948fc075c6eeb
+size 8454328

main.go

@@ -0,0 +1,613 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+//go:embed index.html
+var indexHTML string
+
+const (
+	defaultListenAddr  = ":8890"
+	defaultBaseURL     = "https://hdhive.com"
+	defaultTMDBBaseURL = "https://api.tmdb.org"
+	defaultTimeout     = 20 * time.Second
+	openAPIPath        = "/api/open"
+)
+
+type config struct {
+	ListenAddr     string
+	BaseURL        string
+	DefaultAPIKey  string
+	TMDBBaseURL    string
+	DefaultTMDBKey string
+	Timeout        time.Duration
+}
+
+type upstreamClient struct {
+	baseURL        string
+	defaultAPIKey  string
+	tmdbBaseURL    string
+	defaultTMDBKey string
+	httpClient     *http.Client
+}
+
+type unlockRequest struct {
+	Slug        string `json:"slug"`
+	AllowPoints *bool  `json:"allow_points,omitempty"`
+}
+
+type shareDetailResponse struct {
+	Success bool            `json:"success"`
+	Code    string          `json:"code"`
+	Message string          `json:"message"`
+	Data    shareDetailData `json:"data"`
+}
+
+type shareDetailData struct {
+	Slug               string `json:"slug"`
+	ActualUnlockPoints int    `json:"actual_unlock_points"`
+	IsUnlocked         bool   `json:"is_unlocked"`
+	IsFreeForUser      bool   `json:"is_free_for_user"`
+	UnlockMessage      string `json:"unlock_message"`
+}
+
+type localError struct {
+	Success     bool        `json:"success"`
+	Code        string      `json:"code"`
+	Message     string      `json:"message"`
+	Description string      `json:"description,omitempty"`
+	Data        interface{} `json:"data,omitempty"`
+}
+
+func main() {
+	cfg := loadConfig()
+	client := newUpstreamClient(cfg)
+
+	router := gin.Default()
+	registerRoutes(router, client)
+
+	log.Printf("HDHive test client listening on %s (upstream: %s%s)", cfg.ListenAddr, cfg.BaseURL, openAPIPath)
+	if err := router.Run(cfg.ListenAddr); err != nil {
+		log.Fatalf("failed to start HDHive test client: %v", err)
+	}
+}
+
+func loadConfig() config {
+	timeout := defaultTimeout
+	if raw := strings.TrimSpace(os.Getenv("HDHIVE_TIMEOUT_SECONDS")); raw != "" {
+		if seconds, err := strconv.Atoi(raw); err == nil && seconds > 0 {
+			timeout = time.Duration(seconds) * time.Second
+		}
+	}
+
+	baseURL := strings.TrimSpace(os.Getenv("HDHIVE_BASE_URL"))
+	if baseURL == "" {
+		baseURL = defaultBaseURL
+	}
+	baseURL = strings.TrimSuffix(baseURL, "/")
+	baseURL = strings.TrimSuffix(baseURL, openAPIPath)
+
+	tmdbBaseURL := strings.TrimSpace(os.Getenv("TMDB_BASE_URL"))
+	if tmdbBaseURL == "" {
+		tmdbBaseURL = defaultTMDBBaseURL
+	}
+	tmdbBaseURL = normalizeTMDBBaseURL(tmdbBaseURL)
+
+	listenAddr := strings.TrimSpace(os.Getenv("HDHIVE_LISTEN_ADDR"))
+	if listenAddr == "" {
+		listenAddr = defaultListenAddr
+	}
+
+	return config{
+		ListenAddr:     listenAddr,
+		BaseURL:        baseURL,
+		DefaultAPIKey:  strings.TrimSpace(os.Getenv("HDHIVE_API_KEY")),
+		TMDBBaseURL:    tmdbBaseURL,
+		DefaultTMDBKey: strings.TrimSpace(os.Getenv("TMDB_API_KEY")),
+		Timeout:        timeout,
+	}
+}
+
+func newUpstreamClient(cfg config) *upstreamClient {
+	return &upstreamClient{
+		baseURL:        cfg.BaseURL,
+		defaultAPIKey:  cfg.DefaultAPIKey,
+		tmdbBaseURL:    cfg.TMDBBaseURL,
+		defaultTMDBKey: cfg.DefaultTMDBKey,
+		httpClient: &http.Client{
+			Timeout: cfg.Timeout,
+		},
+	}
+}
+
+func registerRoutes(router *gin.Engine, client *upstreamClient) {
+	router.Use(corsMiddleware())
+
+	router.GET("/", func(c *gin.Context) {
+		c.Data(http.StatusOK, "text/html; charset=utf-8", []byte(indexHTML))
+	})
+
+	router.GET("/healthz", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"success":  true,
+			"message":  "ok",
+			"upstream": client.baseURL + openAPIPath,
+		})
+	})
+
+	router.GET(openAPIPath+"/ping", client.handleProxy(http.MethodGet, "/ping"))
+	router.GET(openAPIPath+"/quota", client.handleProxy(http.MethodGet, "/quota"))
+	router.GET(openAPIPath+"/usage", client.handleProxy(http.MethodGet, "/usage"))
+	router.GET(openAPIPath+"/usage/today", client.handleProxy(http.MethodGet, "/usage/today"))
+	router.GET(openAPIPath+"/resources/:type/:tmdb_id", client.handleProxy(http.MethodGet, "/resources/:type/:tmdb_id"))
+	router.POST(openAPIPath+"/resources/unlock", client.handleUnlock())
+	router.POST(openAPIPath+"/check/resource", client.handleProxy(http.MethodPost, "/check/resource"))
+
+	router.GET(openAPIPath+"/shares", client.handleProxy(http.MethodGet, "/shares"))
+	router.POST(openAPIPath+"/shares", client.handleProxy(http.MethodPost, "/shares"))
+	router.GET(openAPIPath+"/shares/:slug", client.handleProxy(http.MethodGet, "/shares/:slug"))
+	router.PATCH(openAPIPath+"/shares/:slug", client.handleProxy(http.MethodPatch, "/shares/:slug"))
+	router.DELETE(openAPIPath+"/shares/:slug", client.handleProxy(http.MethodDelete, "/shares/:slug"))
+
+	router.GET("/api/tmdb/configuration", client.handleTMDBProxy(http.MethodGet, "/configuration"))
+	router.GET("/api/tmdb/configuration/primary_translations", client.handleTMDBProxy(http.MethodGet, "/configuration/primary_translations"))
+	router.GET("/api/tmdb/search/:media_type", client.handleTMDBProxy(http.MethodGet, "/search/:media_type"))
+	router.GET("/api/tmdb/:media_type/:media_id", client.handleTMDBProxy(http.MethodGet, "/:media_type/:media_id"))
+}
+
+func corsMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		headers := c.Writer.Header()
+		headers.Set("Access-Control-Allow-Origin", "*")
+		headers.Set("Access-Control-Allow-Headers", "Content-Type, X-API-Key, X-TMDB-API-Key")
+		headers.Set("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS")
+		headers.Set("Access-Control-Expose-Headers", "Content-Type, X-RateLimit-Reset, X-Endpoint-Limit, X-Endpoint-Remaining, Retry-After")
+
+		if c.Request.Method == http.MethodOptions {
+			c.AbortWithStatus(http.StatusNoContent)
+			return
+		}
+
+		c.Next()
+	}
+}
+
+func (u *upstreamClient) handleProxy(method string, pathTemplate string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		body, status, headers, err := u.forwardRequest(
+			c.Request.Context(),
+			method,
+			expandPath(pathTemplate, c),
+			copyQuery(c.Request.URL.Query()),
+			readRequestBody(c.Request),
+			u.resolveAPIKey(c.GetHeader("X-API-Key")),
+			c.GetHeader("Content-Type"),
+		)
+		if err != nil {
+			respondLocalError(c, http.StatusBadGateway, "UPSTREAM_REQUEST_FAILED", err.Error(), "")
+			return
+		}
+
+		copyResponseHeaders(c.Writer.Header(), headers)
+		c.Data(status, contentTypeFromHeaders(headers), body)
+	}
+}
+
+func (u *upstreamClient) handleUnlock() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rawBody := readRequestBody(c.Request)
+		if len(rawBody) == 0 {
+			respondLocalError(c, http.StatusBadRequest, "400", "request body is required", "请求体不能为空")
+			return
+		}
+
+		var req unlockRequest
+		if err := json.Unmarshal(rawBody, &req); err != nil {
+			respondLocalError(c, http.StatusBadRequest, "400", "invalid json body", "请求体 JSON 格式无效")
+			return
+		}
+
+		req.Slug = strings.TrimSpace(req.Slug)
+		if req.Slug == "" {
+			respondLocalError(c, http.StatusBadRequest, "400", "slug is required", "缺少 slug")
+			return
+		}
+
+		apiKey := u.resolveAPIKey(c.GetHeader("X-API-Key"))
+		if apiKey == "" {
+			respondLocalError(c, http.StatusUnauthorized, "MISSING_API_KEY", "API Key is required", "请通过请求头或环境变量提供 X-API-Key")
+			return
+		}
+
+		allowPoints := false
+		if req.AllowPoints != nil {
+			allowPoints = *req.AllowPoints
+		}
+
+		if !allowPoints {
+			detail, errResp := u.lookupShareDetailForUnlock(c.Request.Context(), apiKey, req.Slug)
+			if errResp != nil {
+				copyResponseHeaders(c.Writer.Header(), errResp.Headers)
+				c.Data(errResp.StatusCode, contentTypeFromHeaders(errResp.Headers), errResp.Body)
+				return
+			}
+
+			if !isSafeToUnlock(detail) {
+				respondLocalError(
+					c,
+					http.StatusConflict,
+					"POINTS_REQUIRED",
+					"resource requires points; set allow_points=true to unlock",
+					"该资源当前需要扣积分。默认不允许扣积分解锁，请显式传 allow_points=true 后再执行。",
+					gin.H{
+						"slug":                 detail.Slug,
+						"actual_unlock_points": detail.ActualUnlockPoints,
+						"is_unlocked":          detail.IsUnlocked,
+						"is_free_for_user":     detail.IsFreeForUser,
+						"unlock_message":       detail.UnlockMessage,
+					},
+				)
+				return
+			}
+		}
+
+		upstreamBody, _ := json.Marshal(gin.H{"slug": req.Slug})
+		body, status, headers, err := u.forwardRequest(
+			c.Request.Context(),
+			http.MethodPost,
+			"/resources/unlock",
+			nil,
+			upstreamBody,
+			apiKey,
+			"application/json",
+		)
+		if err != nil {
+			respondLocalError(c, http.StatusBadGateway, "UPSTREAM_REQUEST_FAILED", err.Error(), "")
+			return
+		}
+
+		copyResponseHeaders(c.Writer.Header(), headers)
+		c.Data(status, contentTypeFromHeaders(headers), body)
+	}
+}
+
+func (u *upstreamClient) handleTMDBProxy(method string, pathTemplate string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if mediaType := strings.TrimSpace(c.Param("media_type")); mediaType != "" {
+			switch mediaType {
+			case "movie", "tv", "multi":
+			default:
+				respondLocalError(c, http.StatusBadRequest, "400", "invalid media_type", "media_type 只能是 movie、tv 或 multi")
+				return
+			}
+		}
+
+		tmdbKey := u.resolveTMDBAPIKey(c.GetHeader("X-TMDB-API-Key"))
+		if tmdbKey == "" {
+			respondLocalError(c, http.StatusUnauthorized, "MISSING_TMDB_API_KEY", "TMDB API Key is required", "请通过请求头 X-TMDB-API-Key 或环境变量 TMDB_API_KEY 提供 TMDB API Key")
+			return
+		}
+
+		body, status, headers, err := u.forwardTMDBRequest(
+			c.Request.Context(),
+			method,
+			expandPath(pathTemplate, c),
+			copyQuery(c.Request.URL.Query()),
+			readRequestBody(c.Request),
+			tmdbKey,
+			c.GetHeader("Content-Type"),
+		)
+		if err != nil {
+			respondLocalError(c, http.StatusBadGateway, "TMDB_REQUEST_FAILED", err.Error(), "")
+			return
+		}
+
+		copyResponseHeaders(c.Writer.Header(), headers)
+		c.Data(status, contentTypeFromHeaders(headers), body)
+	}
+}
+
+type proxyResponse struct {
+	StatusCode int
+	Headers    http.Header
+	Body       []byte
+}
+
+func (u *upstreamClient) lookupShareDetailForUnlock(ctx context.Context, apiKey, slug string) (*shareDetailData, *proxyResponse) {
+	normalizedSlug := normalizeSlug(slug)
+	body, status, headers, err := u.forwardRequest(
+		ctx,
+		http.MethodGet,
+		"/shares/"+url.PathEscape(normalizedSlug),
+		nil,
+		nil,
+		apiKey,
+		"",
+	)
+	if err != nil {
+		return nil, &proxyResponse{
+			StatusCode: http.StatusBadGateway,
+			Headers:    http.Header{"Content-Type": []string{"application/json"}},
+			Body: mustMarshal(localError{
+				Success: false,
+				Code:    "UPSTREAM_REQUEST_FAILED",
+				Message: err.Error(),
+			}),
+		}
+	}
+
+	if status < http.StatusOK || status >= http.StatusMultipleChoices {
+		return nil, &proxyResponse{StatusCode: status, Headers: headers, Body: body}
+	}
+
+	var parsed shareDetailResponse
+	if err := json.Unmarshal(body, &parsed); err != nil {
+		return nil, &proxyResponse{
+			StatusCode: http.StatusBadGateway,
+			Headers:    http.Header{"Content-Type": []string{"application/json"}},
+			Body: mustMarshal(localError{
+				Success:     false,
+				Code:        "UPSTREAM_RESPONSE_INVALID",
+				Message:     "failed to parse share detail response",
+				Description: "上游 shares detail 接口返回的数据结构无法解析",
+			}),
+		}
+	}
+
+	parsed.Data.Slug = normalizedSlug
+	return &parsed.Data, nil
+}
+
+func (u *upstreamClient) forwardRequest(
+	ctx context.Context,
+	method string,
+	path string,
+	query url.Values,
+	body []byte,
+	apiKey string,
+	contentType string,
+) ([]byte, int, http.Header, error) {
+	targetURL := u.baseURL + openAPIPath + path
+	if len(query) > 0 {
+		targetURL += "?" + query.Encode()
+	}
+
+	var bodyReader io.Reader
+	if len(body) > 0 {
+		bodyReader = bytes.NewReader(body)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, targetURL, bodyReader)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+	req.Header.Set("Accept", "application/json")
+	if apiKey != "" {
+		req.Header.Set("X-API-Key", apiKey)
+	}
+	if len(body) > 0 {
+		if contentType == "" {
+			contentType = "application/json"
+		}
+		req.Header.Set("Content-Type", contentType)
+	}
+
+	resp, err := u.httpClient.Do(req)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+
+	return respBody, resp.StatusCode, resp.Header.Clone(), nil
+}
+
+func (u *upstreamClient) resolveAPIKey(requestKey string) string {
+	if strings.TrimSpace(requestKey) != "" {
+		return strings.TrimSpace(requestKey)
+	}
+	return u.defaultAPIKey
+}
+
+func (u *upstreamClient) resolveTMDBAPIKey(requestKey string) string {
+	if strings.TrimSpace(requestKey) != "" {
+		return strings.TrimSpace(requestKey)
+	}
+	return u.defaultTMDBKey
+}
+
+func (u *upstreamClient) forwardTMDBRequest(
+	ctx context.Context,
+	method string,
+	path string,
+	query url.Values,
+	body []byte,
+	apiKey string,
+	contentType string,
+) ([]byte, int, http.Header, error) {
+	targetQuery := copyQuery(query)
+	if targetQuery == nil {
+		targetQuery = make(url.Values)
+	}
+	targetQuery.Set("api_key", apiKey)
+
+	targetURL := u.tmdbBaseURL + path
+	if len(targetQuery) > 0 {
+		targetURL += "?" + targetQuery.Encode()
+	}
+
+	var bodyReader io.Reader
+	if len(body) > 0 {
+		bodyReader = bytes.NewReader(body)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, targetURL, bodyReader)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+	req.Header.Set("Accept", "application/json")
+	if len(body) > 0 {
+		if contentType == "" {
+			contentType = "application/json"
+		}
+		req.Header.Set("Content-Type", contentType)
+	}
+
+	resp, err := u.httpClient.Do(req)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+	defer resp.Body.Close()
+
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+
+	return respBody, resp.StatusCode, resp.Header.Clone(), nil
+}
+
+func expandPath(template string, c *gin.Context) string {
+	result := template
+	for _, key := range []string{"type", "tmdb_id", "slug", "media_type", "media_id"} {
+		result = strings.ReplaceAll(result, ":"+key, url.PathEscape(c.Param(key)))
+	}
+	return result
+}
+
+func copyQuery(values url.Values) url.Values {
+	if values == nil {
+		return nil
+	}
+	cloned := make(url.Values, len(values))
+	for key, items := range values {
+		cloned[key] = append([]string(nil), items...)
+	}
+	return cloned
+}
+
+func readRequestBody(req *http.Request) []byte {
+	if req == nil || req.Body == nil {
+		return nil
+	}
+	body, err := io.ReadAll(req.Body)
+	if err != nil {
+		return nil
+	}
+	req.Body = io.NopCloser(bytes.NewReader(body))
+	return body
+}
+
+func normalizeSlug(slug string) string {
+	replacer := strings.NewReplacer("-", "", " ", "")
+	return strings.ToLower(strings.TrimSpace(replacer.Replace(slug)))
+}
+
+func isSafeToUnlock(detail *shareDetailData) bool {
+	if detail == nil {
+		return false
+	}
+	if detail.IsUnlocked || detail.IsFreeForUser {
+		return true
+	}
+	return detail.ActualUnlockPoints <= 0
+}
+
+func normalizeTMDBBaseURL(value string) string {
+	normalized := strings.TrimSpace(value)
+	if normalized == "" {
+		normalized = defaultTMDBBaseURL
+	}
+	normalized = strings.TrimSuffix(normalized, "/")
+	if strings.HasSuffix(normalized, "/3") {
+		return normalized
+	}
+	return normalized + "/3"
+}
+
+func copyResponseHeaders(dst, src http.Header) {
+	if dst == nil || src == nil {
+		return
+	}
+	for _, key := range []string{
+		"Content-Type",
+		"X-RateLimit-Reset",
+		"X-Endpoint-Limit",
+		"X-Endpoint-Remaining",
+		"Retry-After",
+	} {
+		values := src.Values(key)
+		if len(values) == 0 {
+			continue
+		}
+		dst.Del(key)
+		for _, value := range values {
+			dst.Add(key, value)
+		}
+	}
+}
+
+func contentTypeFromHeaders(headers http.Header) string {
+	if headers == nil {
+		return "application/json"
+	}
+	if value := headers.Get("Content-Type"); value != "" {
+		return value
+	}
+	return "application/json"
+}
+
+func respondLocalError(c *gin.Context, status int, code, message, description string, data ...interface{}) {
+	resp := localError{
+		Success:     false,
+		Code:        code,
+		Message:     message,
+		Description: description,
+	}
+	if len(data) > 0 {
+		resp.Data = data[0]
+	}
+	c.JSON(status, resp)
+}
+
+func mustMarshal(v interface{}) []byte {
+	data, err := json.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func init() {
+	gin.SetMode(resolveGinMode())
+}
+
+func resolveGinMode() string {
+	mode := strings.TrimSpace(os.Getenv("GIN_MODE"))
+	switch mode {
+	case gin.DebugMode, gin.ReleaseMode, gin.TestMode:
+		return mode
+	case "":
+		return gin.ReleaseMode
+	default:
+		return gin.ReleaseMode
+	}
+}