@remnawave/node-contract 2.6.9 → 2.6.11

package/build/api/controllers/stats.d.ts

@@ -9,5 +9,6 @@ export declare const STATS_ROUTES: {
     readonly GET_ALL_INBOUNDS_STATS: "get-all-inbounds-stats";
     readonly GET_COMBINED_STATS: "get-combined-stats";
     readonly GET_USER_IP_LIST: "get-user-ip-list";
+    readonly GET_USERS_IP_LIST: "get-users-ip-list";
 };
 //# sourceMappingURL=stats.d.ts.map

package/build/api/controllers/stats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../api/controllers/stats.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAG,OAAgB,CAAC;AAEjD,eAAO,MAAM,YAAY;;;;;;;;;;CAcf,CAAC"}
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../api/controllers/stats.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAG,OAAgB,CAAC;AAEjD,eAAO,MAAM,YAAY;;;;;;;;;;;CAef,CAAC"}

package/build/api/controllers/stats.js

@@ -12,4 +12,5 @@ exports.STATS_ROUTES = {
     GET_ALL_INBOUNDS_STATS: 'get-all-inbounds-stats',
     GET_COMBINED_STATS: 'get-combined-stats',
     GET_USER_IP_LIST: 'get-user-ip-list',
+    GET_USERS_IP_LIST: 'get-users-ip-list',
 };

package/build/api/routes.d.ts

