// Package extstore 保存面板扩展配置:免登录免费模型、自定义模型映射、访问密钥。 // // 为什么单独一个文件而不是塞进 config.json:这三块都是「运行期增删」的集合, // 面板每次改动都重写整份配置既容易与其他字段的保存互相踩,也不适合放在 // 需要人工编辑的 config.json 里。文件落在 data 目录(HF 上就是存储桶卷), // 与 state/usage 同一个持久化口径。 package extstore import ( "crypto/rand" "encoding/base64" "encoding/json" "errors" "fmt" "os" "path/filepath" "strings" "sync" "time" ) // 免费模型渠道名(同时也是 /v1/models 里 free:/ 的 provider 段)。 const ( ProviderOpenCode = "opencode" ProviderKilo = "kilo" ) // 渠道协议类型:决定请求怎么整形、模型清单怎么解析。 const ( // TypeOpenCode OpenCode Zen:官方 CLI 指纹 + 工具整形。 TypeOpenCode = "opencode" // TypeKilo Kilo 公共网关:OpenAI 兼容 + isFree 过滤 + 归因头。 TypeKilo = "kilo" // TypeOpenAI 任意 OpenAI 兼容端点:只做透明转发。 TypeOpenAI = "openai" ) // DefaultOpenCodeBase / DefaultKiloBase 上游默认地址(与 dsh-our-free-model 一致)。 const ( DefaultOpenCodeBase = "https://opencode.ai" DefaultKiloBase = "https://ai-gateway.kilo.ai/api/v1" ) // FreeModel 一个已发现的免费模型。 type FreeModel struct { ID string `json:"id"` Name string `json:"name,omitempty"` Enabled bool `json:"enabled"` // Note 上游/用户备注(例如「地区受限」「已下线」),仅展示。 Note string `json:"note,omitempty"` } // FreeProvider 一个免登录渠道。除了内置的 OpenCode / Kilo,也可以加任意 // OpenAI 兼容端点(TypeOpenAI),面板里填 base URL 与模型清单路径即可。 type FreeProvider struct { // Name 渠道 slug,同时是模型前缀 free:/;只允许 [a-z0-9_-]。 Name string `json:"name"` // Label 面板显示名(默认取 Name)。 Label string `json:"label,omitempty"` // Type opencode / kilo / openai。 Type string `json:"type"` // Enabled 渠道总开关。 Enabled bool `json:"enabled"` // BaseURL 上游根地址,例如 https://api.example.com/v1。 BaseURL string `json:"base_url"` // ModelsPath 模型清单路径,默认 /models(TypeOpenCode 默认 /inference/v1/models)。 ModelsPath string `json:"models_path,omitempty"` // ChatPath 对话路径,默认 /chat/completions(TypeOpenCode 默认 // /inference/openai/v1/chat/completions)。 ChatPath string `json:"chat_path,omitempty"` // FreeFilter 免费模型筛选:all(全部)/ free-suffix(id 含 free 段)/ // is-free(清单行 isFree=true,Kilo 用)。 FreeFilter string `json:"free_filter,omitempty"` // AuthHeader / AuthValue 可选:需要固定 Key 的公共端点(多数免登录渠道留空)。 AuthHeader string `json:"auth_header,omitempty"` AuthValue string `json:"auth_value,omitempty"` // Headers 额外请求头。 Headers map[string]string `json:"headers,omitempty"` // Models 已发现的模型清单(含启停状态)。 Models []FreeModel `json:"models"` // UpdatedAt 最近一次成功刷新时间。 UpdatedAt time.Time `json:"updated_at,omitempty"` } // FreeSettings 免登录免费模型层设置。 type FreeSettings struct { Enabled bool `json:"enabled"` // Providers 渠道列表(顺序即面板展示顺序)。 Providers []FreeProvider `json:"providers"` // UpdatedAt 最近一次成功刷新模型清单的时间(展示用)。 UpdatedAt time.Time `json:"updated_at,omitempty"` // 兼容旧版 extensions.json 的固定字段(读取时迁移到 Providers,写回时清空)。 OpenCode *FreeProvider `json:"opencode,omitempty"` Kilo *FreeProvider `json:"kilo,omitempty"` } // CustomModel 自定义模型:客户端点名该模型时改写为 Target 并注入 Prompt。 // 与 ds2api 面板里的「自定义模型列表」同一语义——不是新模型,只是一层提示词外壳。 type CustomModel struct { Name string `json:"name"` Target string `json:"target"` Prompt string `json:"prompt"` Mode string `json:"mode,omitempty"` // append(默认)/ prepend / replace Description string `json:"description,omitempty"` // Temperature / MaxTokens 可选覆盖;nil = 不修改客户端请求。 Temperature *float64 `json:"temperature,omitempty"` MaxTokens *int `json:"max_tokens,omitempty"` Enabled bool `json:"enabled"` } // AccessKey 面板签发的访问密钥(用于 /v1/* 与 /status,不用于面板本身)。 type AccessKey struct { ID string `json:"id"` Name string `json:"name"` Key string `json:"key"` Enabled bool `json:"enabled"` CreatedAt time.Time `json:"created_at"` LastUsedAt time.Time `json:"last_used_at,omitempty"` // AllowModels 非空 = 白名单:只有匹配的模型可用。 AllowModels []string `json:"allow_models,omitempty"` // DenyModels 黑名单:匹配的模型不可用(白名单命中后仍受黑名单约束)。 DenyModels []string `json:"deny_models,omitempty"` // Note 备注/用途说明。 Note string `json:"note,omitempty"` } // Data 整个扩展配置文件。 type Data struct { Free FreeSettings `json:"free"` CustomModels []CustomModel `json:"custom_models"` AccessKeys []AccessKey `json:"access_keys"` } // Store 并发安全的扩展配置存储;path 为空时只在内存里(测试用)。 type Store struct { mu sync.RWMutex path string data Data } // Open 读取(不存在则返回默认值)。默认开启 OpenCode 免登录渠道,Kilo 关闭, // 模型清单留空——第一次启动后由后台刷新填充。 func Open(path string) *Store { s := &Store{path: path, data: Defaults()} if path == "" { return s } raw, err := os.ReadFile(path) if err == nil { var d Data if json.Unmarshal(raw, &d) == nil { // 免费层总开关缺省开启;只有文件里显式写了 false 才关闭。 var probe struct { Free struct { Enabled *bool `json:"enabled"` } `json:"free"` } if json.Unmarshal(raw, &probe) != nil || probe.Free.Enabled == nil { d.Free.Enabled = true } s.data = normalize(d) } } return s } func defaultProvider(name, typ, label, base string, enabled bool) FreeProvider { return FreeProvider{ Name: name, Label: label, Type: typ, Enabled: enabled, BaseURL: base, } } // Defaults 默认扩展配置。 func Defaults() Data { return Data{Free: FreeSettings{ Enabled: true, Providers: []FreeProvider{ defaultProvider(ProviderOpenCode, TypeOpenCode, "OpenCode Zen", DefaultOpenCodeBase, true), defaultProvider(ProviderKilo, TypeKilo, "Kilo", DefaultKiloBase, false), }, }} } // NormalizeProviderSlug 校验/归一化渠道名:只保留 [a-z0-9_-],其它字符换成 '-'。 func NormalizeProviderSlug(name string) string { name = strings.ToLower(strings.TrimSpace(name)) var b strings.Builder for _, r := range name { switch { case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '-', r == '_': b.WriteRune(r) case r == ' ', r == '.': b.WriteByte('-') } } return strings.Trim(b.String(), "-") } func normalizeProvider(p FreeProvider) FreeProvider { p.Name = NormalizeProviderSlug(p.Name) if p.Name == "" { p.Name = "provider" } if p.Type == "" { p.Type = TypeOpenAI } switch p.Type { case TypeOpenCode: if p.Label == "" { p.Label = "OpenCode Zen" } if p.BaseURL == "" { p.BaseURL = DefaultOpenCodeBase } if p.ModelsPath == "" { p.ModelsPath = "/inference/v1/models" } if p.ChatPath == "" { p.ChatPath = "/inference/openai/v1/chat/completions" } if p.FreeFilter == "" { p.FreeFilter = "free-suffix" } case TypeKilo: if p.Label == "" { p.Label = "Kilo" } if p.BaseURL == "" { p.BaseURL = DefaultKiloBase } if p.ModelsPath == "" { p.ModelsPath = "/models" } if p.ChatPath == "" { p.ChatPath = "/chat/completions" } if p.FreeFilter == "" { p.FreeFilter = "is-free" } default: p.Type = TypeOpenAI if p.Label == "" { p.Label = p.Name } if p.ModelsPath == "" { p.ModelsPath = "/models" } if p.ChatPath == "" { p.ChatPath = "/chat/completions" } if p.FreeFilter == "" { p.FreeFilter = "all" } } p.BaseURL = strings.TrimRight(strings.TrimSpace(p.BaseURL), "/") p.ModelsPath = "/" + strings.TrimLeft(strings.TrimSpace(p.ModelsPath), "/") p.ChatPath = "/" + strings.TrimLeft(strings.TrimSpace(p.ChatPath), "/") if p.Models == nil { p.Models = []FreeModel{} } if p.Headers == nil { p.Headers = map[string]string{} } return p } func normalize(d Data) Data { // 旧版固定字段迁移:只在 Providers 为空时采用,避免覆盖用户新加的渠道。 if len(d.Free.Providers) == 0 { if d.Free.OpenCode != nil { legacy := *d.Free.OpenCode legacy.Name = ProviderOpenCode legacy.Type = TypeOpenCode legacy.Label = "OpenCode Zen" d.Free.Providers = append(d.Free.Providers, legacy) } if d.Free.Kilo != nil { legacy := *d.Free.Kilo legacy.Name = ProviderKilo legacy.Type = TypeKilo legacy.Label = "Kilo" d.Free.Providers = append(d.Free.Providers, legacy) } } d.Free.OpenCode = nil d.Free.Kilo = nil if len(d.Free.Providers) == 0 { d.Free.Providers = Defaults().Free.Providers } seen := map[string]bool{} providers := make([]FreeProvider, 0, len(d.Free.Providers)) for _, p := range d.Free.Providers { p = normalizeProvider(p) if seen[p.Name] { continue } seen[p.Name] = true providers = append(providers, p) } d.Free.Providers = providers if d.CustomModels == nil { d.CustomModels = []CustomModel{} } if d.AccessKeys == nil { d.AccessKeys = []AccessKey{} } for i := range d.CustomModels { cm := &d.CustomModels[i] cm.Name = strings.TrimSpace(cm.Name) cm.Target = strings.TrimSpace(cm.Target) switch cm.Mode { case "prepend", "replace": default: cm.Mode = "append" } } return d } // Path 返回配置文件路径。 func (s *Store) Path() string { return s.path } // Snapshot 返回深拷贝快照(调用方随便改)。 func (s *Store) Snapshot() Data { s.mu.RLock() defer s.mu.RUnlock() return clone(s.data) } func clone(d Data) Data { out := d out.Free.Providers = make([]FreeProvider, len(d.Free.Providers)) for i, p := range d.Free.Providers { cp := p cp.Models = append([]FreeModel(nil), p.Models...) if p.Headers != nil { cp.Headers = make(map[string]string, len(p.Headers)) for k, v := range p.Headers { cp.Headers[k] = v } } out.Free.Providers[i] = cp } out.CustomModels = append([]CustomModel(nil), d.CustomModels...) out.AccessKeys = append([]AccessKey(nil), d.AccessKeys...) for i := range out.AccessKeys { out.AccessKeys[i].AllowModels = append([]string(nil), d.AccessKeys[i].AllowModels...) out.AccessKeys[i].DenyModels = append([]string(nil), d.AccessKeys[i].DenyModels...) } return out } // Update 在锁内修改并原子落盘;fn 返回错误时不改内存、不写盘。 func (s *Store) Update(fn func(*Data) error) error { s.mu.Lock() defer s.mu.Unlock() d := clone(s.data) if err := fn(&d); err != nil { return err } d = normalize(d) if err := s.saveLocked(d); err != nil { return err } s.data = d return nil } func (s *Store) saveLocked(d Data) error { if s.path == "" { return nil } raw, err := json.MarshalIndent(d, "", " ") if err != nil { return err } if dir := filepath.Dir(s.path); dir != "" && dir != "." { if err := os.MkdirAll(dir, 0o700); err != nil { return err } } tmp := s.path + ".tmp" if err := os.WriteFile(tmp, append(raw, '\n'), 0o600); err != nil { return err } return os.Rename(tmp, s.path) } // HasFreeModels 是否有可用的免费模型(渠道开关 + 模型开关)。 func (d Data) HasFreeModels() bool { if !d.Free.Enabled { return false } for _, p := range d.Free.Providers { if !p.Enabled { continue } for _, m := range p.Models { if m.Enabled { return true } } } return false } // Provider 返回指定渠道设置。 func (d Data) Provider(name string) (FreeProvider, bool) { name = NormalizeProviderSlug(name) for _, p := range d.Free.Providers { if p.Name == name { return p, true } } return FreeProvider{}, false } // ProviderNames 返回所有渠道名(保持面板顺序)。 func (d Data) ProviderNames() []string { out := make([]string, 0, len(d.Free.Providers)) for _, p := range d.Free.Providers { out = append(out, p.Name) } return out } // FreeModelEnabled 报告 provider 下的 id 是否启用。 func (d Data) FreeModelEnabled(provider, id string) bool { if !d.Free.Enabled { return false } p, ok := d.Provider(provider) if !ok || !p.Enabled { return false } for _, m := range p.Models { if m.ID == id { return m.Enabled } } return false } // FindFreeModel 按 provider/id 查找。 func (d Data) FindFreeModel(provider, id string) (FreeModel, bool) { p, ok := d.Provider(provider) if !ok { return FreeModel{}, false } for _, m := range p.Models { if m.ID == id { return m, true } } return FreeModel{}, false } // CustomFor 按模型名(大小写不敏感)查找启用的自定义模型。 func (d Data) CustomFor(name string) (CustomModel, bool) { name = strings.TrimSpace(name) if name == "" { return CustomModel{}, false } for _, m := range d.CustomModels { if m.Enabled && strings.EqualFold(m.Name, name) { return m, true } } return CustomModel{}, false } // AccessTokens 返回所有启用的访问密钥。 func (d Data) AccessTokens() []string { out := make([]string, 0, len(d.AccessKeys)) for _, k := range d.AccessKeys { if k.Enabled && strings.TrimSpace(k.Key) != "" { out = append(out, k.Key) } } return out } // AccessKeyFor 按密钥原文查找启用的访问密钥。 func (d Data) AccessKeyFor(token string) (AccessKey, bool) { if token == "" { return AccessKey{}, false } for _, k := range d.AccessKeys { if k.Enabled && k.Key == token { return k, true } } return AccessKey{}, false } func providerPtr(d *Data, name string) *FreeProvider { name = NormalizeProviderSlug(name) for i := range d.Free.Providers { if d.Free.Providers[i].Name == name { return &d.Free.Providers[i] } } return nil } // UpsertFreeProvider 新增或按 Name 覆盖渠道(同时可更新开关/地址/协议等)。 func (s *Store) UpsertFreeProvider(p FreeProvider) error { if NormalizeProviderSlug(p.Name) == "" { return errors.New("provider name is required") } return s.Update(func(d *Data) error { p = normalizeProvider(p) if cur := providerPtr(d, p.Name); cur != nil { // 保留已有模型清单与刷新时间(除非调用方显式带了模型)。 if len(p.Models) == 0 { p.Models = cur.Models } if p.UpdatedAt.IsZero() { p.UpdatedAt = cur.UpdatedAt } *cur = p return nil } d.Free.Providers = append(d.Free.Providers, p) return nil }) } // DeleteFreeProvider 删除渠道。 func (s *Store) DeleteFreeProvider(name string) error { return s.Update(func(d *Data) error { name = NormalizeProviderSlug(name) out := d.Free.Providers[:0] for _, p := range d.Free.Providers { if p.Name != name { out = append(out, p) } } if len(out) == len(d.Free.Providers) { return fmt.Errorf("unknown provider: %s", name) } d.Free.Providers = out return nil }) } // SetFreeEnabled 总开关。 func (s *Store) SetFreeEnabled(enabled bool) error { return s.Update(func(d *Data) error { d.Free.Enabled = enabled; return nil }) } // SetModelEnabled 单模型开关(不存在时报错)。 func (s *Store) SetModelEnabled(provider, id string, enabled bool) error { return s.Update(func(d *Data) error { p := providerPtr(d, provider) if p == nil { return fmt.Errorf("unknown provider: %s", provider) } for i := range p.Models { if p.Models[i].ID == id { p.Models[i].Enabled = enabled return nil } } return fmt.Errorf("unknown free model: %s/%s", provider, id) }) } // MergeModels 把一次刷新结果并进当前清单:保留已有模型的启用状态,新模型默认启用, // 上游已下架的模型保留(标为不可用由调用方决定,这里不删除用户的选择)。 func (s *Store) MergeModels(provider string, models []FreeModel) error { return s.Update(func(d *Data) error { p := providerPtr(d, provider) if p == nil { return fmt.Errorf("unknown provider: %s", provider) } prev := make(map[string]FreeModel, len(p.Models)) for _, m := range p.Models { prev[m.ID] = m } next := make([]FreeModel, 0, len(models)+len(p.Models)) seen := make(map[string]bool, len(models)) for _, m := range models { if m.ID == "" || seen[m.ID] { continue } seen[m.ID] = true if old, ok := prev[m.ID]; ok { m.Enabled = old.Enabled if m.Name == "" { m.Name = old.Name } if m.Note == "" { m.Note = old.Note } } else { // 新发现的模型默认启用;上游把付费 id 也列出来时由调用方过滤。 m.Enabled = true } next = append(next, m) } for _, old := range p.Models { if !seen[old.ID] { next = append(next, old) } } p.Models = next p.UpdatedAt = time.Now() d.Free.UpdatedAt = time.Now() return nil }) } // UpsertCustom 新增或按 name 覆盖自定义模型。 func (s *Store) UpsertCustom(cm CustomModel) error { cm.Name = strings.TrimSpace(cm.Name) cm.Target = strings.TrimSpace(cm.Target) if cm.Name == "" { return errors.New("name is required") } if strings.ContainsAny(cm.Name, "/: \t\r\n") { return errors.New("name must not contain '/', ':' or whitespace") } if cm.Target == "" { return errors.New("target model is required") } switch cm.Mode { case "prepend", "replace": default: cm.Mode = "append" } if cm.Temperature != nil && (*cm.Temperature < 0 || *cm.Temperature > 2) { return errors.New("temperature must be between 0 and 2") } if cm.MaxTokens != nil && *cm.MaxTokens <= 0 { return errors.New("max_tokens must be positive") } return s.Update(func(d *Data) error { for i := range d.CustomModels { if strings.EqualFold(d.CustomModels[i].Name, cm.Name) { d.CustomModels[i] = cm return nil } } d.CustomModels = append(d.CustomModels, cm) return nil }) } // DeleteCustom 删除自定义模型。 func (s *Store) DeleteCustom(name string) error { return s.Update(func(d *Data) error { out := d.CustomModels[:0] for _, m := range d.CustomModels { if !strings.EqualFold(m.Name, name) { out = append(out, m) } } d.CustomModels = out return nil }) } // AddAccessKey 生成并保存一个访问密钥,返回明文(只在此刻完整返回一次)。 func (s *Store) AddAccessKey(name, note string, allow, deny []string) (AccessKey, error) { buf := make([]byte, 24) if _, err := rand.Read(buf); err != nil { return AccessKey{}, err } key := AccessKey{ ID: "ak_" + randomHex(6), Name: strings.TrimSpace(name), Key: "sk-wb2api-" + base64.RawURLEncoding.EncodeToString(buf), Enabled: true, CreatedAt: time.Now(), Note: strings.TrimSpace(note), AllowModels: cleanPatterns(allow), DenyModels: cleanPatterns(deny), } if key.Name == "" { key.Name = "key-" + key.ID[3:] } err := s.Update(func(d *Data) error { d.AccessKeys = append(d.AccessKeys, key) return nil }) return key, err } // UpdateAccessKey 修改密钥的备注、启停与模型白/黑名单(Key 原文不可改)。 func (s *Store) UpdateAccessKey(id, name, note string, enabled bool, allow, deny []string) error { return s.Update(func(d *Data) error { for i := range d.AccessKeys { if d.AccessKeys[i].ID != id { continue } if strings.TrimSpace(name) != "" { d.AccessKeys[i].Name = strings.TrimSpace(name) } d.AccessKeys[i].Note = strings.TrimSpace(note) d.AccessKeys[i].Enabled = enabled d.AccessKeys[i].AllowModels = cleanPatterns(allow) d.AccessKeys[i].DenyModels = cleanPatterns(deny) return nil } return fmt.Errorf("unknown access key: %s", id) }) } func cleanPatterns(patterns []string) []string { out := make([]string, 0, len(patterns)) for _, p := range patterns { p = strings.TrimSpace(p) if p != "" { out = append(out, p) } } if len(out) == 0 { return nil } return out } // DeleteAccessKey 删除访问密钥。 func (s *Store) DeleteAccessKey(id string) error { return s.Update(func(d *Data) error { out := d.AccessKeys[:0] for _, k := range d.AccessKeys { if k.ID != id { out = append(out, k) } } d.AccessKeys = out return nil }) } // SetAccessKeyEnabled 启停访问密钥。 func (s *Store) SetAccessKeyEnabled(id string, enabled bool) error { return s.Update(func(d *Data) error { for i := range d.AccessKeys { if d.AccessKeys[i].ID == id { d.AccessKeys[i].Enabled = enabled return nil } } return fmt.Errorf("unknown access key: %s", id) }) } // TouchAccessKey 记录最近使用时间(只改内存,不写盘;下一次其它改动会一起落盘)。 func (s *Store) TouchAccessKey(token string) { if s == nil || token == "" { return } s.mu.Lock() defer s.mu.Unlock() for i := range s.data.AccessKeys { if s.data.AccessKeys[i].Key == token { s.data.AccessKeys[i].LastUsedAt = time.Now() return } } } // HasAccessToken 报告 token 是否是任一启用的访问密钥(常量时间比较在调用方)。 func (d Data) HasAccessToken(token string) bool { if token == "" { return false } for _, k := range d.AccessKeys { if k.Enabled && k.Key == token { return true } } return false } func randomHex(n int) string { buf := make([]byte, n) if _, err := rand.Read(buf); err != nil { return fmt.Sprintf("%d", time.Now().UnixNano()) } return fmt.Sprintf("%x", buf) }