feat: 节点删除\重命名\去重

pkg/parser/hysteria.go

@@ -0,0 +1,83 @@
+package parser
+
+import (
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+	"sub2sing-box/internal/model"
+)
+
+//hysteria://host:port?protocol=udp&auth=123456&peer=sni.domain&insecure=1&upmbps=100&downmbps=100&alpn=hysteria&obfs=xplus&obfsParam=123456#remarks
+//
+//- host: hostname or IP address of the server to connect to (required)
+//- port: port of the server to connect to (required)
+//- protocol: protocol to use ("udp", "wechat-video", "faketcp") (optional, default: "udp")
+//- auth: authentication payload (string) (optional)
+//- peer: SNI for TLS (optional)
+//- insecure: ignore certificate errors (optional)
+//- upmbps: upstream bandwidth in Mbps (required)
+//- downmbps: downstream bandwidth in Mbps (required)
+//- alpn: QUIC ALPN (optional)
+//- obfs: Obfuscation mode (optional, empty or "xplus")
+//- obfsParam: Obfuscation password (optional)
+//- remarks: remarks (optional)
+
+func ParseHysteria(proxy string) (model.Proxy, error) {
+	if !strings.HasPrefix(proxy, "hysteria://") {
+		return model.Proxy{}, errors.New("invalid hysteria Url")
+	}
+	parts := strings.SplitN(strings.TrimPrefix(proxy, "hysteria://"), "?", 2)
+	serverInfo := strings.SplitN(parts[0], ":", 2)
+	if len(serverInfo) != 2 {
+		return model.Proxy{}, errors.New("invalid hysteria Url")
+	}
+	params, err := url.ParseQuery(parts[1])
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid hysteria Url")
+	}
+	host := serverInfo[0]
+	port, err := strconv.Atoi(serverInfo[1])
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid hysteria Url")
+	}
+	protocol := params.Get("protocol")
+	auth := params.Get("auth")
+	// peer := params.Get("peer")
+	insecure := params.Get("insecure")
+	upmbps := params.Get("upmbps")
+	downmbps := params.Get("downmbps")
+	alpn := params.Get("alpn")
+	obfs := params.Get("obfs")
+	// obfsParam := params.Get("obfsParam")
+	remarks := ""
+	if strings.Contains(parts[1], "#") {
+		r := strings.Split(parts[1], "#")
+		remarks = r[len(r)-1]
+	} else {
+		remarks = serverInfo[0] + ":" + serverInfo[1]
+	}
+	insecureBool, err := strconv.ParseBool(insecure)
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid hysteria Url")
+	}
+	result := model.Proxy{
+		Type: "hysteria",
+		Tag:  remarks,
+		Hysteria: model.Hysteria{
+			Server:     host,
+			ServerPort: uint16(port),
+			Up:         upmbps,
+			Down:       downmbps,
+			Auth:       []byte(auth),
+			Obfs:       obfs,
+			Network:    protocol,
+			TLS: &model.OutboundTLSOptions{
+				Enabled:  true,
+				Insecure: insecureBool,
+				ALPN:     strings.Split(alpn, ","),
+			},
+		},
+	}
+	return result, nil
+}

pkg/parser/hysteria2.go