@@ -3,7 +3,6 @@ export declare const REST_API: {
     readonly XRAY: {
         readonly START: "/node/xray/start";
         readonly STOP: "/node/xray/stop";
-        readonly STATUS: "/node/xray/status";
         readonly NODE_HEALTH_CHECK: "/node/xray/healthcheck";
     };
     readonly STATS: {
@@ -16,6 +15,7 @@ export declare const REST_API: {
         readonly GET_ALL_INBOUNDS_STATS: "/node/stats/get-all-inbounds-stats";
         readonly GET_COMBINED_STATS: "/node/stats/get-combined-stats";
         readonly GET_USER_IP_LIST: "/node/stats/get-user-ip-list";
+        readonly GET_USERS_IP_LIST: "/node/stats/get-users-ip-list";
     };
     readonly HANDLER: {
         readonly ADD_USER: "/node/handler/add-user";

package/build/api/routes.js

@@ -40,7 +40,6 @@ exports.REST_API = {
     XRAY: {
         START: `${exports.ROOT}/${CONTROLLERS.XRAY_CONTROLLER}/${CONTROLLERS.XRAY_ROUTES.START}`,
         STOP: `${exports.ROOT}/${CONTROLLERS.XRAY_CONTROLLER}/${CONTROLLERS.XRAY_ROUTES.STOP}`,
-        STATUS: `${exports.ROOT}/${CONTROLLERS.XRAY_CONTROLLER}/${CONTROLLERS.XRAY_ROUTES.STATUS}`,
         NODE_HEALTH_CHECK: `${exports.ROOT}/${CONTROLLERS.XRAY_CONTROLLER}/${CONTROLLERS.XRAY_ROUTES.NODE_HEALTH_CHECK}`,
     },
     STATS: {
@@ -53,6 +52,7 @@ exports.REST_API = {
         GET_ALL_INBOUNDS_STATS: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_ALL_INBOUNDS_STATS}`,
         GET_COMBINED_STATS: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_COMBINED_STATS}`,
         GET_USER_IP_LIST: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_USER_IP_LIST}`,
+        GET_USERS_IP_LIST: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_USERS_IP_LIST}`,
     },
     HANDLER: {
         ADD_USER: `${exports.ROOT}/${CONTROLLERS.HANDLER_CONTROLLER}/${CONTROLLERS.HANDLER_ROUTES.ADD_USER}`,

package/build/commands/stats/get-system-stats.command.d.ts

@@ -3,69 +3,159 @@ export declare namespace GetSystemStatsCommand {
     const url: "/node/stats/get-system-stats";
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
-            numGoroutine: z.ZodNumber;
-            numGC: z.ZodNumber;
-            alloc: z.ZodNumber;
-            totalAlloc: z.ZodNumber;
-            sys: z.ZodNumber;
-            mallocs: z.ZodNumber;
-            frees: z.ZodNumber;
-            liveObjects: z.ZodNumber;
-            pauseTotalNs: z.ZodNumber;
-            uptime: z.ZodNumber;
-            reportsCount: z.ZodOptional<z.ZodNumber>;
+            xrayInfo: z.ZodNullable<z.ZodObject<{
+                numGoroutine: z.ZodNumber;
+                numGC: z.ZodNumber;
+                alloc: z.ZodNumber;
+                totalAlloc: z.ZodNumber;
+                sys: z.ZodNumber;
+                mallocs: z.ZodNumber;
+                frees: z.ZodNumber;
+                liveObjects: z.ZodNumber;
+                pauseTotalNs: z.ZodNumber;
+                uptime: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                uptime: number;
+                numGoroutine: number;
+                numGC: number;
+                alloc: number;
+                totalAlloc: number;
+                sys: number;
+                mallocs: number;
+                frees: number;
+                liveObjects: number;
+                pauseTotalNs: number;
+            }, {
+                uptime: number;
+                numGoroutine: number;
+                numGC: number;
+                alloc: number;
+                totalAlloc: number;
+                sys: number;
+                mallocs: number;
+                frees: number;
+                liveObjects: number;
+                pauseTotalNs: number;
+            }>>;
+            plugins: z.ZodObject<{
+                torrentBlocker: z.ZodObject<{
+                    reportsCount: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    reportsCount: number;
+                }, {
+                    reportsCount: number;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                torrentBlocker: {
+                    reportsCount: number;
+                };
+            }, {
+                torrentBlocker: {
+                    reportsCount: number;
+                };
+            }>;
+            hotHostInfo: z.ZodObject<{
+                memoryFree: z.ZodNumber;
+                uptime: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                memoryFree: number;
+                uptime: number;
+            }, {
+                memoryFree: number;
+                uptime: number;
+            }>;
         }, "strip", z.ZodTypeAny, {
-            numGoroutine: number;
-            numGC: number;
-            alloc: number;
-            totalAlloc: number;
-            sys: number;
-            mallocs: number;
-            frees: number;
-            liveObjects: number;
-            pauseTotalNs: number;
-            uptime: number;
-            reportsCount?: number | undefined;
+            xrayInfo: {
+                uptime: number;
+                numGoroutine: number;
+                numGC: number;
+                alloc: number;
+                totalAlloc: number;
+                sys: number;
+                mallocs: number;
+                frees: number;
+                liveObjects: number;
+                pauseTotalNs: number;
+            } | null;
+            plugins: {
+                torrentBlocker: {
+                    reportsCount: number;
+                };
+            };
+            hotHostInfo: {
+                memoryFree: number;
+                uptime: number;
+            };
         }, {
-            numGoroutine: number;
-            numGC: number;
-            alloc: number;
-            totalAlloc: number;
-            sys: number;
-            mallocs: number;
-            frees: number;
-            liveObjects: number;
-            pauseTotalNs: number;
-            uptime: number;
-            reportsCount?: number | undefined;
+            xrayInfo: {
+                uptime: number;
+                numGoroutine: number;
+                numGC: number;
+                alloc: number;
+                totalAlloc: number;
+                sys: number;
+                mallocs: number;
+                frees: number;
+                liveObjects: number;
+                pauseTotalNs: number;
+            } | null;
+            plugins: {
+                torrentBlocker: {
+                    reportsCount: number;
+                };
+            };
+            hotHostInfo: {
+                memoryFree: number;
+                uptime: number;
+            };
         }>;
     }, "strip", z.ZodTypeAny, {
         response: {
-            numGoroutine: number;
-            numGC: number;
-            alloc: number;
-            totalAlloc: number;
-            sys: number;
-            mallocs: number;
-            frees: number;
-            liveObjects: number;
-            pauseTotalNs: number;
-            uptime: number;
-            reportsCount?: number | undefined;
+            xrayInfo: {
+                uptime: number;
+                numGoroutine: number;
+                numGC: number;
+                alloc: number;
+                totalAlloc: number;
+                sys: number;
+                mallocs: number;
+                frees: number;
+                liveObjects: number;
+                pauseTotalNs: number;
+            } | null;
+            plugins: {
+                torrentBlocker: {
+                    reportsCount: number;
+                };
+            };
+            hotHostInfo: {
+                memoryFree: number;
+                uptime: number;
+            };
         };
     }, {
         response: {
-            numGoroutine: number;
-            numGC: number;
-            alloc: number;
-            totalAlloc: number;
-            sys: number;
-            mallocs: number;
-            frees: number;
-            liveObjects: number;
-            pauseTotalNs: number;
-            uptime: number;
-            reportsCount?: number | undefined;
+            xrayInfo: {
+                uptime: number;
+                numGoroutine: number;
+                numGC: number;
+                alloc: number;
+                totalAlloc: number;
+                sys: number;
+                mallocs: number;
+                frees: number;
+                liveObjects: number;
+                pauseTotalNs: number;
+            } | null;
+            plugins: {
+                torrentBlocker: {
+                    reportsCount: number;
+                };
+            };
+            hotHostInfo: {
+                memoryFree: number;
+                uptime: number;
+            };
         };
     }>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/stats/get-system-stats.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-system-stats.command.d.ts","sourceRoot":"","sources":["../../../commands/stats/get-system-stats.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,gCAAkC,CAAC;IAE5C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAczB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"get-system-stats.command.d.ts","sourceRoot":"","sources":["../../../commands/stats/get-system-stats.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,gCAAkC,CAAC;IAE5C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuBzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/stats/get-system-stats.command.js

@@ -2,23 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetSystemStatsCommand = void 0;
 const zod_1 = require("zod");
+const models_1 = require("../../models");
 const api_1 = require("../../api");
 var GetSystemStatsCommand;
 (function (GetSystemStatsCommand) {
     GetSystemStatsCommand.url = api_1.REST_API.STATS.GET_SYSTEM_STATS;
     GetSystemStatsCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
-            numGoroutine: zod_1.z.number(),
-            numGC: zod_1.z.number(),
-            alloc: zod_1.z.number(),
-            totalAlloc: zod_1.z.number(),
-            sys: zod_1.z.number(),
-            mallocs: zod_1.z.number(),
-            frees: zod_1.z.number(),
-            liveObjects: zod_1.z.number(),
-            pauseTotalNs: zod_1.z.number(),
-            uptime: zod_1.z.number(),
-            reportsCount: zod_1.z.number().optional(),
+            xrayInfo: zod_1.z
+                .object({
+                numGoroutine: zod_1.z.number(),
+                numGC: zod_1.z.number(),
+                alloc: zod_1.z.number(),
+                totalAlloc: zod_1.z.number(),
+                sys: zod_1.z.number(),
+                mallocs: zod_1.z.number(),
+                frees: zod_1.z.number(),
+                liveObjects: zod_1.z.number(),
+                pauseTotalNs: zod_1.z.number(),
+                uptime: zod_1.z.number(),
+            })
+                .nullable(),
+            plugins: zod_1.z.object({
+                torrentBlocker: zod_1.z.object({
+                    reportsCount: zod_1.z.number(),
+                }),
+            }),
+            hotHostInfo: models_1.HotHostInfoSchema,
         }),
     });
 })(GetSystemStatsCommand || (exports.GetSystemStatsCommand = GetSystemStatsCommand = {}));

package/build/commands/stats/get-users-ip-list.command.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+export declare namespace GetUsersIpListCommand {
+    const url: "/node/stats/get-users-ip-list";
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            users: z.ZodArray<z.ZodObject<{
+                userId: z.ZodString;
+                ips: z.ZodArray<z.ZodObject<{
+                    ip: z.ZodString;
+                    lastSeen: z.ZodEffects<z.ZodString, Date, string>;
+                }, "strip", z.ZodTypeAny, {
+                    ip: string;
+                    lastSeen: Date;
+                }, {
+                    ip: string;
+                    lastSeen: string;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                userId: string;
+                ips: {
+                    ip: string;
+                    lastSeen: Date;
+                }[];
+            }, {
+                userId: string;
+                ips: {
+                    ip: string;
+                    lastSeen: string;
+                }[];
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            users: {
+                userId: string;
+                ips: {
+                    ip: string;
+                    lastSeen: Date;
+                }[];
+            }[];
+        }, {
+            users: {
+                userId: string;
+                ips: {
+                    ip: string;
+                    lastSeen: string;
+                }[];
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            users: {
+                userId: string;
+                ips: {
+                    ip: string;
+                    lastSeen: Date;
+                }[];
+            }[];
+        };
+    }, {
+        response: {
+            users: {
+                userId: string;
+                ips: {
+                    ip: string;
+                    lastSeen: string;
+                }[];
+            }[];
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=get-users-ip-list.command.d.ts.map

package/build/commands/stats/get-users-ip-list.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-users-ip-list.command.d.ts","sourceRoot":"","sources":["../../../commands/stats/get-users-ip-list.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,iCAAmC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoBzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/stats/get-users-ip-list.command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUsersIpListCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+var GetUsersIpListCommand;
+(function (GetUsersIpListCommand) {
+    GetUsersIpListCommand.url = api_1.REST_API.STATS.GET_USERS_IP_LIST;
+    GetUsersIpListCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            users: zod_1.z.array(zod_1.z.object({
+                userId: zod_1.z.string(),
+                ips: zod_1.z.array(zod_1.z.object({
+                    ip: zod_1.z.string(),
+                    lastSeen: zod_1.z
+                        .string()
+                        .datetime({
+                        local: true,
+                        offset: true,
+                    })
+                        .transform((str) => new Date(str)),
+                })),
+            })),
+        }),
+    });
+})(GetUsersIpListCommand || (exports.GetUsersIpListCommand = GetUsersIpListCommand = {}));

package/build/commands/stats/index.d.ts

@@ -6,5 +6,6 @@ export * from './get-outbound-stats.command';
 export * from './get-system-stats.command';
 export * from './get-user-ip-list.command';
 export * from './get-user-online-status.command';
+export * from './get-users-ip-list.command';
 export * from './get-users-stats.command';
 //# sourceMappingURL=index.d.ts.map

package/build/commands/stats/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/stats/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/stats/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC"}

package/build/commands/stats/index.js

@@ -22,4 +22,5 @@ __exportStar(require("./get-outbound-stats.command"), exports);
 __exportStar(require("./get-system-stats.command"), exports);
 __exportStar(require("./get-user-ip-list.command"), exports);
 __exportStar(require("./get-user-online-status.command"), exports);
+__exportStar(require("./get-users-ip-list.command"), exports);
 __exportStar(require("./get-users-stats.command"), exports);

package/build/commands/xray/index.d.ts

@@ -1,5 +1,4 @@
 export * from './get-node-health-check.command';
-export * from './get-status-and-version.command';
 export * from './start.command';
 export * from './stop.command';
 //# sourceMappingURL=index.d.ts.map

package/build/commands/xray/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/xray/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/xray/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/build/commands/xray/index.js

@@ -15,6 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./get-node-health-check.command"), exports);
-__exportStar(require("./get-status-and-version.command"), exports);
 __exportStar(require("./start.command"), exports);
 __exportStar(require("./stop.command"), exports);

package/build/commands/xray/start.command.d.ts

@@ -89,49 +89,134 @@ export declare namespace StartXrayCommand {
             isStarted: z.ZodBoolean;
             version: z.ZodNullable<z.ZodString>;
             error: z.ZodNullable<z.ZodString>;
-            systemInformation: z.ZodNullable<z.ZodObject<{
-                cpuCores: z.ZodNumber;
-                cpuModel: z.ZodString;
-                memoryTotal: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                cpuCores: number;
-                cpuModel: string;
-                memoryTotal: string;
-            }, {
-                cpuCores: number;
-                cpuModel: string;
-                memoryTotal: string;
-            }>>;
             nodeInformation: z.ZodObject<{
                 version: z.ZodNullable<z.ZodString>;
+                hostInfo: z.ZodObject<{
+                    arch: z.ZodString;
+                    cpus: z.ZodNumber;
+                    cpuModel: z.ZodString;
+                    memoryTotal: z.ZodNumber;
+                    hostname: z.ZodString;
+                    platform: z.ZodString;
+                    release: z.ZodString;
+                    type: z.ZodString;
+                    version: z.ZodString;
+                    networkInterfaces: z.ZodArray<z.ZodString, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                }, {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                }>;
+                hotHostInfo: z.ZodObject<{
+                    memoryFree: z.ZodNumber;
+                    uptime: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    memoryFree: number;
+                    uptime: number;
+                }, {
+                    memoryFree: number;
+                    uptime: number;
+                }>;
             }, "strip", z.ZodTypeAny, {
                 version: string | null;
+                hotHostInfo: {
+                    memoryFree: number;
+                    uptime: number;
+                };
+                hostInfo: {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                };
             }, {
                 version: string | null;
+                hotHostInfo: {
+                    memoryFree: number;
+                    uptime: number;
+                };
+                hostInfo: {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                };
             }>;
         }, "strip", z.ZodTypeAny, {
             error: string | null;
             version: string | null;
             isStarted: boolean;
-            systemInformation: {
-                cpuCores: number;
-                cpuModel: string;
-                memoryTotal: string;
-            } | null;
             nodeInformation: {
                 version: string | null;
+                hotHostInfo: {
+                    memoryFree: number;
+                    uptime: number;
+                };
+                hostInfo: {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                };
             };
         }, {
             error: string | null;
             version: string | null;
             isStarted: boolean;
-            systemInformation: {
-                cpuCores: number;
-                cpuModel: string;
-                memoryTotal: string;
-            } | null;
             nodeInformation: {
                 version: string | null;
+                hotHostInfo: {
+                    memoryFree: number;
+                    uptime: number;
+                };
+                hostInfo: {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                };
             };
         }>;
     }, "strip", z.ZodTypeAny, {
@@ -139,13 +224,24 @@ export declare namespace StartXrayCommand {
             error: string | null;
             version: string | null;
             isStarted: boolean;
-            systemInformation: {
-                cpuCores: number;
-                cpuModel: string;
-                memoryTotal: string;
-            } | null;
             nodeInformation: {
                 version: string | null;
+                hotHostInfo: {
+                    memoryFree: number;
+                    uptime: number;
+                };
+                hostInfo: {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                };
             };
         };
     }, {
@@ -153,13 +249,24 @@ export declare namespace StartXrayCommand {
             error: string | null;
             version: string | null;
             isStarted: boolean;
-            systemInformation: {
-                cpuCores: number;
-                cpuModel: string;
-                memoryTotal: string;
-            } | null;
             nodeInformation: {
                 version: string | null;
+                hotHostInfo: {
+                    memoryFree: number;
+                    uptime: number;
+                };
+                hostInfo: {
+                    type: string;
+                    arch: string;
+                    cpus: number;
+                    cpuModel: string;
+                    memoryTotal: number;
+                    hostname: string;
+                    platform: string;
+                    release: string;
+                    version: string;
+                    networkInterfaces: string[];
+                };
             };
         };
     }>;

