@meru2802/aux-server 1.0.0

package/dist/controllers/coreController.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response } from "express";
+import { IServiceContainer } from "../services/ServiceContainer";
+import { BaseController } from "./BaseController";
+export declare class CoreController extends BaseController {
+    constructor(serviceContainer?: IServiceContainer);
+    getDownloadLink: (req: Request, res: Response) => Promise<void>;
+    createDeviceGroup: (req: Request, res: Response) => Promise<void>;
+    addUserToGroup: (req: Request, res: Response) => Promise<void>;
+    getEndpointInstallScript: (req: Request, res: Response) => void;
+}
+//# sourceMappingURL=coreController.d.ts.map

package/dist/controllers/coreController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreController.d.ts","sourceRoot":"","sources":["../../src/controllers/coreController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAelD,qBAAa,cAAe,SAAQ,cAAc;gBACpC,gBAAgB,CAAC,EAAE,iBAAiB;IAIzC,eAAe,GACpB,KAAK,OAAO,EACZ,KAAK,QAAQ,KACZ,OAAO,CAAC,IAAI,CAAC,CAkJd;IAEK,iBAAiB,GACtB,KAAK,OAAO,EACZ,KAAK,QAAQ,KACZ,OAAO,CAAC,IAAI,CAAC,CAoHd;IAEK,cAAc,GACnB,KAAK,OAAO,EACZ,KAAK,QAAQ,KACZ,OAAO,CAAC,IAAI,CAAC,CAyLd;IAEK,wBAAwB,GAAI,KAAK,OAAO,EAAE,KAAK,QAAQ,UAgF5D;CACH"}