@@ -0,0 +1,58 @@
+package parser
+
+import (
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+	"sub2sing-box/internal/model"
+)
+
+// hysteria2://letmein@example.com/?insecure=1&obfs=salamander&obfs-password=gawrgura&pinSHA256=deadbeef&sni=real.example.com
+
+func ParseHysteria2(proxy string) (model.Proxy, error) {
+	if !strings.HasPrefix(proxy, "hysteria2://") && !strings.HasPrefix(proxy, "hy2://") {
+		return model.Proxy{}, errors.New("invalid hysteria2 Url")
+	}
+	parts := strings.SplitN(strings.TrimPrefix(proxy, "hysteria2://"), "@", 2)
+	serverInfo := strings.SplitN(parts[1], "/?", 2)
+	serverAndPort := strings.SplitN(serverInfo[0], ":", 2)
+	if len(serverAndPort) == 1 {
+		serverAndPort = append(serverAndPort, "443")
+	} else if len(serverAndPort) != 2 {
+		return model.Proxy{}, errors.New("invalid hysteria2 Url")
+	}
+	params, err := url.ParseQuery(serverInfo[1])
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid hysteria2 Url")
+	}
+	port, err := strconv.Atoi(serverAndPort[1])
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid hysteria2 Url")
+	}
+	remarks := params.Get("name")
+	server := serverAndPort[0]
+	password := parts[0]
+	network := params.Get("network")
+	result := model.Proxy{
+		Type: "hysteria2",
+		Tag:  remarks,
+		Hysteria2: model.Hysteria2{
+			Server:     server,
+			ServerPort: uint16(port),
+			Password:   password,
+			Obfs: &model.Hysteria2Obfs{
+				Type:     params.Get("obfs"),
+				Password: params.Get("obfs-password"),
+			},
+			TLS: &model.OutboundTLSOptions{
+				Enabled:     params.Get("pinSHA256") != "",
+				Insecure:    params.Get("insecure") == "1",
+				ServerName:  params.Get("sni"),
+				Certificate: []string{params.Get("pinSHA256")},
+			},
+			Network: network,
+		},
+	}
+	return result, nil
+}

pkg/parser/parsers_map.go

@@ -0,0 +1,15 @@
+package parser
+
+import (
+	"sub2sing-box/internal/model"
+)
+
+var ParserMap map[string]func(string) (model.Proxy, error) = map[string]func(string) (model.Proxy, error){
+	"ss://":        ParseShadowsocks,
+	"vmess://":     ParseVmess,
+	"trojan://":    ParseTrojan,
+	"vless://":     ParseVless,
+	"hysteria://":  ParseHysteria,
+	"hy2://":       ParseHysteria2,
+	"hysteria2://": ParseHysteria2,
+}

pkg/parser/shadowsocks.go

@@ -0,0 +1,64 @@
+package parser
+
+import (
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+	"sub2sing-box/internal"
+	"sub2sing-box/internal/model"
+)
+
+func ParseShadowsocks(proxy string) (model.Proxy, error) {
+	if !strings.HasPrefix(proxy, "ss://") {
+		return model.Proxy{}, errors.New("invalid ss Url")
+	}
+	parts := strings.SplitN(strings.TrimPrefix(proxy, "ss://"), "@", 2)
+	if len(parts) != 2 {
+		return model.Proxy{}, errors.New("invalid ss Url")
+	}
+	if !strings.Contains(parts[0], ":") {
+		decoded, err := internal.DecodeBase64(parts[0])
+		if err != nil {
+			return model.Proxy{}, errors.New("invalid ss Url" + err.Error())
+		}
+		parts[0] = decoded
+	}
+	credentials := strings.SplitN(parts[0], ":", 2)
+	if len(credentials) != 2 {
+		return model.Proxy{}, errors.New("invalid ss Url")
+	}
+	serverInfo := strings.SplitN(parts[1], "#", 2)
+	serverAndPort := strings.SplitN(serverInfo[0], ":", 2)
+	if len(serverAndPort) != 2 {
+		return model.Proxy{}, errors.New("invalid ss Url")
+	}
+	port, err := strconv.Atoi(strings.TrimSpace(serverAndPort[1]))
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid ss Url" + err.Error())
+	}
+	remarks := ""
+	if len(serverInfo) == 2 {
+		unescape, err := url.QueryUnescape(serverInfo[1])
+		if err != nil {
+			return model.Proxy{}, errors.New("invalid ss Url" + err.Error())
+		}
+		remarks = strings.TrimSpace(unescape)
+	} else {
+		remarks = strings.TrimSpace(serverAndPort[0])
+	}
+	method := credentials[0]
+	password := credentials[1]
+	server := strings.TrimSpace(serverAndPort[0])
+	result := model.Proxy{
+		Type: "shadowsocks",
+		Tag:  remarks,
+		Shadowsocks: model.Shadowsocks{
+			Method:     method,
+			Password:   password,
+			Server:     server,
+			ServerPort: uint16(port),
+		},
+	}
+	return result, nil
+}

pkg/parser/trojan.go