package/build/commands/xray/start.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/start.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,GAAG,oBAAsB,CAAC;IAChC,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0BxB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"start.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/start.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,GAAG,oBAAsB,CAAC;IAChC,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAexB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAWzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/xray/start.command.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartXrayCommand = void 0;
 const zod_1 = require("zod");
+const models_1 = require("../../models");
 const api_1 = require("../../api");
-const UNSUPPORTED_REMNAWAVE_VERSION_MESSAGE = {
-    message: 'Unsupported Remnawave version. Please, upgrade Remnawave to version v2.3.x or higher. Or downgrade Remnawave Node version to v2.2.3 (change :latest to :2.2.3 in docker-compose.yml, most likely in /opt/remnanode)',
-};
 var StartXrayCommand;
 (function (StartXrayCommand) {
     StartXrayCommand.url = api_1.REST_API.XRAY.START;
@@ -20,29 +18,18 @@ var StartXrayCommand;
                     tag: zod_1.z.string(),
                 })),
             }),
-        }, {
-            errorMap: () => ({
-                ...UNSUPPORTED_REMNAWAVE_VERSION_MESSAGE,
-            }),
-        }),
-        xrayConfig: zod_1.z.record(zod_1.z.unknown(), {
-            errorMap: () => ({
-                ...UNSUPPORTED_REMNAWAVE_VERSION_MESSAGE,
-            }),
         }),
