@meru2802/aux-server 1.0.18 → 1.0.20

package/dist/controllers/coreController.js

@@ -9,274 +9,127 @@ class CoreController extends BaseController_1.BaseController {
         super(serviceContainer);
         this.getDownloadLink = async (req, res) => {
             try {
-                const deviceGroupName = req.body.deviceGroupName;
-                const deviceGroupId = req.body.deviceGroupId;
+                const { deviceGroupName, deviceGroupId } = req.body;
                 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.host}/meshagents?id=10006&meshid=${meshcookie}&ac=02`;
-                    const response = {
-                        download_link: downloadLink,
-                        timestamp: new Date().toISOString(),
-                    };
-                    res.status(200).json(response);
+                    const downloadLink = this.buildDownloadLink(deviceGroupId.split("/")[2]);
+                    res.status(200).json(this.buildDownloadLinkResponse(downloadLink));
                     return;
                 }
                 if (!deviceGroupName) {
-                    const errorResponse = {
-                        error: "'deviceGroupName' body param is required",
-                        timestamp: new Date().toISOString(),
-                    };
-                    res.status(400).json(errorResponse);
+                    this.sendErrorResponse(res, 400, "'deviceGroupName' body param is required");
                     return;
                 }
+                if (!this.ensureWebSocket(res))
+                    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);
+                if (!this.ensureMessageSent(res, meshesMessageSent))
                     return;
-                }
-                const waitForMeshResponse = new Promise((resolve, reject) => {
-                    let responseReceived = false;
-                    // Wait 60 second for ws message to arive
-                    const timeout = setTimeout(() => {
-                        if (!responseReceived) {
-                            responseReceived = true;
-                            reject(new Error("Timeout waiting for mesh response"));
-                        }
-                    }, 60000);
-                    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.host}/meshagents?id=10006&meshid=${meshcookie}&ac=02`;
-                                const response = {
-                                    download_link: downloadLink,
-                                    timestamp: new Date().toISOString(),
-                                };
-                                resolve(response);
-                            }
+                try {
+                    const response = await this.waitForWebSocketResponse(60000, (message, resolve, reject) => {
+                        if (message.action !== types_1.MeshActions.MESH_ES) {
+                            return false;
                         }
-                        catch (parseError) {
-                            if (!responseReceived) {
-                                responseReceived = true;
-                                clearTimeout(timeout);
-                                (_b = this.webSocket) === null || _b === void 0 ? void 0 : _b.removeListener("message", messageHandler);
-                                reject(parseError);
-                            }
+                        const meshesMessage = message;
+                        const mesh = meshesMessage.meshes.find((m) => m.name === deviceGroupName);
+                        if (!mesh) {
+                            reject(new Error("Mesh Not Found"));
+                            return true;
                         }
-                    };
-                    this.webSocket.on("message", messageHandler);
-                });
-                try {
-                    const response = await waitForMeshResponse;
+                        const downloadLink = this.buildDownloadLink(mesh._id.split("/")[2] || "");
+                        resolve(this.buildDownloadLinkResponse(downloadLink));
+                        return true;
+                    });
                     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;
+                    this.sendErrorResponse(res, 500, error instanceof Error
+                        ? error.message
+                        : "Failed to get mesh response");
                 }
             }
             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.sendErrorResponse(res, 500, "Internal server error");
             }
         };
         this.createDeviceGroup = async (req, res) => {
             try {
-                const deviceGroupName = req.body.deviceGroupName;
-                const description = req.body.description;
+                const { deviceGroupName, description } = req.body;
                 if (!deviceGroupName) {
-                    const errorResponse = {
-                        error: "'deviceGroupName' body param is required",
-                        timestamp: new Date().toISOString(),
-                    };
-                    res.status(400).json(errorResponse);
+                    this.sendErrorResponse(res, 400, "'deviceGroupName' body param is required");
                     return;
                 }
+                if (!this.ensureWebSocket(res))
+                    return;
                 const createMeshMessageSent = this.WebSocketService.sendMessage({
                     action: "createmesh",
                     meshname: deviceGroupName,
                     meshtype: 2,
-                    desc: description ? description : "",
+                    desc: description !== null && description !== void 0 ? 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);
+                if (!this.ensureMessageSent(res, createMeshMessageSent))
                     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"));
-                        }
-                    }, 60000);
-                    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;
+                    const response = await this.waitForWebSocketResponse(60000, (message, resolve, reject) => {
+                        const msg = message;
+                        if (msg.action !== types_1.MeshActions.CREATE_MESH)
+                            return false;
+                        const createMeshMessage = message;
+                        if (createMeshMessage.result !== "ok") {
+                            reject(new Error(`Could Not Create Device Group with name: ${deviceGroupName}`));
+                            return true;
+                        }
+                        resolve({
+                            result: createMeshMessage.result,
+                            deviceGroupId: createMeshMessage.meshid,
+                            timestamp: new Date().toISOString(),
+                        });
+                        return true;
+                    });
                     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);
