package pluginhost import (	"bytes"	"sort"	"strconv"	"strings" 	"github.com/router-for-me/CLIProxyAPI/v7/internal/config"	"gopkg.in/yaml.v3") var defaultRuntimeConfigYAML = []byte("enabled: false\npriority: 0\n") type runtimeConfig struct {	Enabled bool	Dir     string	Items   map[string]runtimeItemConfig} type runtimeItemConfig struct {	ID         string	Enabled    bool	Priority   int	Version    string	ConfigYAML []byte} func runtimeConfigFromConfig(cfg *config.Config) (runtimeConfig, error) {	out := runtimeConfig{		Dir:   "plugins",		Items: make(map[string]runtimeItemConfig),	}	if cfg == nil {		return out, nil	} 	out.Enabled = cfg.Plugins.Enabled	if !out.Enabled {		return out, nil	}	pluginsDir, errResolvePluginsDir := config.ResolvePluginsDir(cfg.Plugins.Dir)	if errResolvePluginsDir != nil {		return runtimeConfig{}, errResolvePluginsDir	}	out.Dir = pluginsDir 	ids := make([]string, 0, len(cfg.Plugins.Configs))	for id := range cfg.Plugins.Configs {		ids = append(ids, id)	}	sort.Strings(ids) 	for _, id := range ids {		item := cfg.Plugins.Configs[id]		enabled := false		if item.Enabled != nil {			enabled = *item.Enabled		} 		out.Items[id] = runtimeItemConfig{			ID:         id,			Enabled:    enabled,			Priority:   item.Priority,			Version:    pluginConfigDesiredVersion(item),			ConfigYAML: runtimeConfigYAML(item, enabled),		}	}	return out, nil} func defaultRuntimeItemConfig(id string) runtimeItemConfig {	return runtimeItemConfig{		ID:         id,		Enabled:    false,		Priority:   0,		ConfigYAML: append([]byte(nil), defaultRuntimeConfigYAML...),	}} func runtimeConfigYAML(item config.PluginInstanceConfig, enabled bool) []byte {	rawNode := normalizedConfigNode(item, enabled)	rawYAML := bytes.TrimSpace(mustMarshalYAML(rawNode))	if len(rawYAML) == 0 {		return append([]byte(nil), defaultRuntimeConfigYAML...)	}	return append(append([]byte(nil), rawYAML...), '\n')} func desiredPluginVersions(items map[string]runtimeItemConfig) map[string]string {	if len(items) == 0 {		return nil	}	out := make(map[string]string, len(items))	for id, item := range items {		id = strings.TrimSpace(id)		version := strings.TrimSpace(item.Version)		if id == "" || version == "" {			continue		}		out[id] = version	}	if len(out) == 0 {		return nil	}	return out} func pluginConfigDesiredVersion(item config.PluginInstanceConfig) string {	storeNode := yamlMappingValue(&item.Raw, "store")	if storeNode == nil {		return ""	}	if version := normalizePluginDesiredVersion(yamlScalarString(yamlMappingValue(storeNode, "version"))); version != "" {		return version	}	return normalizePluginDesiredVersion(yamlScalarString(yamlMappingValue(storeNode, "release-tag")))} func normalizePluginDesiredVersion(version string) string {	version = strings.TrimSpace(version)	if len(version) > 1 && (version[0] == 'v' || version[0] == 'V') {		version = version[1:]	}	if !validPluginVersion(version) {		return ""	}	return version} func yamlScalarString(node *yaml.Node) string {	if node == nil || node.Kind == 0 {		return ""	}	if node.Kind == yaml.ScalarNode {		return strings.TrimSpace(node.Value)	}	var value string	if errDecode := node.Decode(&value); errDecode != nil {		return ""	}	return strings.TrimSpace(value)} func yamlMappingValue(node *yaml.Node, key string) *yaml.Node {	if node == nil || node.Kind != yaml.MappingNode {		return nil	}	for index := 0; index+1 < len(node.Content); index += 2 {		if node.Content[index] != nil && node.Content[index].Value == key {			return node.Content[index+1]		}	}	return nil} func normalizedConfigNode(item config.PluginInstanceConfig, enabled bool) *yaml.Node {	if item.Raw.Kind == 0 {		return defaultRuntimeConfigNode(enabled, item.Priority)	}	node := deepCopyYAMLNode(&item.Raw)	if node.Kind != yaml.MappingNode {		return node	}	ensureMappingScalar(node, "enabled", boolYAMLValue(enabled), "!!bool")	ensureMappingScalar(node, "priority", intYAMLValue(item.Priority), "!!int")	return node} func defaultRuntimeConfigNode(enabled bool, priority int) *yaml.Node {	return &yaml.Node{		Kind: yaml.MappingNode,		Tag:  "!!map",		Content: []*yaml.Node{			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "enabled"},			{Kind: yaml.ScalarNode, Tag: "!!bool", Value: boolYAMLValue(enabled)},			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "priority"},			{Kind: yaml.ScalarNode, Tag: "!!int", Value: intYAMLValue(priority)},		},	}} func ensureMappingScalar(node *yaml.Node, key, value, tag string) {	if node == nil || node.Kind != yaml.MappingNode {		return	}	for i := 0; i+1 < len(node.Content); i += 2 {		if node.Content[i] != nil && node.Content[i].Value == key {			return		}	}	node.Content = append(node.Content,		&yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: key},		&yaml.Node{Kind: yaml.ScalarNode, Tag: tag, Value: value},	)} func boolYAMLValue(v bool) string {	if v {		return "true"	}	return "false"} func intYAMLValue(v int) string {	return strconv.Itoa(v)} func deepCopyYAMLNode(node *yaml.Node) *yaml.Node {	if node == nil {		return nil	}	copyNode := *node	if len(node.Content) > 0 {		copyNode.Content = make([]*yaml.Node, 0, len(node.Content))		for _, child := range node.Content {			copyNode.Content = append(copyNode.Content, deepCopyYAMLNode(child))		}	}	return &copyNode} func mustMarshalYAML(v any) []byte {	raw, errMarshal := yaml.Marshal(v)	if errMarshal != nil {		return append([]byte(nil), defaultRuntimeConfigYAML...)	}	return raw}