+        xrayConfig: zod_1.z.record(zod_1.z.unknown()),
     });
     StartXrayCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             isStarted: zod_1.z.boolean(),
             version: zod_1.z.string().nullable(),
             error: zod_1.z.string().nullable(),
-            systemInformation: zod_1.z.nullable(zod_1.z.object({
-                cpuCores: zod_1.z.number(),
-                cpuModel: zod_1.z.string(),
-                memoryTotal: zod_1.z.string(),
-            })),
             nodeInformation: zod_1.z.object({
                 version: zod_1.z.string().nullable(),
+                hostInfo: models_1.HostInfoSchema,
+                hotHostInfo: models_1.HotHostInfoSchema,
             }),
         }),
     });

package/build/constants/xray/stats.js

@@ -74,7 +74,7 @@ const XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL = ({ webhookUrl, }) => ({
     outboundTag: 'RW_TB_OUTBOUND_BLOCK',
     webhook: {
         url: webhookUrl,
-        deduplication: 30,
+        deduplication: 5,
     },
 });
 exports.XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL = XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL;

package/build/models/host-info.schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const HostInfoSchema: z.ZodObject<{
+    arch: z.ZodString;
+    cpus: z.ZodNumber;
+    cpuModel: z.ZodString;
+    memoryTotal: z.ZodNumber;
+    hostname: z.ZodString;
+    platform: z.ZodString;
+    release: z.ZodString;
+    type: z.ZodString;
+    version: z.ZodString;
+    networkInterfaces: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    arch: string;
+    cpus: number;
+    cpuModel: string;
+    memoryTotal: number;
+    hostname: string;
+    platform: string;
+    release: string;
+    version: string;
+    networkInterfaces: string[];
+}, {
+    type: string;
+    arch: string;
+    cpus: number;
+    cpuModel: string;
+    memoryTotal: number;
+    hostname: string;
+    platform: string;
+    release: string;
+    version: string;
+    networkInterfaces: string[];
+}>;
+export type THostInfo = z.infer<typeof HostInfoSchema>;
+export declare const HotHostInfoSchema: z.ZodObject<{
+    memoryFree: z.ZodNumber;
+    uptime: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    memoryFree: number;
+    uptime: number;
+}, {
+    memoryFree: number;
+    uptime: number;
+}>;
+export type THotHostInfo = z.infer<typeof HotHostInfoSchema>;
+//# sourceMappingURL=host-info.schema.d.ts.map