@@ -0,0 +1,108 @@
+package parser
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+	"strings"
+	"sub2sing-box/internal/model"
+)
+
+func ParseTrojan(proxy string) (model.Proxy, error) {
+	if !strings.HasPrefix(proxy, "trojan://") {
+		return model.Proxy{}, fmt.Errorf("invalid trojan Url")
+	}
+	parts := strings.SplitN(strings.TrimPrefix(proxy, "trojan://"), "@", 2)
+	if len(parts) != 2 {
+		return model.Proxy{}, fmt.Errorf("invalid trojan Url")
+	}
+	serverInfo := strings.SplitN(parts[1], "#", 2)
+	serverAndPortAndParams := strings.SplitN(serverInfo[0], "?", 2)
+	serverAndPort := strings.SplitN(serverAndPortAndParams[0], ":", 2)
+	params, err := url.ParseQuery(serverAndPortAndParams[1])
+	if err != nil {
+		return model.Proxy{}, err
+	}
+	if len(serverAndPort) != 2 {
+		return model.Proxy{}, fmt.Errorf("invalid trojan")
+	}
+	port, err := strconv.Atoi(strings.TrimSpace(serverAndPort[1]))
+	if err != nil {
+		return model.Proxy{}, err
+	}
+	remarks := ""
+	if len(serverInfo) == 2 {
+		remarks, _ = url.QueryUnescape(strings.TrimSpace(serverInfo[1]))
+	} else {
+		remarks = serverAndPort[0]
+	}
+	server := strings.TrimSpace(serverAndPort[0])
+	password := strings.TrimSpace(parts[0])
+	result := model.Proxy{
+		Type: "trojan",
+		Tag:  remarks,
+		Trojan: model.Trojan{
+			Server:     server,
+			ServerPort: uint16(port),
+			Password:   password,
+			Network:    params.Get("type"),
+		},
+	}
+	if params.Get("security") == "xtls" || params.Get("security") == "tls" {
+		result.Trojan.TLS = &model.OutboundTLSOptions{
+			Enabled:    true,
+			ALPN:       strings.Split(params.Get("alpn"), ","),
+			ServerName: params.Get("sni"),
+		}
+	}
+	if params.Get("security") == "reality" {
+		result.Trojan.TLS = &model.OutboundTLSOptions{
+			Enabled:    true,
+			ServerName: params.Get("sni"),
+			Reality: &model.OutboundRealityOptions{
+				Enabled:   true,
+				PublicKey: params.Get("pbk"),
+				ShortID:   params.Get("sid"),
+			},
+			UTLS: &model.OutboundUTLSOptions{
+				Enabled:     params.Get("fp") != "",
+				Fingerprint: params.Get("fp"),
+			},
+		}
+	}
+	if params.Get("type") == "ws" {
+		result.Trojan.Transport = &model.V2RayTransportOptions{
+			Type: "ws",
+			WebsocketOptions: model.V2RayWebsocketOptions{
+				Path: params.Get("path"),
+				Headers: map[string]string{
+					"Host": params.Get("host"),
+				},
+			},
+		}
+	}
+	if params.Get("type") == "http" {
+		result.Trojan.Transport = &model.V2RayTransportOptions{
+			Type: "http",
+			HTTPOptions: model.V2RayHTTPOptions{
+				Host: []string{params.Get("host")},
+				Path: params.Get("path"),
+			},
+		}
+	}
+	if params.Get("type") == "quic" {
+		result.Trojan.Transport = &model.V2RayTransportOptions{
+			Type:        "quic",
+			QUICOptions: model.V2RayQUICOptions{},
+		}
+	}
+	if params.Get("type") == "grpc" {
+		result.Trojan.Transport = &model.V2RayTransportOptions{
+			Type: "grpc",
+			GRPCOptions: model.V2RayGRPCOptions{
+				ServiceName: params.Get("serviceName"),
+			},
+		}
+	}
+	return result, nil
+}

pkg/parser/vless.go

