@remnawave/xtls-sdk 0.11.0 → 0.12.0

package/build/src/xray-protos/transport/internet/config.js

@@ -5,7 +5,7 @@
 //   protoc               v6.33.4
 // source: transport/internet/config.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HappyEyeballsConfig = exports.SocketConfig = exports.CustomSockopt = exports.ProxyConfig = exports.StreamConfig = exports.TransportConfig = exports.SocketConfig_TProxyMode = exports.AddressPortStrategy = exports.DomainStrategy = exports.protobufPackage = void 0;
+exports.HappyEyeballsConfig = exports.SocketConfig = exports.CustomSockopt = exports.ProxyConfig = exports.QuicParams = exports.UdpHop = exports.StreamConfig = exports.TransportConfig = exports.SocketConfig_TProxyMode = exports.AddressPortStrategy = exports.DomainStrategy = exports.protobufPackage = void 0;
 exports.domainStrategyFromJSON = domainStrategyFromJSON;
 exports.domainStrategyToJSON = domainStrategyToJSON;
 exports.addressPortStrategyFromJSON = addressPortStrategyFromJSON;
@@ -292,6 +292,7 @@ function createBaseStreamConfig() {
         securitySettings: [],
         udpmasks: [],
         tcpmasks: [],
+        quicParams: undefined,
         socketSettings: undefined,
     };
 }