package/build/models/host-info.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-info.schema.d.ts","sourceRoot":"","sources":["../../models/host-info.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvD,eAAO,MAAM,iBAAiB;;;;;;;;;EAG5B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/build/models/host-info.schema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HotHostInfoSchema = exports.HostInfoSchema = void 0;
+const zod_1 = require("zod");
+exports.HostInfoSchema = zod_1.z.object({
+    arch: zod_1.z.string(),
+    cpus: zod_1.z.number().int(),
+    cpuModel: zod_1.z.string(),
+    memoryTotal: zod_1.z.number(),
+    hostname: zod_1.z.string(),
+    platform: zod_1.z.string(),
+    release: zod_1.z.string(),
+    type: zod_1.z.string(),
+    version: zod_1.z.string(),
+    networkInterfaces: zod_1.z.array(zod_1.z.string()),
+});
+exports.HotHostInfoSchema = zod_1.z.object({
+    memoryFree: zod_1.z.number(),
+    uptime: zod_1.z.number(),
+});

package/build/models/index.d.ts

@@ -1,3 +1,4 @@
+export * from './host-info.schema';
 export * from './torrent-blocker.report.schema';
 export * from './xray-webhook.schema';
 //# sourceMappingURL=index.d.ts.map

package/build/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC"}

package/build/models/index.js