package/dist/controllers/coreController.js

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreController = void 0;
+const BaseController_1 = require("./BaseController");
+const types_1 = require("../types");
+const utils_1 = require("../lib/utils");
+class CoreController extends BaseController_1.BaseController {
+    constructor(serviceContainer) {
+        super(serviceContainer);
+        this.getDownloadLink = async (req, res) => {
+            try {
+                const deviceGroupName = req.body.deviceGroupName;
+                const deviceGroupId = req.body.deviceGroupId; // Not required but if given then deviceGroupName is not required
+                if (deviceGroupId) {
+                    const inviteEncryptionKey = (0, utils_1.getBinaryKey)(this.config.meshcentralConfig.inviteEncryptionKey);
+                    const meshcookie = (0, utils_1.encodeCookie)({ m: deviceGroupId.split("/")[2] }, inviteEncryptionKey);
+                    const downloadLink = `https://${this.config.meshcentralConfig.server}/meshagents?id=10006&meshid=${meshcookie}&ac=02`;
+                    const response = {
+                        download_link: downloadLink,
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(200).json(response);
+                    return;
+                }
+                if (!deviceGroupName) {
+                    const errorResponse = {
+                        error: "'deviceGroupName' body param is required",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(400).json(errorResponse);
+                    return;
+                }
+                const meshesMessageSent = this.WebSocketService.sendMessage({
+                    action: "meshes",
+                    responseid: "meshctrl",
+                });
+                if (!meshesMessageSent) {
+                    const errorResponse = {
+                        error: "Could Not Send Message Over Socket",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                    return;
+                }
+                if (!this.webSocket) {
+                    const errorResponse = {
+                        error: "Socket Not Found",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                    return;
+                }
+                const waitForMeshResponse = new Promise((resolve, reject) => {
+                    let responseReceived = false;
+                    // Wait 10 second for ws message to arive
+                    const timeout = setTimeout(() => {
+                        if (!responseReceived) {
+                            responseReceived = true;
+                            reject(new Error("Timeout waiting for mesh response"));
+                        }
+                    }, 10000);
+                    const messageHandler = (data) => {
+                        var _a, _b;
+                        if (responseReceived)
+                            return;
+                        try {
+                            const message = JSON.parse(data.toString());
+                            if (message.action === types_1.MeshActions.MESH_ES) {
+                                responseReceived = true;
+                                clearTimeout(timeout);
+                                (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.removeListener("message", messageHandler);
+                                const meshesMessasge = message;
+                                const mesh = meshesMessasge.meshes.find((mesh) => mesh.name === deviceGroupName);
+                                if (!mesh) {
+                                    reject(new Error("Mesh Not Found"));
+                                    return;
+                                }
+                                const inviteEncryptionKey = (0, utils_1.getBinaryKey)(this.config.meshcentralConfig.inviteEncryptionKey);
+                                const meshcookie = (0, utils_1.encodeCookie)({ m: mesh._id.split("/")[2] }, inviteEncryptionKey);
+                                const downloadLink = `https://${this.config.meshcentralConfig.server}/meshagents?id=10006&meshid=${meshcookie}&ac=02`;
+                                const response = {
+                                    download_link: downloadLink,
+                                    timestamp: new Date().toISOString(),
+                                };
+                                resolve(response);
+                            }
+                        }
+                        catch (parseError) {
+                            if (!responseReceived) {
+                                responseReceived = true;
+                                clearTimeout(timeout);
+                                (_b = this.webSocket) === null || _b === void 0 ? void 0 : _b.removeListener("message", messageHandler);
+                                reject(parseError);
+                            }
+                        }
+                    };
+                    this.webSocket.on("message", messageHandler);
+                });
+                try {
+                    const response = await waitForMeshResponse;
+                    res.status(200).json(response);
+                    return;
+                }
+                catch (error) {
+                    console.error("Error waiting for mesh response:", error);
+                    const errorResponse = {
+                        error: error instanceof Error
+                            ? error.message
+                            : "Failed to get mesh response",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                    return;
+                }
+            }
+            catch (error) {
+                console.error("Error creating download link:", error);
+                const errorResponse = {
+                    error: "Internal server error",
+                    timestamp: new Date().toISOString(),
+                };
+                res.status(500).json(errorResponse);
+                return;
+            }
+        };
+        this.createDeviceGroup = async (req, res) => {
+            try {
+                const deviceGroupName = req.body.deviceGroupName;
+                const description = req.body.description;
+                if (!deviceGroupName) {
+                    const errorResponse = {
+                        error: "'deviceGroupName' body param is required",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(400).json(errorResponse);
+                    return;
+                }
+                const createMeshMessageSent = this.WebSocketService.sendMessage({
+                    action: "createmesh",
+                    meshname: deviceGroupName,
+                    meshtype: 2,
+                    desc: description ? description : "",
+                });
+                if (!createMeshMessageSent) {
+                    const errorResponse = {
+                        error: "Could Not Send Message Over Socket",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                    return;
+                }
+                if (!this.webSocket) {
+                    const errorResponse = {
+                        error: "Socket Not Found",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                    return;
+                }
+                const waitForMeshResponse = new Promise((resolve, reject) => {
+                    let responseReceived = false;
+                    // Wait 10 second for ws message to arive
+                    const timeout = setTimeout(() => {
+                        if (!responseReceived) {
+                            responseReceived = true;
+                            reject(new Error("Timeout waiting for mesh response"));
+                        }
+                    }, 10000);
+                    const messageHandler = (data) => {
+                        var _a, _b;
+                        if (responseReceived)
+                            return;
+                        try {
+                            const message = JSON.parse(data.toString());
+                            if (message.action === types_1.MeshActions.CREATE_MESH) {
+                                responseReceived = true;
+                                clearTimeout(timeout);
+                                (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.removeListener("message", messageHandler);
+                                const createMeshMessage = message;
+                                if (createMeshMessage.result != "ok") {
+                                    reject(new Error(`Could Not Create Device Group with name: ${deviceGroupName}`));
+                                }
+                                const response = {
+                                    result: createMeshMessage.result,
+                                    deviceGroupId: createMeshMessage.meshid,
+                                    timestamp: new Date().toISOString(),
+                                };
+                                resolve(response);
+                            }
+                        }
+                        catch (parseError) {
+                            if (!responseReceived) {
+                                responseReceived = true;
+                                clearTimeout(timeout);
+                                (_b = this.webSocket) === null || _b === void 0 ? void 0 : _b.removeListener("message", messageHandler);
+                                reject(parseError);
+                            }
+                        }
+                    };
+                    this.webSocket.on("message", messageHandler);
+                });
+                try {
+                    const response = await waitForMeshResponse;
+                    res.status(200).json(response);
+                    return;
+                }
+                catch (error) {
+                    console.error("Error waiting for createmesh response:", error);
+                    const errorResponse = {
+                        error: error instanceof Error
+                            ? error.message
+                            : "Failed to get createmesh response",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                }
+            }
+            catch (error) {
+                console.error("Error creating device group link:", error);
+                const errorResponse = {
+                    error: "Internal server error",
+                    timestamp: new Date().toISOString(),
+                };
+                res.status(500).json(errorResponse);
+            }
+        };
+        this.addUserToGroup = async (req, res) => {
+            try {
+                const { deviceGroupName, deviceGroupId, users } = req.body;
+                if (!users || !Array.isArray(users) || users.length === 0) {
+                    const errorResponse = {
+                        error: "'users' body param is required and must be a non-empty array",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(400).json(errorResponse);
+                    return;
+                }
+                if (!deviceGroupName && !deviceGroupId) {
+                    const errorResponse = {
+                        error: "Either 'deviceGroupName' or 'deviceGroupId' body param is required",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(400).json(errorResponse);
+                    return;
+                }
+                const meshUserIds = [];
+                const failedUsers = [];
+                try {
+                    const placeholders = users.map((_, index) => `$${index + 1}`).join(",");
+                    const nexus_epm_user_id_query = `SELECT username, id FROM accounts_user WHERE username IN (${placeholders})`;
+                    const nexus_epm_user_id = await this.dbPool.query(nexus_epm_user_id_query, users);
+                    const foundUsers = new Map();
+                    nexus_epm_user_id.rows.forEach((row) => {
+                        foundUsers.set(row.username, row.id);
+                    });
+                    for (const username of users) {
+                        const userId = foundUsers.get(username);
+                        if (userId) {
+                            const meshUserId = `user//${username}___${userId}`;
+                            meshUserIds.push(meshUserId);
+                        }
+                        else {
+                            console.warn(`User '${username}' not found in database`);
+                            failedUsers.push(username);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("Error fetching user IDs from database:", error);
+                    failedUsers.push(...users);
+                }
+                if (meshUserIds.length === 0) {
+                    const errorResponse = {
+                        error: "No valid users found in the database",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(400).json(errorResponse);
+                    return;
+                }
+                const addMeshUserMessage = {
+                    action: "addmeshuser",
+                    meshid: deviceGroupId,
+                    meshname: deviceGroupName,
+                    userids: meshUserIds,
+                    meshadmin: 4294967295,
+                    remove: false,
+                };
+                const addMeshUserMessageSent = this.WebSocketService.sendMessage(addMeshUserMessage);
+                if (!addMeshUserMessageSent) {
+                    const errorResponse = {
+                        error: "Could Not Send Message Over Socket",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                    return;
+                }
+                if (!this.webSocket) {
+                    const errorResponse = {
+                        error: "Socket Not Found",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                    return;
+                }
+                const waitForAddUserResponse = new Promise((resolve, reject) => {
+                    let responseReceived = false;
+                    const addedUsers = [];
+                    let expectedResponses = meshUserIds.length;
+                    // Wait 15 seconds for ws message to arrive (longer timeout for multiple users)
+                    const timeout = setTimeout(() => {
+                        if (!responseReceived) {
+                            responseReceived = true;
+                            if (addedUsers.length > 0) {
+                                // Partial success
+                                resolve({
+                                    result: "partial",
+                                    users_added: addedUsers,
+                                    failed_users: failedUsers,
+                                    timestamp: new Date().toISOString(),
+                                });
+                            }
+                            else {
+                                reject(new Error("Timeout waiting for add mesh user response"));
+                            }
+                        }
+                    }, 15000);
+                    const messageHandler = (data) => {
+                        var _a;
+                        if (responseReceived)
+                            return;
+                        try {
+                            const message = JSON.parse(data.toString());
+                            if (message.action === types_1.MeshActions.EVENT &&
+                                message.event.etype === "user" &&
+                                message.event.action === "accountchange" &&
+                                message.event.msg.includes("Device group membership changed")) {
+                                const changedUser = message.event.msgArgs[0];
+                                if (changedUser &&
+                                    meshUserIds.some((userId) => userId.includes(changedUser))) {
+                                    addedUsers.push(changedUser);
+                                    expectedResponses--;
+                                    if (expectedResponses <= 0) {
+                                        responseReceived = true;
+                                        clearTimeout(timeout);
+                                        (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.removeListener("message", messageHandler);
+                                        const response = {
+                                            result: "success",
+                                            users_added: addedUsers,
+                                            failed_users: failedUsers.length > 0 ? failedUsers : undefined,
+                                            timestamp: new Date().toISOString(),
+                                        };
+                                        resolve(response);
+                                    }
+                                }
+                            }
+                        }
+                        catch (parseError) {
+                            console.error("Error parsing WebSocket message:", parseError);
+                        }
+                    };
+                    this.webSocket.on("message", messageHandler);
+                });
+                try {
+                    const response = await waitForAddUserResponse;
+                    res.status(200).json(response);
+                    return;
+                }
+                catch (error) {
+                    console.error("Error waiting for add mesh user response:", error);
+                    const errorResponse = {
+                        error: error instanceof Error
+                            ? error.message
+                            : "Failed to add users to device group",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(500).json(errorResponse);
+                }
+            }
+            catch (error) {
+                console.error("Error adding users to device group:", error);
+                const errorResponse = {
+                    error: "Internal server error",
+                    timestamp: new Date().toISOString(),
+                };
+                res.status(500).json(errorResponse);
+            }
+        };
+        this.getEndpointInstallScript = (req, res) => {
+            const { clientId, siteId, agentType, endpointUrl } = req.body;
+            const baseUrl = `https://${this.config.epmConfig.server}`;
+            const script = `
+$endpointsetup = 'nexus-endpoint-v0.1.0-i32-setup.exe'
+$api = '"${baseUrl}"'
+$clientid = '${clientId}'
+$siteid = '${siteId}'
+$agenttype = '"${agentType}"'
+$power = 0
+$rdp = 1
+$ping = 0
+$auth = '"${this.config.epmConfig.installerToken}"'
+$endpointdownloadlink = '${endpointUrl}'
+$apilink = $endpointdownloadlink.split('/')
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$serviceName = 'nexusrmm'
+If (Get-Service $serviceName -ErrorAction SilentlyContinue) {
+    write-host ('Nexus RMM Agent Is Already Installed')
+} Else {
+    $OutPath = $env:TMP
+    $installArgs = @('-m install --api ', "$api", '--client-id', $clientid, '--site-id', $siteid, '--agent-type', "$agenttype", '--auth', "$auth", '-silent')
+    if ($power) {
+        $installArgs += "--power"
+    }
+    if ($rdp) {
+        $installArgs += "--rdp"
+    }
+    if ($ping) {
+        $installArgs += "--ping"
+    }
+    Try
+    {
+        $DefenderStatus = Get-MpComputerStatus | select  AntivirusEnabled
+        if ($DefenderStatus -match "True") {
+            Add-MpPreference -ExclusionPath 'C:\\Program Files\\NexusAgent\\*'
+            Add-MpPreference -ExclusionPath 'C:\\Program Files\\NexusMeshBackend\\*'
+            Add-MpPreference -ExclusionPath 'C:\\Program Files\\Nexus Endpoint\\*'
+            Add-MpPreference -ExclusionPath 'C:\\ProgramData\\NexusRMM\\*'
+        }
+    }
+    Catch {
+        # pass
+    }
+    
+    $X = 0
+    do {
+      Write-Output "Waiting for network"
+      Start-Sleep -s 5
+      $X += 1      
+    } until(($connectresult = Test-NetConnection $apilink[2] -Port 443 | ? { $_.TcpTestSucceeded }) -or $X -eq 3)
+    
+    if ($connectresult.TcpTestSucceeded -eq $true){
+        Try{
+            Invoke-WebRequest -Uri $endpointdownloadlink -OutFile $OutPath\\$endpointsetup
+            Start-Process -FilePath $OutPath\\$endpointsetup -ArgumentList ('/S') -Wait
+            write-host ('Extracting Nexus Endpoint...')
+            Start-Sleep -s 5
+            Start-Process -FilePath "C:\\Program Files\\Nexus Endpoint\\rmmagent.exe" -ArgumentList ('/VERYSILENT /SUPPRESSMSGBOXES') -Wait
+            Start-Sleep -s 5
+            Start-Process -FilePath "C:\\Program Files\\NexusAgent\\nexusrmm.exe" -ArgumentList $installArgs -Wait
+            exit 0
+        } Catch {
+            $ErrorMessage = $_.Exception.Message
+            $FailedItem = $_.Exception.ItemName
+            Write-Error -Message "$ErrorMessage $FailedItem"
+            exit 1
+        }
+        Finally{
+            Remove-Item -Path $OutPath\\$endpointsetup
+        }
+    } else {
+        Write-Output "Unable to connect to server"
+    }
+}
+`;
+            res.setHeader("X-Script-Type", "Powershell");
+            res.setHeader("Content-Type", "text/plain; charset=utf-8");
+            res.status(200).send(script);
+        };
+    }
+}
+exports.CoreController = CoreController;

package/dist/controllers/healthController.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response } from "express";
+import { BaseController } from "./BaseController";
+import { IServiceContainer } from "../services/ServiceContainer";
+export declare class HealthController extends BaseController {
+    constructor(serviceContainer?: IServiceContainer);
+    health: (req: Request, res: Response) => void;
+    status: (req: Request, res: Response) => void;
+}
+//# sourceMappingURL=healthController.d.ts.map

package/dist/controllers/healthController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"healthController.d.ts","sourceRoot":"","sources":["../../src/controllers/healthController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEjE,qBAAa,gBAAiB,SAAQ,cAAc;gBACtC,gBAAgB,CAAC,EAAE,iBAAiB;IAIzC,MAAM,GAAI,KAAK,OAAO,EAAE,KAAK,QAAQ,KAAG,IAAI,CASjD;IAEK,MAAM,GAAI,KAAK,OAAO,EAAE,KAAK,QAAQ,KAAG,IAAI,CAgBjD;CACH"}

package/dist/controllers/healthController.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthController = void 0;
+const BaseController_1 = require("./BaseController");
+class HealthController extends BaseController_1.BaseController {
+    constructor(serviceContainer) {
+        super(serviceContainer);
+        this.health = (req, res) => {
+            const response = {
+                status: "ok",
+                timestamp: new Date().toISOString(),
+                meshConnection: this.isWebSocketConnected,
+                dbConnection: !this.dbPool.ended,
+            };
+            res.json(response);
+        };
+        this.status = (req, res) => {
+            const response = {
+                service: "aux-server",
+                version: "1.0.0",
+                meshCentral: {
+                    connected: this.isWebSocketConnected,
+                    server: this.meshServer,
+                },
+                database: {
+                    connected: !this.dbPool.ended,
+                    host: this.dbPool.options.host || "unknown",
+                },
+                uptime: process.uptime(),
+            };
+            res.json(response);
+        };
+    }
+}
+exports.HealthController = HealthController;

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { ServiceContainer } from "./services/ServiceContainer";
+export default class AuxServer {
+    private static instance;
+    private config;
+    private serviceContainer;
+    private constructor();
+    static getInstance(): AuxServer;
+    start(port?: number): Promise<void>;
+    shutdown(): Promise<void>;
+    isHealthy(): Promise<boolean>;
+    getServiceContainer(): ServiceContainer;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAE/D,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAY;IACnC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAmB;IAE3C,OAAO;WAKO,WAAW,IAAI,SAAS;IAQzB,KAAK,CAAC,IAAI,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUzC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAUzB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAUnC,mBAAmB,IAAI,gBAAgB;CAG/C"}

package/dist/index.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("./config");
+const ServiceContainer_1 = require("./services/ServiceContainer");
+class AuxServer {
+    constructor() {
+        this.config = config_1.ConfigManager.getInstance().getConfig();
+        this.serviceContainer = ServiceContainer_1.ServiceContainer.initialize(this.config);
+    }
+    static getInstance() {
+        if (this.instance) {
+            return this.instance;
+        }
+        this.instance = new AuxServer();
+        return this.instance;
+    }
+    async start(port = 3003) {
+        try {
+            const applicationService = this.serviceContainer.getApplicationService();
+            await applicationService.start(port);
+        }
+        catch (error) {
+            console.error("Failed to start AuxServer:", error);
+            throw error;
+        }
+    }
+    async shutdown() {
+        try {
+            const applicationService = this.serviceContainer.getApplicationService();
+            await applicationService.stop();
+        }
+        catch (error) {
+            console.error("Error during shutdown:", error);
+            throw error;
+        }
+    }
+    async isHealthy() {
+        try {
+            const applicationService = this.serviceContainer.getApplicationService();
+            return await applicationService.isHealthy();
+        }
+        catch (error) {
+            console.error("Health check failed:", error);
+            return false;
+        }
+    }
+    getServiceContainer() {
+        return this.serviceContainer;
+    }
+}
+exports.default = AuxServer;
+const auxServer = AuxServer.getInstance();
+async function startServer() {
+    try {
+        const port = parseInt(process.env.PORT || "3003");
+        await auxServer.start(port);
+    }
+    catch (error) {
+        console.error("Failed to start server:", error);
+        process.exit(1);
+    }
+}
+async function gracefulShutdown(signal) {
+    console.log(`Received ${signal}, shutting down gracefully...`);
+    try {
+        await auxServer.shutdown();
+        console.log("Server shutdown completed");
+        process.exit(0);
+    }
+    catch (error) {
+        console.error("Error during shutdown:", error);
+        process.exit(1);
+    }
+}
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("uncaughtException", async (error) => {
+    console.error("Uncaught Exception:", error);
+    try {
+        await auxServer.shutdown();
+    }
+    catch (shutdownError) {
+        console.error("Error during emergency shutdown:", shutdownError);
+    }
+    process.exit(1);
+});
+process.on("unhandledRejection", async (reason, promise) => {
+    console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    try {
+        await auxServer.shutdown();
+    }
+    catch (shutdownError) {
+        console.error("Error during emergency shutdown:", shutdownError);
+    }
+    process.exit(1);
+});
+startServer();

package/dist/lib/utils/index.d.ts

@@ -0,0 +1,10 @@
+export interface CookieObject {
+    time?: number;
+    [key: string]: any;
+}
+export declare class CookieEncryptionError extends Error {
+    constructor(message: string);
+}
+export declare function encodeCookie(o: CookieObject, key: Buffer | null): string | null;
+export declare function getBinaryKey(key: string): Buffer;
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/index.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,YAAY,CAC1B,CAAC,EAAE,YAAY,EACf,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,MAAM,GAAG,IAAI,CAqCf;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}