gcli2api / internal /extstore /extstore.go
a3216's picture
feat: 同步上游 320f5d4;扩展模型(多免费渠道/自定义映射/访问密钥/模型白名单)
e48a2d8
Raw History Blame Contribute Delete
22 kB
// 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>/<id> 的 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:<name>/<id>;只允许 [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)
}