@remnawave/backend-contract 2.1.75 → 2.1.77

package/build/backend/models/response-rules/response-rule.schema.js

@@ -3,27 +3,109 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
-exports.ResponseRuleSchema = zod_1.z.object({
-    name: zod_1.z.string().min(1, 'Name is required').max(50, 'Name must be less than 50 characters'),
+const response_rule_condition_schema_1 = require("./response-rule-condition.schema");
+const RuleExampleJson = JSON.stringify({
+    name: 'Block Legacy Clients',
+    description: 'Block requests from legacy clients',
+    enabled: true,
+    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
+    conditions: [
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'Hiddify',
+            caseSensitive: true,
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+            caseSensitive: true,
+        },
+    ],
+    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+}, null, 2);
+exports.ResponseRuleSchema = zod_1.z
+    .object({
+    name: zod_1.z
+        .string()
+        .min(1, 'Name is required')
+        .max(50, 'Name must be less than 50 characters')
+        .describe(JSON.stringify({
+        title: 'Name',
+        markdownDescription: 'Name of the response rule.',
+    })),
     description: zod_1.z
         .string()
         .min(1, 'Description is required')
         .max(250, 'Description must be less than 250 characters')
-        .optional(),
-    operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_OPERATORS).describe('Operator to use for the rule.'),
-    conditions: zod_1.z.array(zod_1.z.object({
-        headerName: zod_1.z
-            .string()
-            .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
-            .describe('Name of the HTTP header to check, case insensitive, must comply with RFC 7230.'),
-        operator: zod_1.z
-            .nativeEnum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS)
-            .describe('Operator to use for the condition.'),
-        value: zod_1.z
-            .string()
-            .min(1, 'Value is required')
-            .max(255, 'Value must be less than 255 characters')
-            .describe('Value to check against the header, case sensitive.'),
+        .optional()
+        .describe(JSON.stringify({
+        title: 'Description',
+        markdownDescription: 'Description of the response rule. Maximum length is 250 characters.',
+    })),
+    enabled: zod_1.z.boolean().describe(JSON.stringify({
+        markdownDescription: 'Whether the response rule is enabled. If disabled, the rule will not be applied.',
+    })),
+    operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_OPERATORS).describe(JSON.stringify({
+        title: 'Operator',
+        markdownDescription: 'Operator to use for combining conditions in the rule.',
+    })),
+    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema),
+    responseType: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe(JSON.stringify({
+        markdownDescription: `Type of the response. Determines the type of **response** to be returned when the rule is matched.\n\n${Object.entries(constants_1.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION)
+            .map(([key, description]) => `- **${key}**: ${description}\n`)
+            .join('\n')}`,
     })),
-    responseType: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe('Type of the response.'),
-});
+    responseModifications: zod_1.z.object({
+        headers: zod_1.z
+            .array(zod_1.z.object({
+            key: zod_1.z
+                .string()
+                .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
+                .describe(JSON.stringify({
+                title: 'Key',
+                markdownDescription: 'Key of the response header. Must comply with RFC 7230.',
+            })),
+            value: zod_1.z
+                .string()
+                .min(1, 'Value is required')
+                .describe(JSON.stringify({
+                title: 'Value',
+                markdownDescription: 'Value of the response header. ',
+            })),
+        }))
+            .optional()
+            .describe(JSON.stringify({
+            markdownDescription: 'Response headers to be added when the rule is matched.',
+        })),
+    }),
+})
+    .describe(JSON.stringify({
+    title: 'Response Rule',
+    markdownDescription: `\n\nFields:\n- **name**: Name of the response rule (required)\n- **description**: Description of the response rule (optional)\n- **enabled**: Whether the response rule is enabled. If disabled, the rule will not be applied.\n- **operator**: Operator to combine conditions (AND/OR)\n- **conditions**: Array of conditions to match against HTTP headers\n  - **headerName**: Name of the HTTP header to check (case insensitive)\n  - **operator**: Comparison operator (CONTAINS, EQUALS, etc)\n  - **value**: Value to compare against (case sensitive, max 255 chars)\n- **responseType**: Type of response when rule matches (e.g. BLOCK)\n\nExample:\n\`\`\`json\n${RuleExampleJson}\n\`\`\``,
+    examples: [
+        {
+            name: 'This is example rule name',
+            description: 'This is example rule description (optional)',
+            enabled: true,
+            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
+            conditions: [
+                {
+                    headerName: 'user-agent',
+                    operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                    value: 'Example Rule Value, replace with your own value',
+                    caseSensitive: true,
+                },
+            ],
+            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+        },
+        {
+            name: 'Empty rule',
+            enabled: true,
+            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
+            conditions: [],
+            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+        },
+    ],
+}));

