Download internal/extstore/extstore.go from a3216/gcli2api: direct link, hf CLI and curl.
- Browser
- Download file 22 kB
-
https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/extstore/extstore.go
- Command line
-
hf download hf://spaces/a3216/gcli2api/internal/extstore/extstore.go
-
curl -L -o extstore.go https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/extstore/extstore.go
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) | |
| } | |