@@ -0,0 +1,122 @@
+package parser
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+	"strings"
+	"sub2sing-box/internal/model"
+)
+
+func ParseVless(proxy string) (model.Proxy, error) {
+	if !strings.HasPrefix(proxy, "vless://") {
+		return model.Proxy{}, fmt.Errorf("invalid vless Url")
+	}
+	parts := strings.SplitN(strings.TrimPrefix(proxy, "vless://"), "@", 2)
+	if len(parts) != 2 {
+		return model.Proxy{}, fmt.Errorf("invalid vless Url")
+	}
+	serverInfo := strings.SplitN(parts[1], "#", 2)
+	serverAndPortAndParams := strings.SplitN(serverInfo[0], "?", 2)
+	serverAndPort := strings.SplitN(serverAndPortAndParams[0], ":", 2)
+	params, err := url.ParseQuery(serverAndPortAndParams[1])
+	if err != nil {
+		return model.Proxy{}, err
+	}
+	if len(serverAndPort) != 2 {
+		return model.Proxy{}, fmt.Errorf("invalid vless")
+	}
+	port, err := strconv.Atoi(strings.TrimSpace(serverAndPort[1]))
+	if err != nil {
+		return model.Proxy{}, err
+	}
+	remarks := ""
+	if len(serverInfo) == 2 {
+		if strings.Contains(serverInfo[1], "|") {
+			remarks = strings.SplitN(serverInfo[1], "|", 2)[1]
+		} else {
+			remarks, err = url.QueryUnescape(serverInfo[1])
+			if err != nil {
+				return model.Proxy{}, err
+			}
+		}
+	} else {
+		remarks, err = url.QueryUnescape(serverAndPort[0])
+		if err != nil {
+			return model.Proxy{}, err
+		}
+	}
+	server := strings.TrimSpace(serverAndPort[0])
+	uuid := strings.TrimSpace(parts[0])
+	result := model.Proxy{
+		Type: "vless",
+		Tag:  remarks,
+		VLESS: model.VLESS{
+			Server:     server,
+			ServerPort: uint16(port),
+			UUID:       uuid,
+			Flow:       params.Get("flow"),
+		},
+	}
+	if params.Get("security") == "tls" {
+		result.VLESS.TLS = &model.OutboundTLSOptions{
+			Enabled:  true,
+			ALPN:     strings.Split(params.Get("alpn"), ","),
+			Insecure: params.Get("allowInsecure") == "1",
+		}
+	}
+	if params.Get("security") == "reality" {
+		result.VLESS.TLS = &model.OutboundTLSOptions{
+			Enabled:    true,
+			ServerName: params.Get("sni"),
+			UTLS: &model.OutboundUTLSOptions{
+				Enabled:     params.Get("fp") != "",
+				Fingerprint: params.Get("fp"),
+			},
+			Reality: &model.OutboundRealityOptions{
+				Enabled:   true,
+				PublicKey: params.Get("pbk"),
+				ShortID:   params.Get("sid"),
+			},
+			ALPN: strings.Split(params.Get("alpn"), ","),
+		}
+	}
+	if params.Get("type") == "ws" {
+		result.VLESS.Transport = &model.V2RayTransportOptions{
+			Type: "ws",
+			WebsocketOptions: model.V2RayWebsocketOptions{
+				Path: params.Get("path"),
+				Headers: map[string]string{
+					"Host": params.Get("host"),
+				},
+			},
+		}
+	}
+	if params.Get("type") == "quic" {
+		result.VLESS.Transport = &model.V2RayTransportOptions{
+			Type:        "quic",
+			QUICOptions: model.V2RayQUICOptions{},
+		}
+	}
+	if params.Get("type") == "grpc" {
+		result.VLESS.Transport = &model.V2RayTransportOptions{
+			Type: "grpc",
+			GRPCOptions: model.V2RayGRPCOptions{
+				ServiceName: params.Get("serviceName"),
+			},
+		}
+	}
+	if params.Get("type") == "http" {
+		host, err := url.QueryUnescape(params.Get("host"))
+		if err != nil {
+			return model.Proxy{}, err
+		}
+		result.VLESS.Transport = &model.V2RayTransportOptions{
+			Type: "http",
+			HTTPOptions: model.V2RayHTTPOptions{
+				Host: strings.Split(host, ","),
+			},
+		}
+	}
+	return result, nil
+}

pkg/parser/vmess.go