package/build/backend/models/response-rules/response-rules-config.schema.d.ts

@@ -6,6 +6,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
     rules: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
         operator: z.ZodNativeEnum<{
             readonly AND: "AND";
             readonly OR: "OR";
@@ -25,48 +26,88 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 readonly NOT_REGEX: "NOT_REGEX";
             }>;
             value: z.ZodString;
+            caseSensitive: z.ZodBoolean;
         }, "strip", z.ZodTypeAny, {
             value: string;
-            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
+            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+            caseSensitive: boolean;
         }, {
             value: string;
-            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
+            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+            caseSensitive: boolean;
         }>, "many">;
         responseType: z.ZodNativeEnum<{
+            readonly BROWSER: "BROWSER";
             readonly BLOCK: "BLOCK";
-            readonly BASE64: "BASE64";
             readonly STATUS_CODE_404: "STATUS_CODE_404";
-            readonly STATUS_CODE_403: "STATUS_CODE_403";
             readonly STATUS_CODE_451: "STATUS_CODE_451";
             readonly SOCKET_DROP: "SOCKET_DROP";
-            readonly STASH: "STASH";
-            readonly SINGBOX: "SINGBOX";
-            readonly SINGBOX_LEGACY: "SINGBOX_LEGACY";
-            readonly MIHOMO: "MIHOMO";
             readonly XRAY_JSON: "XRAY_JSON";
+            readonly XRAY_BASE64: "XRAY_BASE64";
+            readonly MIHOMO: "MIHOMO";
+            readonly STASH: "STASH";
             readonly CLASH: "CLASH";
+            readonly SINGBOX: "SINGBOX";
+        }>;
+        responseModifications: z.ZodObject<{
+            headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                key: string;
+            }, {
+                value: string;
+                key: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            headers?: {
+                value: string;
+                key: string;
+            }[] | undefined;
+        }, {
+            headers?: {
+                value: string;
+                key: string;
+            }[] | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         operator: "AND" | "OR";
+        enabled: boolean;
         conditions: {
             value: string;
-            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
+            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+            caseSensitive: boolean;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseModifications: {
+            headers?: {
+                value: string;
+                key: string;
+            }[] | undefined;
+        };
         description?: string | undefined;
     }, {
         name: string;
         operator: "AND" | "OR";
+        enabled: boolean;
         conditions: {
             value: string;
-            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
+            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+            caseSensitive: boolean;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseModifications: {
+            headers?: {
+                value: string;
+                key: string;
+            }[] | undefined;
+        };
         description?: string | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
@@ -74,12 +115,20 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
     rules: {
         name: string;
         operator: "AND" | "OR";
+        enabled: boolean;
         conditions: {
             value: string;
-            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
+            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+            caseSensitive: boolean;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseModifications: {
+            headers?: {
+                value: string;
+                key: string;
+            }[] | undefined;
+        };
         description?: string | undefined;
     }[];
 }, {
@@ -87,12 +136,20 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
     rules: {
         name: string;
         operator: "AND" | "OR";
+        enabled: boolean;
         conditions: {
             value: string;
-            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
+            operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+            caseSensitive: boolean;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseModifications: {
+            headers?: {
+                value: string;
+                key: string;
+            }[] | undefined;
+        };
         description?: string | undefined;
     }[];
 }>;

package/build/backend/models/response-rules/response-rules-config.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASpC,CAAC"}
+{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCpC,CAAC"}

package/build/backend/models/response-rules/response-rules-config.schema.js

@@ -4,11 +4,52 @@ exports.ResponseRulesConfigSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
 const response_rule_schema_1 = require("./response-rule.schema");
+const RuleExampleJson = JSON.stringify({
+    name: 'Block Legacy Clients',
+    description: 'Block requests from legacy clients',
+    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
+    enabled: true,
+    conditions: [
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'Hiddify',
+            caseSensitive: true,
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+            caseSensitive: true,
+        },
+    ],
+    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+}, null, 2);
 exports.ResponseRulesConfigSchema = zod_1.z.object({
     version: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_CONFIG_VERSION).describe(JSON.stringify({
         title: 'Response Rules Config Version',
-        description: 'Version of the response rules config.',
-        examples: [constants_1.RESPONSE_RULES_CONFIG_VERSION[1]],
+        markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
+    })),
+    rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).describe(JSON.stringify({
+        examples: [
+            [
+                {
+                    name: 'This is example rule name',
+                    description: 'This is example rule description (optional)',
+                    operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
+                    enabled: true,
+                    conditions: [
+                        {
+                            headerName: 'user-agent',
+                            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                            value: 'Example Rule Value, replace with your own value',
+                            caseSensitive: true,
+                        },
+                    ],
+                    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+                },
+            ],
+        ],
+        markdownDescription: `Array of **response rules**.\n\nRules served from top to bottom – first matched rule is applied. Each rule is an object with the following properties:\n\n- **name**: Name of the response rule.\n- **description**: Description of the response rule.(Optional) \n- **enabled**: Whether the response rule is enabled. If disabled, the rule will not be applied.\n- **operator**: Operator to use for the rule.\n- **conditions**: Array of conditions to use for the rule.\n- **responseType**: Type of the response.\n\nExamples:\n\n1. Block legacy clients:\n\n\`\`\`json\n${RuleExampleJson}\n\`\`\`\n\nThis example shows how to block requests from legacy clients by checking if the User-Agent header contains "Hiddify" or "FoxRay".`,
     })),
-    rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema),
 });

package/build/backend/models/subscription-settings.schema.d.ts

@@ -15,6 +15,160 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
     disabledUsersRemarks: z.ZodArray<z.ZodString, "many">;
     customResponseHeaders: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
     randomizeHosts: z.ZodBoolean;
+    responseRules: z.ZodNullable<z.ZodObject<{
+        version: z.ZodNativeEnum<{
+            readonly 1: "1";
+        }>;
+        rules: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodBoolean;
+            operator: z.ZodNativeEnum<{
+                readonly AND: "AND";
+                readonly OR: "OR";
+            }>;
+            conditions: z.ZodArray<z.ZodObject<{
+                headerName: z.ZodString;
+                operator: z.ZodNativeEnum<{
+                    readonly EQUALS: "EQUALS";
+                    readonly NOT_EQUALS: "NOT_EQUALS";
+                    readonly CONTAINS: "CONTAINS";
+                    readonly NOT_CONTAINS: "NOT_CONTAINS";
+                    readonly STARTS_WITH: "STARTS_WITH";
+                    readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
+                    readonly ENDS_WITH: "ENDS_WITH";
+                    readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
+                    readonly REGEX: "REGEX";
+                    readonly NOT_REGEX: "NOT_REGEX";
+                }>;
+                value: z.ZodString;
+                caseSensitive: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }, {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }>, "many">;
+            responseType: z.ZodNativeEnum<{
+                readonly BROWSER: "BROWSER";
+                readonly BLOCK: "BLOCK";
+                readonly STATUS_CODE_404: "STATUS_CODE_404";
+                readonly STATUS_CODE_451: "STATUS_CODE_451";
+                readonly SOCKET_DROP: "SOCKET_DROP";
+                readonly XRAY_JSON: "XRAY_JSON";
+                readonly XRAY_BASE64: "XRAY_BASE64";
+                readonly MIHOMO: "MIHOMO";
+                readonly STASH: "STASH";
+                readonly CLASH: "CLASH";
+                readonly SINGBOX: "SINGBOX";
+            }>;
+            responseModifications: z.ZodObject<{
+                headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    value: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    value: string;
+                    key: string;
+                }, {
+                    value: string;
+                    key: string;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            }, {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            operator: "AND" | "OR";
+            enabled: boolean;
+            conditions: {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }[];
+            responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+            responseModifications: {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            };
+            description?: string | undefined;
+        }, {
+            name: string;
+            operator: "AND" | "OR";
+            enabled: boolean;
+            conditions: {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }[];
+            responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+            responseModifications: {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            };
+            description?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        version: "1";
+        rules: {
+            name: string;
+            operator: "AND" | "OR";
+            enabled: boolean;
+            conditions: {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }[];
+            responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+            responseModifications: {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            };
+            description?: string | undefined;
+        }[];
+    }, {
+        version: "1";
+        rules: {
+            name: string;
+            operator: "AND" | "OR";
+            enabled: boolean;
+            conditions: {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }[];
+            responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+            responseModifications: {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            };
+            description?: string | undefined;
+        }[];
+    }>>;
     createdAt: z.ZodEffects<z.ZodString, Date, string>;
     updatedAt: z.ZodEffects<z.ZodString, Date, string>;
 }, "strip", z.ZodTypeAny, {
@@ -35,6 +189,28 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
     disabledUsersRemarks: string[];
     customResponseHeaders: Record<string, string> | null;
     randomizeHosts: boolean;
+    responseRules: {
+        version: "1";
+        rules: {
+            name: string;
+            operator: "AND" | "OR";
+            enabled: boolean;
+            conditions: {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }[];
+            responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+            responseModifications: {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            };
+            description?: string | undefined;
+        }[];
+    } | null;
 }, {
     uuid: string;
     createdAt: string;
@@ -53,5 +229,27 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
     disabledUsersRemarks: string[];
     customResponseHeaders: Record<string, string> | null;
     randomizeHosts: boolean;
+    responseRules: {
+        version: "1";
+        rules: {
+            name: string;
+            operator: "AND" | "OR";
+            enabled: boolean;
+            conditions: {
+                value: string;
+                headerName: string;
+                operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+                caseSensitive: boolean;
+            }[];
+            responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+            responseModifications: {
+                headers?: {
+                    value: string;
+                    key: string;
+                }[] | undefined;
+            };
+            description?: string | undefined;
+        }[];
+    } | null;
 }>;
 //# sourceMappingURL=subscription-settings.schema.d.ts.map

package/build/backend/models/subscription-settings.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCrC,CAAC"}
+{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCrC,CAAC"}

package/build/backend/models/subscription-settings.schema.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubscriptionSettingsSchema = void 0;
 const zod_1 = require("zod");
+const response_rules_1 = require("./response-rules");
 exports.SubscriptionSettingsSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     profileTitle: zod_1.z.string(),
@@ -21,6 +22,7 @@ exports.SubscriptionSettingsSchema = zod_1.z.object({
     disabledUsersRemarks: zod_1.z.array(zod_1.z.string()),
     customResponseHeaders: zod_1.z.nullable(zod_1.z.record(zod_1.z.string(), zod_1.z.string())),
     randomizeHosts: zod_1.z.boolean(),
+    responseRules: zod_1.z.nullable(response_rules_1.ResponseRulesConfigSchema),
     createdAt: zod_1.z
         .string()
         .datetime()

package/build/frontend/commands/subscription-settings/update-subscription-settings.command.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateSubscriptionSettingsCommand = void 0;
 const zod_1 = require("zod");
-const api_1 = require("../../api");
 const models_1 = require("../../models");
+const api_1 = require("../../api");
 const constants_1 = require("../../constants");
 var UpdateSubscriptionSettingsCommand;
 (function (UpdateSubscriptionSettingsCommand) {
@@ -31,6 +31,7 @@ var UpdateSubscriptionSettingsCommand;
             .string()
             .regex(/^[a-zA-Z0-9_-]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.'), zod_1.z.string())),
         randomizeHosts: zod_1.z.optional(zod_1.z.boolean()),
+        responseRules: zod_1.z.optional(models_1.ResponseRulesConfigSchema),
     });
     UpdateSubscriptionSettingsCommand.ResponseSchema = zod_1.z.object({
         response: models_1.SubscriptionSettingsSchema,

package/build/frontend/constants/response-rules/response-rules.contants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
+exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
 const subscription_template_1 = require("../subscription-template");
 exports.RESPONSE_RULES_CONFIG_VERSION = {
     1: '1',
@@ -24,4 +24,31 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     REGEX: 'REGEX',
     NOT_REGEX: 'NOT_REGEX',
 };
-exports.RESPONSE_RULES_RESPONSE_TYPES = Object.assign(Object.assign({}, subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE), { BLOCK: 'BLOCK', BASE64: 'BASE64', STATUS_CODE_404: 'STATUS_CODE_404', STATUS_CODE_403: 'STATUS_CODE_403', STATUS_CODE_451: 'STATUS_CODE_451', SOCKET_DROP: 'SOCKET_DROP' });
+exports.RESPONSE_RULES_RESPONSE_TYPES = Object.assign(Object.assign({}, subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE), { BROWSER: 'BROWSER', BLOCK: 'BLOCK', STATUS_CODE_404: 'STATUS_CODE_404', STATUS_CODE_451: 'STATUS_CODE_451', SOCKET_DROP: 'SOCKET_DROP' });
+exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = Object.values(exports.RESPONSE_RULES_RESPONSE_TYPES);
+exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = Object.values(exports.RESPONSE_RULES_CONDITION_OPERATORS);
+exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = {
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.BLOCK]: 'Block response type blocks the request and returns a 403 status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_BASE64]: 'Previously used as fallback response type. It return subscription as base64 encoded string. Compatible with most client application with Xray core.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_404]: 'Status code 404 response type returns a 404 status code. This response type is used to return a 404 status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_451]: 'Status code 451 response type returns a 451 status code. This response type is used to return a 451 status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.SOCKET_DROP]: 'Socket drop response type drops the socket connection. This response type is used to drop the socket connection.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.CLASH]: 'Useful for client application that use Legacy Clash core. It return subscription as Clash YAML format.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STASH]: 'Format which is used by Stash client application.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.SINGBOX]: 'Format which is used by Singbox client application.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.MIHOMO]: 'Return subscription as Mihomo Core YAML format.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_JSON]: 'Return subscription as Xray JSON format.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.BROWSER]: 'Return subscription as browser format.',
+};
+exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = {
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.EQUALS]: 'Equals operator checks if the header value exactly matches the specified string, case sensitive. Underlying implementation uses strict string comparison – ===.',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EQUALS]: 'Not equals operator checks if the header value does not match the specified string, case sensitive. Underlying implementation uses strict string comparison – !==.',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS]: 'Contains operator checks if the header value contains the specified string, case sensitive. Underlying implementation uses string.includes().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_CONTAINS]: 'Not contains operator checks if the header value does not contain the specified string, case sensitive. Underlying implementation uses string.includes().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.STARTS_WITH]: 'Starts with operator checks if the header value starts with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_STARTS_WITH]: 'Not starts with operator checks if the header value does not start with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.ENDS_WITH]: 'Ends with operator checks if the header value ends with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_ENDS_WITH]: 'Not ends with operator checks if the header value does not end with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.REGEX]: 'Regex operator checks if the header value matches the specified regex. Underlying implementation uses regex.test().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_REGEX]: 'Inverse regex operator checks if the header value does not match the specified regex. Underlying implementation uses regex.test().',
+};