+                    this.sendErrorResponse(res, 500, error instanceof Error
+                        ? error.message
+                        : "Failed to get createmesh response");
                 }
             }
             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.sendErrorResponse(res, 500, "Internal server error");
             }
         };
         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);
+                    this.sendErrorResponse(res, 400, "'users' body param is required and must be a non-empty array");
                     return;
                 }
                 if (!deviceGroupName && !deviceGroupId) {
-                    const errorResponse = {
-                        error: "Either 'deviceGroupName' or 'deviceGroupId' body param is required",
-                        timestamp: new Date().toISOString(),
-                    };
-                    res.status(400).json(errorResponse);
+                    this.sendErrorResponse(res, 400, "Either 'deviceGroupName' or 'deviceGroupId' body param is required");
                     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}`.toLowerCase();
-                            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 (!this.ensureWebSocket(res))
+                    return;
+                const { meshUsers, failedUsers } = await this.fetchMeshUsers(users);
+                if (meshUsers.length === 0) {
+                    this.sendErrorResponse(res, 400, "No valid users found in the database");
+                    return;
                 }
-                if (meshUserIds.length === 0) {
-                    const errorResponse = {
-                        error: "No valid users found in the database",
-                        timestamp: new Date().toISOString(),
-                    };
-                    res.status(400).json(errorResponse);
+                const { createdUsers, existingUsers, failedToCreate } = await this.createMeshUsers(meshUsers);
+                const usersToAddToGroup = [...createdUsers, ...existingUsers];
+                const allFailedUsers = [...failedUsers, ...failedToCreate];
+                if (usersToAddToGroup.length === 0) {
+                    this.sendErrorResponse(res, 400, "Failed to create or find any users in MeshCentral");
                     return;
                 }
+                const meshUserIds = usersToAddToGroup.map((u) => u.meshId);
                 const addMeshUserMessage = {
                     action: "addmeshuser",
                     meshid: deviceGroupId,
@@ -287,174 +140,337 @@ class CoreController extends BaseController_1.BaseController {
                 };
                 console.log(`Add Mesh User Message: ${JSON.stringify(addMeshUserMessage)}`);
                 const addMeshUserMessageSent = this.WebSocketService.sendMessage(addMeshUserMessage);
-                console.log(addMeshUserMessageSent);
-                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);
+                if (!this.ensureMessageSent(res, addMeshUserMessageSent))
                     return;
-                }
-                const waitForAddUserResponse = new Promise((resolve, reject) => {
-                    let responseReceived = false;
-                    const addedUsers = [];
-                    let expectedResponses = meshUserIds.length;
-                    // Wait 60 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"));
-                            }
-                        }
-                    }, 60000);
-                    const messageHandler = (data) => {
-                        var _a;
-                        if (responseReceived)
-                            return;
-                        try {
-                            const message = JSON.parse(data.toString());
-                            console.log(`Mesh Message received: ${JSON.stringify(message)}`);
-                            if (message.action == types_1.MeshActions.EVENT &&
-                                message.event.msgid == 78) {
-                                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);
-                            reject(parseError);
-                        }
-                    };
-                    this.webSocket.on("message", messageHandler);
-                });
                 try {
-                    const response = await waitForAddUserResponse;
+                    const response = await this.waitForAddUserToGroupResponse(meshUserIds, allFailedUsers);
                     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);
+                    this.sendErrorResponse(res, 500, error instanceof Error
+                        ? error.message
+                        : "Failed to add users to device group");
                 }
             }
             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.sendErrorResponse(res, 500, "Internal server error");
             }
         };
         this.getEndpointInstallScript = async (req, res) => {
             try {
                 const { clientId, siteId, agentType, endpointUrl, os, installerToken } = req.body;
-                const baseUrl = `${this.config.epmConfig.server}`;
-                const iceberg_org_id_query = "SELECT string_value FROM clients_clientcustomfield WHERE client_id = $1";
-                const iceberg_site_id_query = "SELECT string_value FROM clients_sitecustomfield WHERE site_id = $1";
-                const iceberg_org_token_query = "SELECT string_value FROM clients_clientcustomfield WHERE client_id = $1 AND field_id = $2";
-                const iceberg_asset_type_id_query = "SELECT string_value FROM clients_clientcustomfield WHERE client_id = $1 AND field_id = $2";
-                console.log(`[getAgentDetails] Executing parallel queries for iceberg details`);
-                const iceberg_org_id_promise = this.dbPool.query(iceberg_org_id_query, [clientId]);
-                const iceberg_site_id_promise = this.dbPool.query(iceberg_site_id_query, [siteId]);
-                const iceberg_org_token_promise = this.dbPool.query(iceberg_org_token_query, [
-                    clientId,
-                    this.config.epmConfig.tokenFieldId,
-                ]);
-                const iceberg_asset_type_id_promise = this.dbPool.query(iceberg_asset_type_id_query, [
-                    clientId,
-                    this.config.epmConfig.assetTypeFieldId,
-                ]);
-                let [iceberg_ord_id, iceberg_site_id, iceberg_org_token, iceberg_asset_type_id,] = await Promise.all([
-                    iceberg_org_id_promise,
-                    iceberg_site_id_promise,
-                    iceberg_org_token_promise,
-                    iceberg_asset_type_id_promise,
-                ]);
-                console.log(`[getAgentDetails] Iceberg queries completed with results:`, {
-                    org_id_rows: iceberg_ord_id.rows.length,
-                    site_id_rows: iceberg_site_id.rows.length,
-                    org_token_rows: iceberg_org_token.rows.length,
-                    asset_type_id_rows: iceberg_asset_type_id.rows.length,
-                });
-                if (iceberg_ord_id.rows.length > 0 &&
-                    iceberg_site_id.rows.length > 0 &&
-                    iceberg_org_token.rows.length > 0 &&
-                    iceberg_asset_type_id.rows.length > 0) {
-                    const siteRow = iceberg_site_id.rows[0];
-                    const orgRow = iceberg_ord_id.rows[0];
-                    const orgTokenRow = iceberg_org_token.rows[0];
-                    const assetTypeRow = iceberg_asset_type_id.rows[0];
-                    if (!siteRow || !orgRow || !orgTokenRow || !assetTypeRow) {
-                        const errorResponse = {
-                            error: "Either SiteId, OrgId, OrgToken, or AssetTypeId is missing",
-                            timestamp: new Date().toISOString(),
-                        };
-                        res.status(501).json(errorResponse);
+                const icebergDetails = await this.fetchIcebergDetails(clientId, siteId);
+                if (!icebergDetails) {
+                    this.sendErrorResponse(res, 501, "Either SiteId, OrgId, OrgToken, or AssetTypeId is missing");
+                    return;
+                }
+                const { assetTypeId, icebergSiteId, icebergOrgId, icebergOrgToken } = icebergDetails;
+                const baseUrl = this.config.epmConfig.server;
+                if (os === types_1.OperatingSystems.WINDOWS) {
+                    const script = this.generateWindowsScript({
+                        baseUrl,
+                        clientId,
+                        siteId,
+                        agentType,
+                        installerToken,
+                        endpointUrl,
+                        assetTypeId,
+                        icebergSiteId,
+                        icebergOrgId,
+                        icebergOrgToken,
+                    });
+                    this.sendScript(res, "powershell", script);
+                    return;
+                }
+                if (os === types_1.OperatingSystems.LINUX) {
+                    if (!this.ensureWebSocket(res))
+                        return;
+                    const meshesMessageSent = this.WebSocketService.sendMessage({
+                        action: "meshes",
+                        responseid: "meshctrl",
+                    });
+                    if (!this.ensureMessageSent(res, meshesMessageSent))
                         return;
+                    try {
+                        const { deviceGroupId } = await this.waitForWebSocketResponse(60000, (message, resolve, reject) => {
+                            const msg = message;
+                            if (msg.action !== types_1.MeshActions.MESH_ES)
+                                return false;
+                            const meshesMessage = message;
+                            console.log(`meshes: ${JSON.stringify(meshesMessage)}`);
+                            const mesh = meshesMessage.meshes.find((m) => m.name === "TacticalRMM");
+                            if (!mesh) {
+                                reject(new Error("Mesh Not Found"));
+                                return true;
+                            }
+                            const groupId = mesh._id.split("/")[2];
+                            if (!groupId) {
+                                reject(new Error("Error parsing deviceGroupId"));
+                                return true;
+                            }
+                            resolve({ deviceGroupId: groupId });
+                            return true;
+                        });
+                        const script = this.generateLinuxScript({
+                            baseUrl,
+                            clientId,
+                            siteId,
+                            agentType,
+                            installerToken,
+                            endpointUrl,
+                            assetTypeId,
+                            icebergSiteId,
+                            icebergOrgId,
+                            icebergOrgToken,
+                            deviceGroupId,
+                        });
+                        this.sendScript(res, "bash", script);
                     }
-                    const assetTypeId = assetTypeRow.string_value;
-                    const icebergSiteId = siteRow.string_value;
-                    const icebergOrgId = orgRow.string_value;
-                    const icebergOrgToken = orgTokenRow.string_value;
-                    if (os == types_1.OperatingSystems.WINDOWS) {
-                        const script = `
+                    catch (error) {
+                        console.error("Error waiting for mesh response:", error);
+                        this.sendErrorResponse(res, 500, error instanceof Error
+                            ? error.message
+                            : "Failed to get mesh response");
+                    }
+                    return;
+                }
+                if (os === types_1.OperatingSystems.MACOS) {
+                    this.sendErrorResponse(res, 501, "Macos script is not supported yet");
+                    return;
+                }
+                this.sendErrorResponse(res, 400, "Unsupported operating system");
+            }
+            catch (error) {
+                console.error("Error generating install script:", error);
+                this.sendErrorResponse(res, 500, "Internal server error");
+            }
+        };
+    }
+    sendErrorResponse(res, status, error) {
+        const errorResponse = {
+            error,
+            timestamp: new Date().toISOString(),
+        };
+        res.status(status).json(errorResponse);
+    }
+    ensureWebSocket(res) {
+        if (!this.webSocket) {
+            this.sendErrorResponse(res, 500, "Socket Not Found");
+            return false;
+        }
+        return true;
+    }
+    ensureMessageSent(res, sent) {
+        if (!sent) {
+            this.sendErrorResponse(res, 500, "Could Not Send Message Over Socket");
+            return false;
+        }
+        return true;
+    }
+    sendScript(res, type, script) {
+        res.setHeader("X-Script-Type", type);
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.status(200).send(script);
+    }
+    buildDownloadLink(meshId) {
+        const inviteEncryptionKey = (0, utils_1.getBinaryKey)(this.config.meshcentralConfig.inviteEncryptionKey);
+        const meshcookie = (0, utils_1.encodeCookie)({ m: meshId }, inviteEncryptionKey);
+        return `https://${this.config.meshcentralConfig.host}/meshagents?id=10006&meshid=${meshcookie}&ac=02`;
+    }
+    buildDownloadLinkResponse(downloadLink) {
+        return {
+            download_link: downloadLink,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    waitForWebSocketResponse(timeoutMs, handler) {
+        return new Promise((resolve, reject) => {
+            let responseReceived = false;
+            const timeout = setTimeout(() => {
+                var _a;
+                if (!responseReceived) {
+                    responseReceived = true;
+                    (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.removeListener("message", messageHandler);
+                    reject(new Error("Timeout waiting for WebSocket response"));
+                }
+            }, timeoutMs);
+            const cleanup = () => {
+                var _a;
+                clearTimeout(timeout);
+                (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.removeListener("message", messageHandler);
+            };
+            const messageHandler = (data) => {
+                if (responseReceived)
+                    return;
+                try {
+                    const message = JSON.parse(data.toString());
+                    const handled = handler(message, (value) => {
+                        responseReceived = true;
+                        cleanup();
+                        resolve(value);
+                    }, (error) => {
+                        responseReceived = true;
+                        cleanup();
+                        reject(error);
+                    });
+                    if (!handled)
+                        return;
+                }
+                catch (parseError) {
+                    if (!responseReceived) {
+                        responseReceived = true;
+                        cleanup();
+                        reject(parseError);
+                    }
+                }
+            };
+            this.webSocket.on("message", messageHandler);
+        });
+    }
+    waitForAddUserToGroupResponse(meshUserIds, failedUsers) {
+        return new Promise((resolve, reject) => {
+            let responseReceived = false;
+            const addedUsers = [];
+            let expectedResponses = meshUserIds.length;
+            const timeout = setTimeout(() => {
+                var _a;
+                if (!responseReceived) {
+                    responseReceived = true;
+                    (_a = this.webSocket) === null || _a === void 0 ? void 0 : _a.removeListener("message", messageHandler);
+                    if (addedUsers.length > 0) {
+                        resolve({
+                            result: "partial",
+                            users_added: addedUsers,
+                            failed_users: failedUsers.length > 0 ? failedUsers : undefined,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                    else {
+                        reject(new Error("Timeout waiting for add mesh user response"));
+                    }
+                }
+            }, 60000);
+            const messageHandler = (data) => {
+                var _a;
+                if (responseReceived)
+                    return;
+                try {
+                    const message = JSON.parse(data.toString());
+                    console.log(`Mesh Message received: ${JSON.stringify(message)}`);
+                    if (message.action === types_1.MeshActions.EVENT &&
+                        message.event.msgid === 78) {
+                        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);
+                                resolve({
+                                    result: "success",
+                                    users_added: addedUsers,
+                                    failed_users: failedUsers.length > 0 ? failedUsers : undefined,
+                                    timestamp: new Date().toISOString(),
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (parseError) {
+                    console.error("Error parsing WebSocket message:", parseError);
+                }
+            };
+            this.webSocket.on("message", messageHandler);
+        });
+    }
+    async fetchMeshUsers(users) {
+        const meshUsers = [];
+        const failedUsers = [];
+        try {
+            const placeholders = users.map((_, index) => `$${index + 1}`).join(",");
+            const query = `SELECT username, id, email, first_name, last_name FROM accounts_user WHERE username IN (${placeholders})`;
+            const result = await this.dbPool.query(query, users);
+            const foundUsers = new Map();
+            result.rows.forEach((row) => {
+                foundUsers.set(row.username, {
+                    id: row.id,
+                    firstName: row.first_name,
+                    lastName: row.last_name,
+                    email: row.email,
+                });
+            });
+            for (const username of users) {
+                const userDetails = foundUsers.get(username);
+                if (userDetails) {
+                    const meshUserName = `${username}___${userDetails.id}`.toLowerCase();
+                    meshUsers.push({
+                        meshId: `user//${meshUserName}`,
+                        meshUserName,
+                        fullName: `${userDetails.firstName} ${userDetails.lastName}`,
+                        email: userDetails.email,
+                    });
+                }
+                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);
+        }
+        return { meshUsers, failedUsers };
+    }
+    async fetchIcebergDetails(clientId, siteId) {
+        console.log(`[getAgentDetails] Executing parallel queries for iceberg details`);
+        const [icebergOrgId, icebergSiteId, icebergOrgToken, icebergAssetTypeId] = await Promise.all([
+            this.dbPool.query("SELECT string_value FROM clients_clientcustomfield WHERE client_id = $1", [clientId]),
+            this.dbPool.query("SELECT string_value FROM clients_sitecustomfield WHERE site_id = $1", [siteId]),
+            this.dbPool.query("SELECT string_value FROM clients_clientcustomfield WHERE client_id = $1 AND field_id = $2", [clientId, this.config.epmConfig.tokenFieldId]),
+            this.dbPool.query("SELECT string_value FROM clients_clientcustomfield WHERE client_id = $1 AND field_id = $2", [clientId, this.config.epmConfig.assetTypeFieldId]),
+        ]);
+        console.log(`[getAgentDetails] Iceberg queries completed with results:`, {
+            org_id_rows: icebergOrgId.rows.length,
+            site_id_rows: icebergSiteId.rows.length,
+            org_token_rows: icebergOrgToken.rows.length,
+            asset_type_id_rows: icebergAssetTypeId.rows.length,
+        });
+        const orgRow = icebergOrgId.rows[0];
+        const siteRow = icebergSiteId.rows[0];
+        const orgTokenRow = icebergOrgToken.rows[0];
+        const assetTypeRow = icebergAssetTypeId.rows[0];
+        if (!orgRow || !siteRow || !orgTokenRow || !assetTypeRow) {
+            return null;
+        }
+        return {
+            assetTypeId: assetTypeRow.string_value,
+            icebergSiteId: siteRow.string_value,
+            icebergOrgId: orgRow.string_value,
+            icebergOrgToken: orgTokenRow.string_value,
+        };
+    }
+    generateWindowsScript(params) {
+        return `
 $endpointsetup = 'nexus-endpoint-v0.1.0-i32-setup.exe'
-$api = '"${baseUrl}"'
-$clientid = '${clientId}'
-$siteid = '${siteId}'
-$agenttype = '"${agentType}"'
+$api = '"${params.baseUrl}"'
+$clientid = '${params.clientId}'
+$siteid = '${params.siteId}'
+$agenttype = '"${params.agentType}"'
 $power = 0
 $rdp = 1
 $ping = 0
-$auth = '"${installerToken}"'
-$endpointdownloadlink = '${endpointUrl}'
+$auth = '"${params.installerToken}"'
+$endpointdownloadlink = '${params.endpointUrl}'
 $apilink = $endpointdownloadlink.split('/')
-$assetTypeId = '"${assetTypeId}"'
-$icebergSiteId = '"${icebergSiteId}"'
-$icebergOrgId = '"${icebergOrgId}"'
-$icebergOrgToken = '"${icebergOrgToken}"'
+$assetTypeId = '"${params.assetTypeId}"'
+$icebergSiteId = '"${params.icebergSiteId}"'
+$icebergOrgId = '"${params.icebergOrgId}"'
+$icebergOrgToken = '"${params.icebergOrgToken}"'
 $assetEndpoint = '"${this.config.icebergConfig.assetEndpoint}"'
 [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
 $serviceName = 'nexusrmm'
@@ -517,81 +533,9 @@ If (Get-Service $serviceName -ErrorAction SilentlyContinue) {
     }
 }
 `;
-                        res.setHeader("X-Script-Type", "powershell");
-                        res.setHeader("Content-Type", "text/plain; charset=utf-8");
-                        res.status(200).send(script);
-                    }
-                    else if (os == types_1.OperatingSystems.LINUX) {
-                        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;
-                            const timeout = setTimeout(() => {
-                                if (!responseReceived) {
-                                    responseReceived = true;
-                                    reject(new Error("Timeout waiting for mesh response"));
-                                }
-                            }, 60000);
-                            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;
-                                        console.log(`meshes: ${JSON.stringify(meshesMessasge)}`);
-                                        const mesh = meshesMessasge.meshes.find((mesh) => mesh.name == "TacticalRMM");
-                                        if (!mesh) {
-                                            reject(new Error("Mesh Not Found"));
-                                            return;
-                                        }
-                                        const deviceGroupId = mesh._id.split("/")[2];
-                                        if (!deviceGroupId) {
-                                            reject(new Error("Error parsing deviceGroupId"));
-                                            return;
-                                        }
-                                        const response = {
-                                            deviceGroupId,
-                                        };
-                                        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;
-                            const script = `
+    }
+    generateLinuxScript(params) {
+        return `
 #!/usr/bin/env bash
 
 if [ $EUID -ne 0 ]; then
@@ -625,7 +569,7 @@ echo "Downloading and installing Nexus Endpoint..."
 sudo apt-get update
 sudo apt-get install -y libwebkit2gtk-4.1-0 libgtk-3-0 libappindicator3-1 libayatana-appindicator3-1 libxdo-dev
 INSTALLER="nexus-endpoint-installer.deb"
-wget "${endpointUrl}" -O "$INSTALLER"
+wget "${params.endpointUrl}" -O "$INSTALLER"
 sudo dpkg -i "$INSTALLER"
 rm -f "$INSTALLER"
 
@@ -634,17 +578,17 @@ INSECURE=0
 NOMESH=0
 
 agentDL='https://nexus-endpoint-desktop-app.s3.ap-south-1.amazonaws.com/rmmagent/linux/x64/nexusrmm-amd64'
-meshDL='https://${this.config.meshcentralConfig.host}/meshagents?id=${response.deviceGroupId}&installflags=2&meshinstall=6'
-
-apiURL='${baseUrl}'
-token='${installerToken}'
-clientID='${clientId}'
-siteID='${siteId}'
-agentType='${agentType}'
-assetTypeId='${assetTypeId}'
-icebergSiteId='${icebergSiteId}'
-icebergOrgId='${icebergOrgId}'
-icebergOrgToken='${icebergOrgToken}'
+meshDL='https://${this.config.meshcentralConfig.host}/meshagents?id=${params.deviceGroupId}&installflags=2&meshinstall=6'
+
+apiURL='${params.baseUrl}'
+token='${params.installerToken}'
+clientID='${params.clientId}'
+siteID='${params.siteId}'
+agentType='${params.agentType}'
+assetTypeId='${params.assetTypeId}'
+icebergSiteId='${params.icebergSiteId}'
+icebergOrgId='${params.icebergOrgId}'
+icebergOrgToken='${params.icebergOrgToken}'
 assetEndpoint='${this.config.icebergConfig.assetEndpoint}'
 proxy=''
 
@@ -848,50 +792,6 @@ systemctl start \${agentSvcName}
 sudo systemctl restart gdm3
 sudo systemctl restart systemd-logind
 sudo dmidecode --string system-serial-number`;
-                            res.setHeader("X-Script-Type", "bash");
-                            res.setHeader("Content-Type", "text/plain; charset=utf-8");
-                            res.status(200).send(script);
-                            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;
-                        }
-                    }
-                    else if (os == types_1.OperatingSystems.MACOS) {
-                        const errorResponse = {
-                            error: "Macos script is not supported yet",
-                            timestamp: new Date().toISOString(),
-                        };
-                        res.status(501).json(errorResponse);
-                        return;
-                    }
-                }
-                else {
-                    const errorResponse = {
-                        error: "Either SiteId, OrgId, OrgToken, or AssetTypeId is missing",
-                        timestamp: new Date().toISOString(),
-                    };
-                    res.status(501).json(errorResponse);
-                    return;
-                }
-            }
-            catch (error) {
-                console.error("Error generating install script :", error);
-                const errorResponse = {
-                    error: "Internal server error",
-                    timestamp: new Date().toISOString(),
-                };
-                res.status(500).json(errorResponse);
-            }
-        };
     }
 }
 exports.CoreController = CoreController;