@@ -0,0 +1,132 @@
+package parser
+
+import (
+	"encoding/json"
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+	"sub2sing-box/internal"
+	"sub2sing-box/internal/model"
+)
+
+func ParseVmess(proxy string) (model.Proxy, error) {
+	if !strings.HasPrefix(proxy, "vmess://") {
+		return model.Proxy{}, errors.New("invalid vmess url")
+	}
+	base64, err := internal.DecodeBase64(strings.TrimPrefix(proxy, "vmess://"))
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid vmess url" + err.Error())
+	}
+	var vmess model.VmessJson
+	err = json.Unmarshal([]byte(base64), &vmess)
+	if err != nil {
+		return model.Proxy{}, errors.New("invalid vmess url" + err.Error())
+	}
+	port := 0
+	switch vmess.Port.(type) {
+	case string:
+		port, err = strconv.Atoi(vmess.Port.(string))
+		if err != nil {
+			return model.Proxy{}, errors.New("invalid vmess url" + err.Error())
+		}
+	case float64:
+		port = int(vmess.Port.(float64))
+	}
+	aid := 0
+	switch vmess.Aid.(type) {
+	case string:
+		aid, err = strconv.Atoi(vmess.Aid.(string))
+		if err != nil {
+			return model.Proxy{}, errors.New("invalid vmess url" + err.Error())
+		}
+	case float64:
+		aid = int(vmess.Aid.(float64))
+	}
+	if vmess.Scy == "" {
+		vmess.Scy = "auto"
+	}
+
+	name, err := url.QueryUnescape(vmess.Ps)
+	if err != nil {
+		name = vmess.Ps
+	}
+
+	result := model.Proxy{
+		Type: "vmess",
+		Tag:  name,
+		VMess: model.VMess{
+			Server:     vmess.Add,
+			ServerPort: uint16(port),
+			UUID:       vmess.Id,
+			AlterId:    aid,
+			Security:   vmess.Scy,
+		},
+	}
+
+	if vmess.Tls == "tls" {
+		tls := model.OutboundTLSOptions{
+			Enabled: true,
+			UTLS: &model.OutboundUTLSOptions{
+				Fingerprint: vmess.Fp,
+			},
+			ALPN: strings.Split(vmess.Alpn, ","),
+		}
+		result.VMess.TLS = &tls
+	}
+
+	if vmess.Net == "ws" {
+		if vmess.Path == "" {
+			vmess.Path = "/"
+		}
+		if vmess.Host == "" {
+			vmess.Host = vmess.Add
+		}
+		ws := model.V2RayWebsocketOptions{
+			Path: vmess.Path,
+			Headers: map[string]string{
+				"Host": vmess.Host,
+			},
+		}
+		transport := model.V2RayTransportOptions{
+			Type:             "ws",
+			WebsocketOptions: ws,
+		}
+		result.VMess.Transport = &transport
+	}
+
+	if vmess.Net == "quic" {
+		quic := model.V2RayQUICOptions{}
+		transport := model.V2RayTransportOptions{
+			Type:        "quic",
+			QUICOptions: quic,
+		}
+		result.VMess.Transport = &transport
+	}
+
+	if vmess.Net == "grpc" {
+		grpc := model.V2RayGRPCOptions{
+			ServiceName:         vmess.Path,
+			PermitWithoutStream: true,
+		}
+		transport := model.V2RayTransportOptions{
+			Type:        "grpc",
+			GRPCOptions: grpc,
+		}
+		result.VMess.Transport = &transport
+	}
+
+	if vmess.Net == "h2" {
+		httpOps := model.V2RayHTTPOptions{
+			Host: strings.Split(vmess.Host, ","),
+			Path: vmess.Path,
+		}
+		transport := model.V2RayTransportOptions{
+			Type:        "http",
+			HTTPOptions: httpOps,
+		}
+		result.VMess.Transport = &transport
+	}
+
+	return result, nil
+}

pkg/util/convert.go

