mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-02-18 04:10:51 +08:00
Add management API handlers for config and auth file management
- Implemented CRUD operations for authentication files. - Added endpoints for managing API keys, quotas, proxy settings, and other configurations. - Enhanced management access with robust validation, remote access control, and persistence support. - Updated README with new configuration details. Fixed OpenAI Chat Completions for codex
This commit is contained in:
Luis Pater
@@ -8,6 +8,7 @@ import (
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
@@ -48,6 +49,17 @@ type Config struct {
|
||||
|
||||
// AllowLocalhostUnauthenticated allows unauthenticated requests from localhost.
|
||||
AllowLocalhostUnauthenticated bool `yaml:"allow-localhost-unauthenticated"`
|
||||
|
||||
// RemoteManagement nests management-related options under 'remote-management'.
|
||||
RemoteManagement RemoteManagement `yaml:"remote-management"`
|
||||
}
|
||||
|
||||
// RemoteManagement holds management API configuration under 'remote-management'.
|
||||
type RemoteManagement struct {
|
||||
// AllowRemote toggles remote (non-localhost) access to management API.
|
||||
AllowRemote bool `yaml:"allow-remote"`
|
||||
// SecretKey is the management key (plaintext or bcrypt hashed). YAML key intentionally 'secret-key'.
|
||||
SecretKey string `yaml:"secret-key"`
|
||||
}
|
||||
|
||||
// QuotaExceeded defines the behavior when API quota limits are exceeded.
|
||||
@@ -120,6 +132,344 @@ func LoadConfig(configFile string) (*Config, error) {
|
||||
return nil, fmt.Errorf("failed to parse config file: %w", err)
|
||||
}
|
||||
|
||||
// Hash remote management key if plaintext is detected (nested)
|
||||
// We consider a value to be already hashed if it looks like a bcrypt hash ($2a$, $2b$, or $2y$ prefix).
|
||||
if config.RemoteManagement.SecretKey != "" && !looksLikeBcrypt(config.RemoteManagement.SecretKey) {
|
||||
hashed, errHash := hashSecret(config.RemoteManagement.SecretKey)
|
||||
if errHash != nil {
|
||||
return nil, fmt.Errorf("failed to hash remote management key: %w", errHash)
|
||||
}
|
||||
config.RemoteManagement.SecretKey = hashed
|
||||
|
||||
// Persist the hashed value back to the config file to avoid re-hashing on next startup.
|
||||
// Preserve YAML comments and ordering; update only the nested key.
|
||||
_ = SaveConfigPreserveCommentsUpdateNestedScalar(configFile, []string{"remote-management", "secret-key"}, hashed)
|
||||
}
|
||||
|
||||
// Return the populated configuration struct.
|
||||
return &config, nil
|
||||
}
|
||||
|
||||
// looksLikeBcrypt returns true if the provided string appears to be a bcrypt hash.
|
||||
func looksLikeBcrypt(s string) bool {
|
||||
return len(s) > 4 && (s[:4] == "$2a$" || s[:4] == "$2b$" || s[:4] == "$2y$")
|
||||
}
|
||||
|
||||
// hashSecret hashes the given secret using bcrypt.
|
||||
func hashSecret(secret string) (string, error) {
|
||||
// Use default cost for simplicity.
|
||||
hashedBytes, err := bcrypt.GenerateFromPassword([]byte(secret), bcrypt.DefaultCost)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return string(hashedBytes), nil
|
||||
}
|
||||
|
||||
// SaveConfigPreserveComments writes the config back to YAML while preserving existing comments
|
||||
// and key ordering by loading the original file into a yaml.Node tree and updating values in-place.
|
||||
func SaveConfigPreserveComments(configFile string, cfg *Config) error {
|
||||
// Load original YAML as a node tree to preserve comments and ordering.
|
||||
data, err := os.ReadFile(configFile)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
var original yaml.Node
|
||||
if err = yaml.Unmarshal(data, &original); err != nil {
|
||||
return err
|
||||
}
|
||||
if original.Kind != yaml.DocumentNode || len(original.Content) == 0 {
|
||||
return fmt.Errorf("invalid yaml document structure")
|
||||
}
|
||||
if original.Content[0] == nil || original.Content[0].Kind != yaml.MappingNode {
|
||||
return fmt.Errorf("expected root mapping node")
|
||||
}
|
||||
|
||||
// Marshal the current cfg to YAML, then unmarshal to a yaml.Node we can merge from.
|
||||
rendered, err := yaml.Marshal(cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var generated yaml.Node
|
||||
if err = yaml.Unmarshal(rendered, &generated); err != nil {
|
||||
return err
|
||||
}
|
||||
if generated.Kind != yaml.DocumentNode || len(generated.Content) == 0 || generated.Content[0] == nil {
|
||||
return fmt.Errorf("invalid generated yaml structure")
|
||||
}
|
||||
if generated.Content[0].Kind != yaml.MappingNode {
|
||||
return fmt.Errorf("expected generated root mapping node")
|
||||
}
|
||||
|
||||
// Merge generated into original in-place, preserving comments/order of existing nodes.
|
||||
mergeMappingPreserve(original.Content[0], generated.Content[0])
|
||||
|
||||
// Write back.
|
||||
f, err := os.Create(configFile)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
enc := yaml.NewEncoder(f)
|
||||
enc.SetIndent(2)
|
||||
if err = enc.Encode(&original); err != nil {
|
||||
_ = enc.Close()
|
||||
return err
|
||||
}
|
||||
return enc.Close()
|
||||
}
|
||||
|
||||
// SaveConfigPreserveCommentsUpdateNestedScalar updates a nested scalar key path like ["a","b"]
|
||||
// while preserving comments and positions.
|
||||
func SaveConfigPreserveCommentsUpdateNestedScalar(configFile string, path []string, value string) error {
|
||||
data, err := os.ReadFile(configFile)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var root yaml.Node
|
||||
if err = yaml.Unmarshal(data, &root); err != nil {
|
||||
return err
|
||||
}
|
||||
if root.Kind != yaml.DocumentNode || len(root.Content) == 0 {
|
||||
return fmt.Errorf("invalid yaml document structure")
|
||||
}
|
||||
node := root.Content[0]
|
||||
// descend mapping nodes following path
|
||||
for i, key := range path {
|
||||
if i == len(path)-1 {
|
||||
// set final scalar
|
||||
v := getOrCreateMapValue(node, key)
|
||||
v.Kind = yaml.ScalarNode
|
||||
v.Tag = "!!str"
|
||||
v.Value = value
|
||||
} else {
|
||||
next := getOrCreateMapValue(node, key)
|
||||
if next.Kind != yaml.MappingNode {
|
||||
next.Kind = yaml.MappingNode
|
||||
next.Tag = "!!map"
|
||||
}
|
||||
node = next
|
||||
}
|
||||
}
|
||||
f, err := os.Create(configFile)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
enc := yaml.NewEncoder(f)
|
||||
enc.SetIndent(2)
|
||||
if err = enc.Encode(&root); err != nil {
|
||||
_ = enc.Close()
|
||||
return err
|
||||
}
|
||||
return enc.Close()
|
||||
}
|
||||
|
||||
// getOrCreateMapValue finds the value node for a given key in a mapping node.
|
||||
// If not found, it appends a new key/value pair and returns the new value node.
|
||||
func getOrCreateMapValue(mapNode *yaml.Node, key string) *yaml.Node {
|
||||
if mapNode.Kind != yaml.MappingNode {
|
||||
mapNode.Kind = yaml.MappingNode
|
||||
mapNode.Tag = "!!map"
|
||||
mapNode.Content = nil
|
||||
}
|
||||
for i := 0; i+1 < len(mapNode.Content); i += 2 {
|
||||
k := mapNode.Content[i]
|
||||
if k.Value == key {
|
||||
return mapNode.Content[i+1]
|
||||
}
|
||||
}
|
||||
// append new key/value
|
||||
mapNode.Content = append(mapNode.Content, &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: key})
|
||||
val := &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: ""}
|
||||
mapNode.Content = append(mapNode.Content, val)
|
||||
return val
|
||||
}
|
||||
|
||||
// Helpers to update sequences in place to preserve existing comments/anchors
|
||||
func setStringListInPlace(mapNode *yaml.Node, key string, arr []string) {
|
||||
if len(arr) == 0 {
|
||||
setNullValue(mapNode, key)
|
||||
return
|
||||
}
|
||||
v := getOrCreateMapValue(mapNode, key)
|
||||
if v.Kind != yaml.SequenceNode {
|
||||
v.Kind = yaml.SequenceNode
|
||||
v.Tag = "!!seq"
|
||||
v.Content = nil
|
||||
}
|
||||
// Update in place
|
||||
oldLen := len(v.Content)
|
||||
minLen := oldLen
|
||||
if len(arr) < minLen {
|
||||
minLen = len(arr)
|
||||
}
|
||||
for i := 0; i < minLen; i++ {
|
||||
if v.Content[i] == nil {
|
||||
v.Content[i] = &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str"}
|
||||
}
|
||||
v.Content[i].Kind = yaml.ScalarNode
|
||||
v.Content[i].Tag = "!!str"
|
||||
v.Content[i].Value = arr[i]
|
||||
}
|
||||
if len(arr) > oldLen {
|
||||
for i := oldLen; i < len(arr); i++ {
|
||||
v.Content = append(v.Content, &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: arr[i]})
|
||||
}
|
||||
} else if len(arr) < oldLen {
|
||||
v.Content = v.Content[:len(arr)]
|
||||
}
|
||||
}
|
||||
|
||||
func setMappingScalar(mapNode *yaml.Node, key string, val string) {
|
||||
v := getOrCreateMapValue(mapNode, key)
|
||||
v.Kind = yaml.ScalarNode
|
||||
v.Tag = "!!str"
|
||||
v.Value = val
|
||||
}
|
||||
|
||||
// setNullValue ensures a mapping key exists and is set to an explicit null scalar,
|
||||
// so that it renders as `key:` without `[]`.
|
||||
func setNullValue(mapNode *yaml.Node, key string) {
|
||||
// Represent as YAML null scalar without explicit value so it renders as `key:`
|
||||
v := getOrCreateMapValue(mapNode, key)
|
||||
v.Kind = yaml.ScalarNode
|
||||
v.Tag = "!!null"
|
||||
v.Value = ""
|
||||
}
|
||||
|
||||
// mergeMappingPreserve merges keys from src into dst mapping node while preserving
|
||||
// key order and comments of existing keys in dst. Unknown keys from src are appended
|
||||
// to dst at the end, copying their node structure from src.
|
||||
func mergeMappingPreserve(dst, src *yaml.Node) {
|
||||
if dst == nil || src == nil {
|
||||
return
|
||||
}
|
||||
if dst.Kind != yaml.MappingNode || src.Kind != yaml.MappingNode {
|
||||
// If kinds do not match, prefer replacing dst with src semantics in-place
|
||||
// but keep dst node object to preserve any attached comments at the parent level.
|
||||
copyNodeShallow(dst, src)
|
||||
return
|
||||
}
|
||||
// Build a lookup of existing keys in dst
|
||||
for i := 0; i+1 < len(src.Content); i += 2 {
|
||||
sk := src.Content[i]
|
||||
sv := src.Content[i+1]
|
||||
idx := findMapKeyIndex(dst, sk.Value)
|
||||
if idx >= 0 {
|
||||
// Merge into existing value node
|
||||
dv := dst.Content[idx+1]
|
||||
mergeNodePreserve(dv, sv)
|
||||
} else {
|
||||
// Append new key/value pair by deep-copying from src
|
||||
dst.Content = append(dst.Content, deepCopyNode(sk), deepCopyNode(sv))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// mergeNodePreserve merges src into dst for scalars, mappings and sequences while
|
||||
// reusing destination nodes to keep comments and anchors. For sequences, it updates
|
||||
// in-place by index.
|
||||
func mergeNodePreserve(dst, src *yaml.Node) {
|
||||
if dst == nil || src == nil {
|
||||
return
|
||||
}
|
||||
switch src.Kind {
|
||||
case yaml.MappingNode:
|
||||
if dst.Kind != yaml.MappingNode {
|
||||
copyNodeShallow(dst, src)
|
||||
}
|
||||
mergeMappingPreserve(dst, src)
|
||||
case yaml.SequenceNode:
|
||||
// Preserve explicit null style if dst was null and src is empty sequence
|
||||
if dst.Kind == yaml.ScalarNode && dst.Tag == "!!null" && len(src.Content) == 0 {
|
||||
// Keep as null to preserve original style
|
||||
return
|
||||
}
|
||||
if dst.Kind != yaml.SequenceNode {
|
||||
dst.Kind = yaml.SequenceNode
|
||||
dst.Tag = "!!seq"
|
||||
dst.Content = nil
|
||||
}
|
||||
// Update elements in place
|
||||
minContent := len(dst.Content)
|
||||
if len(src.Content) < minContent {
|
||||
minContent = len(src.Content)
|
||||
}
|
||||
for i := 0; i < minContent; i++ {
|
||||
if dst.Content[i] == nil {
|
||||
dst.Content[i] = deepCopyNode(src.Content[i])
|
||||
continue
|
||||
}
|
||||
mergeNodePreserve(dst.Content[i], src.Content[i])
|
||||
}
|
||||
// Append any extra items from src
|
||||
for i := len(dst.Content); i < len(src.Content); i++ {
|
||||
dst.Content = append(dst.Content, deepCopyNode(src.Content[i]))
|
||||
}
|
||||
// Truncate if dst has extra items not in src
|
||||
if len(src.Content) < len(dst.Content) {
|
||||
dst.Content = dst.Content[:len(src.Content)]
|
||||
}
|
||||
case yaml.ScalarNode, yaml.AliasNode:
|
||||
// For scalars, update Tag and Value but keep Style from dst to preserve quoting
|
||||
dst.Kind = src.Kind
|
||||
dst.Tag = src.Tag
|
||||
dst.Value = src.Value
|
||||
// Keep dst.Style as-is intentionally
|
||||
case 0:
|
||||
// Unknown/empty kind; do nothing
|
||||
default:
|
||||
// Fallback: replace shallowly
|
||||
copyNodeShallow(dst, src)
|
||||
}
|
||||
}
|
||||
|
||||
// findMapKeyIndex returns the index of key node in dst mapping (index of key, not value).
|
||||
// Returns -1 when not found.
|
||||
func findMapKeyIndex(mapNode *yaml.Node, key string) int {
|
||||
if mapNode == nil || mapNode.Kind != yaml.MappingNode {
|
||||
return -1
|
||||
}
|
||||
for i := 0; i+1 < len(mapNode.Content); i += 2 {
|
||||
if mapNode.Content[i] != nil && mapNode.Content[i].Value == key {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// deepCopyNode creates a deep copy of a yaml.Node graph.
|
||||
func deepCopyNode(n *yaml.Node) *yaml.Node {
|
||||
if n == nil {
|
||||
return nil
|
||||
}
|
||||
cp := *n
|
||||
if len(n.Content) > 0 {
|
||||
cp.Content = make([]*yaml.Node, len(n.Content))
|
||||
for i := range n.Content {
|
||||
cp.Content[i] = deepCopyNode(n.Content[i])
|
||||
}
|
||||
}
|
||||
return &cp
|
||||
}
|
||||
|
||||
// copyNodeShallow copies type/tag/value and resets content to match src, but
|
||||
// keeps the same destination node pointer to preserve parent relations/comments.
|
||||
func copyNodeShallow(dst, src *yaml.Node) {
|
||||
if dst == nil || src == nil {
|
||||
return
|
||||
}
|
||||
dst.Kind = src.Kind
|
||||
dst.Tag = src.Tag
|
||||
dst.Value = src.Value
|
||||
// Replace content with deep copy from src
|
||||
if len(src.Content) > 0 {
|
||||
dst.Content = make([]*yaml.Node, len(src.Content))
|
||||
for i := range src.Content {
|
||||
dst.Content[i] = deepCopyNode(src.Content[i])
|
||||
}
|
||||
} else {
|
||||
dst.Content = nil
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user