@@ -322,6 +323,9 @@ exports.StreamConfig = {
         for (const v of message.tcpmasks) {
             typed_message_1.TypedMessage.encode(v, writer.uint32(90).fork()).join();
         }
+        if (message.quicParams !== undefined) {
+            exports.QuicParams.encode(message.quicParams, writer.uint32(98).fork()).join();
+        }
         if (message.socketSettings !== undefined) {
             exports.SocketConfig.encode(message.socketSettings, writer.uint32(50).fork()).join();
         }
@@ -390,6 +394,13 @@ exports.StreamConfig = {
                     message.tcpmasks.push(typed_message_1.TypedMessage.decode(reader, reader.uint32()));
                     continue;
                 }
+                case 12: {
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.quicParams = exports.QuicParams.decode(reader, reader.uint32());
+                    continue;
+                }
                 case 6: {
                     if (tag !== 50) {
                         break;
@@ -436,6 +447,11 @@ exports.StreamConfig = {
             tcpmasks: globalThis.Array.isArray(object?.tcpmasks)
                 ? object.tcpmasks.map((e) => typed_message_1.TypedMessage.fromJSON(e))
                 : [],
+            quicParams: isSet(object.quicParams)
+                ? exports.QuicParams.fromJSON(object.quicParams)
+                : isSet(object.quic_params)
+                    ? exports.QuicParams.fromJSON(object.quic_params)
+                    : undefined,
             socketSettings: isSet(object.socketSettings)
                 ? exports.SocketConfig.fromJSON(object.socketSettings)
                 : isSet(object.socket_settings)
@@ -469,6 +485,9 @@ exports.StreamConfig = {
         if (message.tcpmasks?.length) {
             obj.tcpmasks = message.tcpmasks.map((e) => typed_message_1.TypedMessage.toJSON(e));
         }
+        if (message.quicParams !== undefined) {
+            obj.quicParams = exports.QuicParams.toJSON(message.quicParams);
+        }
         if (message.socketSettings !== undefined) {
             obj.socketSettings = exports.SocketConfig.toJSON(message.socketSettings);
         }
@@ -489,6 +508,9 @@ exports.StreamConfig = {
         message.securitySettings = object.securitySettings?.map((e) => typed_message_1.TypedMessage.fromPartial(e)) || [];
         message.udpmasks = object.udpmasks?.map((e) => typed_message_1.TypedMessage.fromPartial(e)) || [];
         message.tcpmasks = object.tcpmasks?.map((e) => typed_message_1.TypedMessage.fromPartial(e)) || [];
+        message.quicParams = (object.quicParams !== undefined && object.quicParams !== null)
+            ? exports.QuicParams.fromPartial(object.quicParams)
+            : undefined;
         message.socketSettings = (object.socketSettings !== undefined && object.socketSettings !== null)
             ? exports.SocketConfig.fromPartial(object.socketSettings)
             : undefined;
@@ -496,6 +518,390 @@ exports.StreamConfig = {
     },
 };
 typeRegistry_1.messageTypeRegistry.set(exports.StreamConfig.$type, exports.StreamConfig);
+function createBaseUdpHop() {
+    return { $type: "xray.transport.internet.UdpHop", ports: [], intervalMin: 0, intervalMax: 0 };
+}
+exports.UdpHop = {
+    $type: "xray.transport.internet.UdpHop",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        writer.uint32(10).fork();
+        for (const v of message.ports) {
+            writer.uint32(v);
+        }
+        writer.join();
+        if (message.intervalMin !== 0) {
+            writer.uint32(16).int64(message.intervalMin);
+        }
+        if (message.intervalMax !== 0) {
+            writer.uint32(24).int64(message.intervalMax);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseUdpHop();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag === 8) {
+                        message.ports.push(reader.uint32());
+                        continue;
+                    }
+                    if (tag === 10) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.ports.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.intervalMin = longToNumber(reader.int64());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.intervalMax = longToNumber(reader.int64());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.UdpHop.$type,
+            ports: globalThis.Array.isArray(object?.ports) ? object.ports.map((e) => globalThis.Number(e)) : [],
+            intervalMin: isSet(object.intervalMin)
+                ? globalThis.Number(object.intervalMin)
+                : isSet(object.interval_min)
+                    ? globalThis.Number(object.interval_min)
+                    : 0,
+            intervalMax: isSet(object.intervalMax)
+                ? globalThis.Number(object.intervalMax)
+                : isSet(object.interval_max)
+                    ? globalThis.Number(object.interval_max)
+                    : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.ports?.length) {
+            obj.ports = message.ports.map((e) => Math.round(e));
+        }
+        if (message.intervalMin !== 0) {
+            obj.intervalMin = Math.round(message.intervalMin);
+        }
+        if (message.intervalMax !== 0) {
+            obj.intervalMax = Math.round(message.intervalMax);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.UdpHop.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseUdpHop();
+        message.ports = object.ports?.map((e) => e) || [];
+        message.intervalMin = object.intervalMin ?? 0;
+        message.intervalMax = object.intervalMax ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.UdpHop.$type, exports.UdpHop);
+function createBaseQuicParams() {
+    return {
+        $type: "xray.transport.internet.QuicParams",
+        congestion: "",
+        brutalUp: 0,
+        brutalDown: 0,
+        udpHop: undefined,
+        initStreamReceiveWindow: 0,
+        maxStreamReceiveWindow: 0,
+        initConnReceiveWindow: 0,
+        maxConnReceiveWindow: 0,
+        maxIdleTimeout: 0,
+        keepAlivePeriod: 0,
+        disablePathMtuDiscovery: false,
+        maxIncomingStreams: 0,
+    };
+}
+exports.QuicParams = {
+    $type: "xray.transport.internet.QuicParams",
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.congestion !== "") {
+            writer.uint32(10).string(message.congestion);
+        }
+        if (message.brutalUp !== 0) {
+            writer.uint32(16).uint64(message.brutalUp);
+        }
+        if (message.brutalDown !== 0) {
+            writer.uint32(24).uint64(message.brutalDown);
+        }
+        if (message.udpHop !== undefined) {
+            exports.UdpHop.encode(message.udpHop, writer.uint32(34).fork()).join();
+        }
+        if (message.initStreamReceiveWindow !== 0) {
+            writer.uint32(40).uint64(message.initStreamReceiveWindow);
+        }
+        if (message.maxStreamReceiveWindow !== 0) {
+            writer.uint32(48).uint64(message.maxStreamReceiveWindow);
+        }
+        if (message.initConnReceiveWindow !== 0) {
+            writer.uint32(56).uint64(message.initConnReceiveWindow);
+        }
+        if (message.maxConnReceiveWindow !== 0) {
+            writer.uint32(64).uint64(message.maxConnReceiveWindow);
+        }
+        if (message.maxIdleTimeout !== 0) {
+            writer.uint32(72).int64(message.maxIdleTimeout);
+        }
+        if (message.keepAlivePeriod !== 0) {
+            writer.uint32(80).int64(message.keepAlivePeriod);
+        }
+        if (message.disablePathMtuDiscovery !== false) {
+            writer.uint32(88).bool(message.disablePathMtuDiscovery);
+        }
+        if (message.maxIncomingStreams !== 0) {
+            writer.uint32(96).int64(message.maxIncomingStreams);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQuicParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.congestion = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.brutalUp = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.brutalDown = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.udpHop = exports.UdpHop.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.initStreamReceiveWindow = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.maxStreamReceiveWindow = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.initConnReceiveWindow = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.maxConnReceiveWindow = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.maxIdleTimeout = longToNumber(reader.int64());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.keepAlivePeriod = longToNumber(reader.int64());
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.disablePathMtuDiscovery = reader.bool();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.maxIncomingStreams = longToNumber(reader.int64());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            $type: exports.QuicParams.$type,
+            congestion: isSet(object.congestion) ? globalThis.String(object.congestion) : "",
+            brutalUp: isSet(object.brutalUp)
+                ? globalThis.Number(object.brutalUp)
+                : isSet(object.brutal_up)
+                    ? globalThis.Number(object.brutal_up)
+                    : 0,
+            brutalDown: isSet(object.brutalDown)
+                ? globalThis.Number(object.brutalDown)
+                : isSet(object.brutal_down)
+                    ? globalThis.Number(object.brutal_down)
+                    : 0,
+            udpHop: isSet(object.udpHop)
+                ? exports.UdpHop.fromJSON(object.udpHop)
+                : isSet(object.udp_hop)
+                    ? exports.UdpHop.fromJSON(object.udp_hop)
+                    : undefined,
+            initStreamReceiveWindow: isSet(object.initStreamReceiveWindow)
+                ? globalThis.Number(object.initStreamReceiveWindow)
+                : isSet(object.init_stream_receive_window)
+                    ? globalThis.Number(object.init_stream_receive_window)
+                    : 0,
+            maxStreamReceiveWindow: isSet(object.maxStreamReceiveWindow)
+                ? globalThis.Number(object.maxStreamReceiveWindow)
+                : isSet(object.max_stream_receive_window)
+                    ? globalThis.Number(object.max_stream_receive_window)
+                    : 0,
+            initConnReceiveWindow: isSet(object.initConnReceiveWindow)
+                ? globalThis.Number(object.initConnReceiveWindow)
+                : isSet(object.init_conn_receive_window)
+                    ? globalThis.Number(object.init_conn_receive_window)
+                    : 0,
+            maxConnReceiveWindow: isSet(object.maxConnReceiveWindow)
+                ? globalThis.Number(object.maxConnReceiveWindow)
+                : isSet(object.max_conn_receive_window)
+                    ? globalThis.Number(object.max_conn_receive_window)
+                    : 0,
+            maxIdleTimeout: isSet(object.maxIdleTimeout)
+                ? globalThis.Number(object.maxIdleTimeout)
+                : isSet(object.max_idle_timeout)
+                    ? globalThis.Number(object.max_idle_timeout)
+                    : 0,
+            keepAlivePeriod: isSet(object.keepAlivePeriod)
+                ? globalThis.Number(object.keepAlivePeriod)
+                : isSet(object.keep_alive_period)
+                    ? globalThis.Number(object.keep_alive_period)
+                    : 0,
+            disablePathMtuDiscovery: isSet(object.disablePathMtuDiscovery)
+                ? globalThis.Boolean(object.disablePathMtuDiscovery)
+                : isSet(object.disable_path_mtu_discovery)
+                    ? globalThis.Boolean(object.disable_path_mtu_discovery)
+                    : false,
+            maxIncomingStreams: isSet(object.maxIncomingStreams)
+                ? globalThis.Number(object.maxIncomingStreams)
+                : isSet(object.max_incoming_streams)
+                    ? globalThis.Number(object.max_incoming_streams)
+                    : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.congestion !== "") {
+            obj.congestion = message.congestion;
+        }
+        if (message.brutalUp !== 0) {
+            obj.brutalUp = Math.round(message.brutalUp);
+        }
+        if (message.brutalDown !== 0) {
+            obj.brutalDown = Math.round(message.brutalDown);
+        }
+        if (message.udpHop !== undefined) {
+            obj.udpHop = exports.UdpHop.toJSON(message.udpHop);
+        }
+        if (message.initStreamReceiveWindow !== 0) {
+            obj.initStreamReceiveWindow = Math.round(message.initStreamReceiveWindow);
+        }
+        if (message.maxStreamReceiveWindow !== 0) {
+            obj.maxStreamReceiveWindow = Math.round(message.maxStreamReceiveWindow);
+        }
+        if (message.initConnReceiveWindow !== 0) {
+            obj.initConnReceiveWindow = Math.round(message.initConnReceiveWindow);
+        }
+        if (message.maxConnReceiveWindow !== 0) {
+            obj.maxConnReceiveWindow = Math.round(message.maxConnReceiveWindow);
+        }
+        if (message.maxIdleTimeout !== 0) {
+            obj.maxIdleTimeout = Math.round(message.maxIdleTimeout);
+        }
+        if (message.keepAlivePeriod !== 0) {
+            obj.keepAlivePeriod = Math.round(message.keepAlivePeriod);
+        }
+        if (message.disablePathMtuDiscovery !== false) {
+            obj.disablePathMtuDiscovery = message.disablePathMtuDiscovery;
+        }
+        if (message.maxIncomingStreams !== 0) {
+            obj.maxIncomingStreams = Math.round(message.maxIncomingStreams);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.QuicParams.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseQuicParams();
+        message.congestion = object.congestion ?? "";
+        message.brutalUp = object.brutalUp ?? 0;
+        message.brutalDown = object.brutalDown ?? 0;
+        message.udpHop = (object.udpHop !== undefined && object.udpHop !== null)
+            ? exports.UdpHop.fromPartial(object.udpHop)
+            : undefined;
+        message.initStreamReceiveWindow = object.initStreamReceiveWindow ?? 0;
+        message.maxStreamReceiveWindow = object.maxStreamReceiveWindow ?? 0;
+        message.initConnReceiveWindow = object.initConnReceiveWindow ?? 0;
+        message.maxConnReceiveWindow = object.maxConnReceiveWindow ?? 0;
+        message.maxIdleTimeout = object.maxIdleTimeout ?? 0;
+        message.keepAlivePeriod = object.keepAlivePeriod ?? 0;
+        message.disablePathMtuDiscovery = object.disablePathMtuDiscovery ?? false;
+        message.maxIncomingStreams = object.maxIncomingStreams ?? 0;
+        return message;
+    },
+};
+typeRegistry_1.messageTypeRegistry.set(exports.QuicParams.$type, exports.QuicParams);
 function createBaseProxyConfig() {
     return { $type: "xray.transport.internet.ProxyConfig", tag: "", transportLayerProxy: false };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/xtls-sdk",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "A Typescript SDK for XRAY (XTLS) Core GRPC Api",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/build/scripts/export-protos.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=export-protos.d.ts.map

package/build/scripts/export-protos.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"export-protos.d.ts","sourceRoot":"","sources":["../../scripts/export-protos.ts"],"names":[],"mappings":""}

package/build/scripts/export-protos.js

@@ -1,132 +0,0 @@
-"use strict";
-/* eslint-disable no-console */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-const node_util_1 = require("node:util");
-const path = __importStar(require("node:path"));
-const fs = __importStar(require("node:fs"));
-const tar = __importStar(require("tar"));
-const VERSION = '26.2.6';
-const TEMP_DIR = path.join(__dirname, 'temp-xray-core');
-const TARGET_URL = `https://github.com/XTLS/Xray-core/archive/refs/tags/v${VERSION}.tar.gz`;
-const PROTO_DIR = path.join(__dirname, '../src/xray-protos');
-const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
-async function downloadTarGz(url, dest) {
-    const response = await fetch(url);
-    if (!response.ok)
-        throw new Error(`Failed to download file: ${response.statusText}`);
-    const buffer = await response.arrayBuffer();
-    fs.writeFileSync(dest, new Uint8Array(buffer));
-    console.log(`Core extracted to ${dest}`);
-}
-async function extractProtoFiles(tarPath) {
-    await tar.x({
-        file: tarPath,
-        cwd: TEMP_DIR,
-        strip: 1,
-    });
-    console.log('Core extracted');
-    const protoFiles = findProtoFiles(TEMP_DIR);
-    return protoFiles;
-}
-function findProtoFiles(dir, fileList = []) {
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-        const filePath = path.join(dir, file);
-        const stat = fs.statSync(filePath);
-        if (stat.isDirectory()) {
-            findProtoFiles(filePath, fileList);
-        }
-        else if (path.extname(file) === '.proto') {
-            fileList.push(filePath);
-        }
-    }
-    return fileList;
-}
-async function generateTsFromProto(protoFile) {
-    try {
-        console.log(protoFile);
-        const dir = path.join(__dirname, '../src/xray-protos');
-        const command = [
-            'protoc',
-            `--plugin=./node_modules/.bin/protoc-gen-ts_proto`,
-            `--ts_proto_out=${dir}`,
-            `--ts_proto_opt=outputServices=generic-definitions,useExactTypes=false`,
-            `--ts_proto_opt=outputServices=nice-grpc`,
-            `--ts_proto_opt=outputTypeRegistry=true`,
-            `--ts_proto_opt=outputEncodeMethods=true`,
-            `--ts_proto_opt=outputJsonMethods=true`,
-            `--ts_proto_opt=lowerCaseServiceMethods=true`,
-            `--proto_path=${path.join(__dirname, '../scripts/temp-xray-core')}`,
-            protoFile,
-        ].join(' ');
-        console.log(`Generating TypeScript for: ${protoFile}`);
-        const { stdout, stderr } = await execAsync(command);
-        if (stderr) {
-            console.error(`Error for ${protoFile}:`, stderr);
-        }
-        if (stdout) {
-            console.log(`Output for ${protoFile}:`, stdout);
-        }
-    }
-    catch (error) {
-        console.error(`Failed to generate TypeScript for ${protoFile}:`, error);
-    }
-}
-async function main() {
-    try {
-        if (!fs.existsSync(TEMP_DIR)) {
-            fs.mkdirSync(TEMP_DIR);
-        }
-        if (!fs.existsSync(PROTO_DIR)) {
-            fs.mkdirSync(PROTO_DIR, { recursive: true });
-        }
-        const tarPath = path.join(TEMP_DIR, `xray-core-${VERSION}.tar.gz`);
-        await downloadTarGz(TARGET_URL, tarPath);
-        const protoFiles = await extractProtoFiles(tarPath);
-        for (const protoFile of protoFiles) {
-            await generateTsFromProto(protoFile);
-        }
-    }
-    catch (error) {
-        console.error('Произошла ошибка:', error);
-    }
-    finally {
-        fs.rmSync(TEMP_DIR, { recursive: true, force: true });
-        console.log('Temp directory removed');
-    }
-}
-main();