Refactor proxy construction functions and add new features

- Updated `vmessConstruct`, `ssConstruct`, `trojanConstruct`, and other proxy construction functions to include additional parameters such as ALPN lists, fingerprints, and new options for HTTP upgrades.
- Introduced new proxy construction functions: `TUICConstruct`, `anyTLSConstruct`, `vlessConstruct`, `mieruConstruct`, and `sudokuConstruct`.
- Enhanced the `explode` functions to support new proxy types and formats.
- Added `splitKeyValue` function to utility for parsing key-value pairs, useful for protocols like SS2022.
- Created a PowerShell script to start a local HTTP server for testing purposes.

Author: LM-Firefly

src/generator/config/nodemanip.cpp

@@ -41,6 +41,7 @@ int addNodes(std::string link, std::vector<Proxy> &allNodes, int groupID, parse_
     RegexMatchConfigs &time_rules = *parse_set.time_rules;
     string_icase_map *request_headers = parse_set.request_header;
     bool &authorized = parse_set.authorized;
+    string_icase_map custom_headers;
 
     ConfType linkType = ConfType::Unknow;
     std::vector<Proxy> nodes;
@@ -142,7 +143,13 @@ int addNodes(std::string link, std::vector<Proxy> &allNodes, int groupID, parse_
         writeLog(LOG_TYPE_INFO, "Downloading subscription data...");
         if(startsWith(link, "surge:///install-config")) //surge config link
             link = urlDecode(getUrlArg(link, "url"));
-        strSub = webGet(link, proxy, global.cacheSubscription, &extra_headers, request_headers);
+        if(request_headers)
+            custom_headers = *request_headers;
+        if(parse_set.custom_user_agent && !parse_set.custom_user_agent->empty())
+        {
+            custom_headers["User-Agent"] = *parse_set.custom_user_agent;
+        }
+        strSub = webGet(link, proxy, global.cacheSubscription, &extra_headers, &custom_headers);
         /*
         if(strSub.size() == 0)
         {
@@ -426,12 +433,14 @@ std::string removeEmoji(const std::string &orig_remark)
     return remark;
 }
 
-std::string addEmoji(const Proxy &node, const RegexMatchConfigs &emoji_array, extra_settings &ext)
+std::string addEmoji(const Proxy &node, const RegexMatchConfigs &emoji_array, extra_settings &ext, const std::string &original_remark)
 {
     std::string real_rule, ret;
 
     for(const RegexMatchConfig &x : emoji_array)
     {
+        Proxy origNode = node;
+        origNode.Remark = original_remark;
         if(!x.Script.empty() && ext.authorized)
         {
             std::string result;
@@ -444,9 +453,21 @@ std::string addEmoji(const Proxy &node, const RegexMatchConfigs &emoji_array, ex
                 {
                     ctx.eval(script);
                     auto getEmoji = (std::function<std::string(const Proxy&)>) ctx.eval("getEmoji");
-                    ret = getEmoji(node);
+                    ret = getEmoji(origNode);
+                    if(ret.empty())
+                        ret = getEmoji(node);
                     if(!ret.empty())
-                        result = ret + " " + node.Remark;
+                    {
+                        std::string trimmed = trim(node.Remark);
+                        if(trimmed != removeEmoji(trimmed))
+                        {
+                            result = node.Remark;
+                        }
+                        else if(startsWith(trimmed, ret) || startsWith(trimmed, ret + " "))
+                            result = node.Remark;
+                        else
+                            result = ret + " " + node.Remark;
+                    }
                 }
                 catch (qjs::exception)
                 {
@@ -459,8 +480,24 @@ std::string addEmoji(const Proxy &node, const RegexMatchConfigs &emoji_array, ex
         }
         if(x.Replace.empty())
             continue;
+        if(applyMatcher(x.Match, real_rule, origNode) && real_rule.size() && regFind(original_remark, real_rule))
+        {
+            std::string trimmed = trim(node.Remark);
+            if(trimmed != removeEmoji(trimmed))
+                return node.Remark;
+            if(startsWith(trimmed, x.Replace) || startsWith(trimmed, x.Replace + " "))
+                return node.Remark;
+            return x.Replace + " " + node.Remark;
+        }
         if(applyMatcher(x.Match, real_rule, node) && real_rule.size() && regFind(node.Remark, real_rule))
+        {
+            std::string trimmed = trim(node.Remark);
+            if(trimmed != removeEmoji(trimmed))
+                return node.Remark;
+            if(startsWith(trimmed, x.Replace) || startsWith(trimmed, x.Replace + " "))
+                return node.Remark;
             return x.Replace + " " + node.Remark;
+        }
     }
     return node.Remark;
 }
@@ -469,13 +506,30 @@ void preprocessNodes(std::vector<Proxy> &nodes, extra_settings &ext)
 {
     std::for_each(nodes.begin(), nodes.end(), [&ext](Proxy &x)
     {
+        std::string original_remark = x.Remark;
         if(ext.remove_emoji)
             x.Remark = trim(removeEmoji(x.Remark));
 
         nodeRename(x, ext.rename_array, ext);
 
         if(ext.add_emoji)
-            x.Remark = addEmoji(x, ext.emoji_array, ext);
+        {
+            Proxy tmp = x;
+            tmp.Remark = x.Remark;
+            std::string added = addEmoji(tmp, ext.emoji_array, ext, original_remark);
+            if(added != tmp.Remark)
+            {
+                if(added.size() >= tmp.Remark.size() && added.compare(added.size() - tmp.Remark.size(), tmp.Remark.size(), tmp.Remark) == 0)
+                {
+                    std::string prefix = added.substr(0, added.size() - tmp.Remark.size());
+                    x.Remark = prefix + x.Remark;
+                }
+                else
+                {
+                    x.Remark = added;
+                }
+            }
+        }
     });
 
     if(ext.sort_flag)

src/generator/config/nodemanip.h

@@ -24,6 +24,7 @@ struct parse_settings
     std::string *sub_info = nullptr;
     bool authorized = false;
     string_icase_map *request_header = nullptr;
+    std::string *custom_user_agent = nullptr;
 #ifndef NO_JS_RUNTIME
     qjs::Runtime *js_runtime = nullptr;
     qjs::Context *js_context = nullptr;

src/generator/config/ruleconvert.cpp

@@ -10,7 +10,7 @@
 
 /// rule type lists
 #define basic_types "DOMAIN", "DOMAIN-SUFFIX", "DOMAIN-KEYWORD", "IP-CIDR", "SRC-IP-CIDR", "GEOIP", "MATCH", "FINAL"
-string_array ClashRuleTypes = {basic_types, "IP-CIDR6", "SRC-PORT", "DST-PORT", "PROCESS-NAME"};
+string_array ClashRuleTypes = {basic_types, "IP-CIDR6", "SRC-PORT", "DST-PORT", "PROCESS-NAME", "DOMAIN-REGEX", "DOMAIN-WILDCARD", "GEOSITE", "IP-SUFFIX", "IP-ASN", "SRC-GEOIP", "SRC-IP-ASN", "SRC-IP-SUFFIX", "IN-PORT", "IN-TYPE", "IN-USER", "IN-NAME", "PROCESS-PATH-REGEX", "PROCESS-PATH", "PROCESS-NAME-REGEX", "PROCESS-NAME-WILDCARD", "PROCESS-PATH-WILDCARD", "UID", "NETWORK", "DSCP", "SUB-RULE", "RULE-SET", "AND", "OR", "NOT"};
 string_array Surge2RuleTypes = {basic_types, "IP-CIDR6", "USER-AGENT", "URL-REGEX", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"};
 string_array SurgeRuleTypes = {basic_types, "IP-CIDR6", "USER-AGENT", "URL-REGEX", "AND", "OR", "NOT", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"};
 string_array QuanXRuleTypes = {basic_types, "USER-AGENT", "HOST", "HOST-SUFFIX", "HOST-KEYWORD"};
@@ -133,6 +133,7 @@ void rulesetToClash(YAML::Node &base_rule, std::vector<RulesetContent> &ruleset_
 
     if(!overwrite_original_rules && base_rule[field_name].IsDefined())
         rules = base_rule[field_name];
+//    const std::string rule_match_regex = "^(.*?,.*?)(,.*)(,.*)$";
 
     std::vector<std::string_view> temp(4);
     for(RulesetContent &x : ruleset_content_array)
@@ -152,6 +153,8 @@ void rulesetToClash(YAML::Node &base_rule, std::vector<RulesetContent> &ruleset_
             if(startsWith(strLine, "FINAL"))
                 strLine.replace(0, 5, "MATCH");
             strLine = transformRuleToCommon(temp, strLine, rule_group);
+//            if(!startsWith(strLine, "AND") && !startsWith(strLine, "OR") && !startsWith(strLine, "NOT") && count_least(strLine, ',', 3))
+//                strLine = regReplace(strLine, rule_match_regex, "$1$3$2");
             allRules.emplace_back(strLine);
             total_rules++;
             continue;
@@ -178,6 +181,8 @@ void rulesetToClash(YAML::Node &base_rule, std::vector<RulesetContent> &ruleset_
                 strLine = trimWhitespace(strLine);
             }
             strLine = transformRuleToCommon(temp, strLine, rule_group);
+//            if(!startsWith(strLine, "AND") && !startsWith(strLine, "OR") && !startsWith(strLine, "NOT") && count_least(strLine, ',', 3))
+//                strLine = regReplace(strLine, rule_match_regex, "$1$3$2");
             allRules.emplace_back(strLine);
         }
     }
@@ -205,6 +210,8 @@ std::string rulesetToClashStr(YAML::Node &base_rule, std::vector<RulesetContent>
     }
     base_rule.remove(field_name);
 
+//    const std::string rule_match_regex = "^(.*?,.*?)(,.*)(,.*)$";
+
     string_view_array temp(4);
     for(RulesetContent &x : ruleset_content_array)
     {
@@ -223,6 +230,8 @@ std::string rulesetToClashStr(YAML::Node &base_rule, std::vector<RulesetContent>
             if(startsWith(strLine, "FINAL"))
                 strLine.replace(0, 5, "MATCH");
             strLine = transformRuleToCommon(temp, strLine, rule_group);
+//            if(!startsWith(strLine, "AND") && !startsWith(strLine, "OR") && !startsWith(strLine, "NOT") && count_least(strLine, ',', 3))
+//                strLine = regReplace(strLine, rule_match_regex, "$1$3$2");
             output_content += "  - " + strLine + "\n";
             total_rules++;
             continue;
@@ -248,8 +257,27 @@ std::string rulesetToClashStr(YAML::Node &base_rule, std::vector<RulesetContent>
                 strLine.erase(strLine.find("//"));
                 strLine = trimWhitespace(strLine);
             }
-            strLine = transformRuleToCommon(temp, strLine, rule_group);
-            output_content += "  - " + strLine + "\n";
+
+            //AND & OR & NOT
+            if(startsWith(strLine, "AND") || startsWith(strLine, "OR") || startsWith(strLine, "NOT"))
+            {
+                output_content += "  - " + strLine + "," + rule_group + "\n";
+            }
+            //SUB-RULE & RULE-SET
+            else if(startsWith(strLine, "SUB-RULE") || startsWith(strLine, "RULE-SET"))
+            {
+                output_content += "  - " + strLine + "\n";
+            }
+            else
+            //OTHER
+            {
+                strLine = transformRuleToCommon(temp, strLine, rule_group);
+                output_content += "  - " + strLine + "\n";
+            }
+//            strLine = transformRuleToCommon(temp, strLine, rule_group);
+//            if(!startsWith(strLine, "AND") && !startsWith(strLine, "OR") && !startsWith(strLine, "NOT") && count_least(strLine, ',', 3))
+//                strLine = regReplace(strLine, rule_match_regex, "$1$3$2");
+//            output_content += "  - " + strLine + "\n";
             total_rules++;
         }
     }