Add proxy rules list export/import format

[salarcode]

Description

Create a universal rules format that anyone can implement without hassle of writing a parser from scratch.

• As minimal as possible, one line per rule
• Parser libraries available for languages
• No tight coupling with specific implementation

[salarcode]

Options:

• KDL seems like a vary good candidate: https://kdl.dev/
• logfmt https://brandur.org/logfmt

rule=MatchPatternHost pattern="*.google.com" proxy=127.0.0.1:8888
rule=Exact pattern="my-site.com" whiteList=true

• Nginx Configuration Format https://nginx.org/en/docs/beginners_guide.html

rule *.google.com type=MatchPatternHost proxy=127.0.0.1:8888;
rule my-site.com type=Exact whiteList=true;

[salarcode]

KDL

Suggested format:

// [SmartProxy Rules KDL]
// SmartProxy 1.9

// Use the first argument for the pattern, properties for the rest
rule "*.google.com" type="MatchPatternHost" proxy="127.0.0.1:8888"
rule "my-site.com"  type="Exact" whiteList=true enabled=false

[salarcode]

KDL Parser, using kdljs library https://github.com/kdl-org/kdljs

Generator:

import { parse, Document } from "kdljs";

export class ProxyRule {
    constructor(
        public ruleType: ProxyRuleType,
        public pattern: string,
        public proxy: string = "",
        public whiteList: boolean = false
    ) {}

    // Static factory to load the whole file
    static fromKdl(kdlContent: string): ProxyRule[] {
        // 1. Validate Header
        if (!kdlContent.includes("// [SmartProxy Rules KDL]")) {
            throw new Error("Invalid SmartProxy header");
        }

        const { output, errors } = parse(kdlContent);
        if (errors.length > 0) throw new Error("KDL Parse Error");

        return output
            .filter(node => node.name === "rule")
            .map(node => {
                const attrs = node.properties;
                return new ProxyRule(
                    attrs.type as ProxyRuleType, // mapped from rule="MatchPatternHost"
                    attrs.pattern as string,
                    attrs.proxy as string || "",
                    Boolean(attrs.whiteList)
                );
            });
    }
}

Parser:

import { parse, Node } from "kdljs";

export enum ProxyRuleType {
    MatchPatternHost = "MatchPatternHost",
    MatchPatternUrl = "MatchPatternUrl",
    RegexHost = "RegexHost",
    RegexUrl = "RegexUrl",
    Exact = "Exact",
    DomainSubdomain = "DomainSubdomain",
    DomainExact = "DomainExact",
    DomainAndPath = "DomainAndPath",
    DomainSubdomainAndPath = "DomainSubdomainAndPath",
    SearchUrl = "SearchUrl"
}

export class ProxyRule {
    public ruleType: ProxyRuleType = ProxyRuleType.MatchPatternHost;
    public rule: string = "";
    public proxy: string = ""; // Expected format: "127.0.0.1:8888"
    public whiteList: boolean = false;
}

export class SmartProxyParser {
    private readonly HEADER = "// [SmartProxy Rules KDL]\n// SmartProxy 1.9";

    /**
     * Parses KDL into ProxyRule objects with ProxyServer validation
     */
    public parse(input: string): ProxyRule[] {
        if (!input.includes("[SmartProxy Rules KDL]")) {
            throw new Error("Missing SmartProxy identification header.");
        }

        const { output, errors } = parse(input);
        if (errors.length > 0) throw new Error(`KDL Error: ${errors[0].message}`);

        return output
            .filter(node => node.name === "rule")
            .map(node => {
                const r = new ProxyRule();
                const p = node.properties;

                // Map Enum safely
                r.ruleType = ProxyRuleType[p.rule as keyof typeof ProxyRuleType] || ProxyRuleType.MatchPatternHost;
                r.rule = String(p.pattern || "");
                r.whiteList = p.whiteList === true;
                
                // Handle Proxy Server:Port string
                const rawProxy = String(p.proxy || "");
                r.proxy = this.validateProxyFormat(rawProxy);

                return r;
            });
    }

    /**
     * Ensures the string is either empty or a valid server:port
     */
    private validateProxyFormat(proxyStr: string): string {
        if (proxyStr === "") return proxyStr;
        
        // Basic Regex for host:port (handles IPv4 and domains)
        const pattern = /^([a-zA-Z0-9.-]+|\[[a-fA-F0-9:]+\]):([0-9]{1,5})$/;
        if (!pattern.test(proxyStr)) {
            console.warn(`Invalid proxy format detected: ${proxyStr}. Defaulting to empty.`);
            return "";
        }
        return proxyStr;
    }

    /**
     * Serialises back to the KDL format
     */
    public stringify(rules: ProxyRule[]): string {
        const body = rules.map(r => 
            `rule rule="${r.ruleType}" pattern="${r.rule}" proxy="${r.proxy}" whiteList=${r.whiteList}`
        ).join("\n");

        return `${this.HEADER}\n\n${body}`;
    }
}

Refined Parser/Stringify

import { parse, Node } from "kdljs";

export class SmartProxyParser {
    private readonly HEADER = "// [SmartProxy Rules KDL]\n// SmartProxy 1.9\n\n// Use the first argument for the pattern, properties for the rest";

    /**
     * Serialises ProxyRule array to your specific KDL style
     */
    public stringify(rules: ProxyRule[]): string {
        const body = rules.map(r => {
            // First argument is the pattern (quoted)
            const patternArg = `"${r.rule}"`;
            
            // Properties follow
            const props = [
                `type="${r.ruleType}"`,
                r.whiteList ? `whiteList=true` : `proxy="${r.proxy}"`
            ];

            return `rule ${patternArg} ${props.join(" ")}`;
        }).join("\n");

        return `${this.HEADER}\n\n${body}`;
    }

    /**
     * Parser that handles positional arguments (the pattern) and properties
     */
    public parse(input: string): ProxyRule[] {
        if (!input.includes("[SmartProxy Rules KDL]")) {
            throw new Error("Invalid header.");
        }

        const { output, errors } = parse(input);
        if (errors.length > 0) throw new Error("KDL Parse Failed");

        return output
            .filter(node => node.name === "rule")
            .map(node => {
                const r = new ProxyRule();
                
                // KDL Positional Argument (the string right after 'rule')
                r.rule = String(node.values[0] || "");
                
                // KDL Properties
                const p = node.properties;
                r.ruleType = ProxyRuleType[p.type as keyof typeof ProxyRuleType] || ProxyRuleType.MatchPatternHost;
                r.whiteList = p.whiteList === true;
                r.proxy = r.whiteList ? "" : String(p.proxy || "");

                return r;
            });
    }
}

FYI Generated via Gemini, not reviewed