@@ -0,0 +1,179 @@
+package util
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+
+	. "sub2sing-box/internal"
+	"sub2sing-box/internal/model"
+	"sub2sing-box/pkg/parser"
+)
+
+func MergeTemplate(proxies []model.Proxy, template string) (string, error) {
+	config, err := ReadTemplate(template)
+	proxyTags := make([]string, 0)
+	if err != nil {
+		return "", err
+	}
+	for _, p := range proxies {
+		proxyTags = append(proxyTags, p.Tag)
+	}
+	ps, err := json.Marshal(&proxies)
+	fmt.Print(string(ps))
+	if err != nil {
+		return "", err
+	}
+	var newOutbounds []model.Outbound
+	err = json.Unmarshal(ps, &newOutbounds)
+	if err != nil {
+		return "", err
+	}
+	for i, outbound := range config.Outbounds {
+		if outbound.Type == "urltest" || outbound.Type == "selector" {
+			var parsedOutbound []string = make([]string, 0)
+			for _, o := range outbound.Outbounds {
+				if o == "<all-proxy-tags>" {
+					parsedOutbound = append(parsedOutbound, proxyTags...)
+				} else {
+					parsedOutbound = append(parsedOutbound, o)
+				}
+			}
+			config.Outbounds[i].Outbounds = parsedOutbound
+		}
+	}
+	config.Outbounds = append(config.Outbounds, newOutbounds...)
+	data, err := json.Marshal(config)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func ConvertCProxyToSProxy(proxy string) (model.Proxy, error) {
+	for prefix, parseFunc := range parser.ParserMap {
+		if strings.HasPrefix(proxy, prefix) {
+			proxy, err := parseFunc(proxy)
+			if err != nil {
+				return model.Proxy{}, err
+			}
+			return proxy, nil
+		}
+	}
+	return model.Proxy{}, errors.New("Unknown proxy format")
+}
+
+func ConvertCProxyToJson(proxy string) (string, error) {
+	sProxy, err := ConvertCProxyToSProxy(proxy)
+	if err != nil {
+		return "", err
+	}
+	data, err := json.Marshal(&sProxy)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func FetchSubscription(url string, maxRetryTimes int) (string, error) {
+	retryTime := 0
+	var err error
+	for retryTime < maxRetryTimes {
+		resp, err := http.Get(url)
+		if err != nil {
+			retryTime++
+			continue
+		}
+		data, err := io.ReadAll(resp.Body)
+		if err != nil {
+			retryTime++
+			continue
+		}
+		return string(data), err
+	}
+	return "", err
+}
+
+func ConvertSubscriptionsToSProxy(urls []string) ([]model.Proxy, error) {
+	proxyList := make([]model.Proxy, 0)
+	for _, url := range urls {
+		data, err := FetchSubscription(url, 3)
+		if err != nil {
+			return nil, err
+		}
+		proxy, err := DecodeBase64(data)
+		if err != nil {
+			return nil, err
+		}
+		proxies := strings.Split(proxy, "\n")
+		for _, p := range proxies {
+			for prefix, parseFunc := range parser.ParserMap {
+				if strings.HasPrefix(p, prefix) {
+					proxy, err := parseFunc(p)
+					if err != nil {
+						return nil, err
+					}
+					proxyList = append(proxyList, proxy)
+				}
+			}
+		}
+	}
+	return proxyList, nil
+}
+
+func ConvertSubscriptionsToJson(urls []string) (string, error) {
+	proxyList, err := ConvertSubscriptionsToSProxy(urls)
+	if err != nil {
+		return "", err
+	}
+	result, err := json.Marshal(proxyList)
+	if err != nil {
+		return "", err
+	}
+	return string(result), nil
+}
+
+func ReadTemplate(path string) (model.Config, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return model.Config{}, err
+	}
+	var res model.Config
+	err = json.Unmarshal(data, &res)
+	if err != nil {
+		return model.Config{}, err
+	}
+	return res, nil
+}
+
+func DeleteProxy(proxies []model.Proxy, regex string) ([]model.Proxy, error) {
+	reg, err := regexp.Compile(regex)
+	if err != nil {
+		return nil, err
+	}
+	var newProxies []model.Proxy
+	for _, p := range proxies {
+		if !reg.MatchString(p.Tag) {
+			newProxies = append(newProxies, p)
+		}
+	}
+	return newProxies, nil
+}
+
+func RenameProxy(proxies []model.Proxy, regex string, replaceText string) ([]model.Proxy, error) {
+	reg, err := regexp.Compile(regex)
+	if err != nil {
+		return nil, err
+	}
+	for i, p := range proxies {
+		if reg.MatchString(p.Tag) {
+			proxies[i].Tag = reg.ReplaceAllString(p.Tag, replaceText)
+		}
+	}
+	return proxies, nil
+}