@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./host-info.schema"), exports);
 __exportStar(require("./torrent-blocker.report.schema"), exports);
 __exportStar(require("./xray-webhook.schema"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/node-contract",
-  "version": "2.6.9",
+  "version": "2.6.11",
   "description": "A node-contract library for Remnawave Panel",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/build/commands/xray/get-status-and-version.command.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-export declare namespace GetStatusAndVersionCommand {
-    const url: "/node/xray/status";
-    const ResponseSchema: z.ZodObject<{
-        response: z.ZodObject<{
-            isRunning: z.ZodBoolean;
-            version: z.ZodNullable<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            isRunning: boolean;
-            version: string | null;
-        }, {
-            isRunning: boolean;
-            version: string | null;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        response: {
-            isRunning: boolean;
-            version: string | null;
-        };
-    }, {
-        response: {
-            isRunning: boolean;
-            version: string | null;
-        };
-    }>;
-    type Response = z.infer<typeof ResponseSchema>;
-}
-//# sourceMappingURL=get-status-and-version.command.d.ts.map

package/build/commands/xray/get-status-and-version.command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-status-and-version.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/get-status-and-version.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,0BAA0B,CAAC;IACjC,MAAM,GAAG,qBAAuB,CAAC;IAEjC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;MAKzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/xray/get-status-and-version.command.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetStatusAndVersionCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-var GetStatusAndVersionCommand;
-(function (GetStatusAndVersionCommand) {
-    GetStatusAndVersionCommand.url = api_1.REST_API.XRAY.STATUS;
-    GetStatusAndVersionCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.object({
-            isRunning: zod_1.z.boolean(),
-            version: zod_1.z.string().nullable(),
-        }),
-    });
-})(GetStatusAndVersionCommand || (exports.GetStatusAndVersionCommand = GetStatusAndVersionCommand = {}));