@meru2802/aux-server 1.0.0

package/README.md

@@ -0,0 +1,168 @@
+# Nexus EPM Auxiliary Server
+
+Nexus EPM auxiliary server to facilitate additional functionality required by Scogo Iceberg.
+
+## Features
+
+- MeshCentral integration for remote device management
+- Device group management
+- Download link generation for mesh agents
+- Connection URL generation for remote access (control, terminal, file system)
+- Health monitoring and status endpoints
+- WebSocket connectivity for real-time communication
+- PostgreSQL database integration
+
+## API Documentation
+
+The server includes comprehensive API documentation using Swagger/OpenAPI 3.0.
+
+### Accessing API Documentation
+
+Once the server is running, you can access the interactive API documentation at:
+
+- **Swagger UI**: `http://localhost:3003/docs`
+- **OpenAPI JSON Spec**: `http://localhost:3003/docs/json`
+
+The Swagger UI provides:
+- Interactive API testing
+- Detailed endpoint documentation
+- Request/response schema definitions
+- Example requests and responses
+- Authentication information
+
+### Available Endpoints
+
+#### Health Endpoints
+- `GET /health` - Basic health check for load balancers
+- `GET /status` - Detailed service status including connections and uptime
+
+#### API Endpoints
+- `POST /api/generate-download-link` - Generate download link for MeshCentral agent
+- `POST /api/generate-connect-urls` - Generate authenticated URLs for device access
+
+#### Core Endpoints
+- `POST /core/create-device-group` - Create a new device group in MeshCentral
+- `POST /core/add-user-to-group` - Add multiple users to a device group
+
+## Development
+
+### Prerequisites
+
+- Node.js (v18 or higher)
+- pnpm
+- PostgreSQL database
+- MeshCentral server
+
+### Installation
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the project
+pnpm run build
+
+# Start the server
+pnpm run start
+
+# Development mode with auto-reload
+pnpm run dev:watch
+```
+
+### Environment Setup
+
+Ensure you have the proper configuration in `config.json` with:
+- MeshCentral server credentials and encryption keys
+- Database connection settings
+- Iceberg integration endpoints
+- Logging configuration
+
+### Database Setup
+
+Run the schema.sql file against your PostgreSQL database to set up the required tables:
+
+```bash
+pnpm run setup:db
+```
+
+## Configuration
+
+The server uses a JSON configuration file (`config.json`) with the following structure:
+
+- `meshcentralConfig`: MeshCentral server connection and encryption settings
+- `dbConfig`: PostgreSQL database connection settings
+- `icebergConfig`: Iceberg integration endpoints
+- `logging`: Logging configuration for file rotation and levels
+
+## Usage
+
+### Getting a Download Link
+
+```bash
+curl -X POST http://localhost:3003/api/generate-download-link \
+  -H "Content-Type: application/json" \
+  -d '{"deviceGroupName": "production-servers"}'
+```
+
+### Getting Connection URLs
+
+```bash
+curl -X POST http://localhost:3003/api/generate-connect-urls \
+  -H "Content-Type: application/json" \
+  -d '{"meshNodeId": "node//abc123", "userId": "john.doe"}'
+```
+
+### Creating a Device Group
+
+```bash
+curl -X POST http://localhost:3003/core/create-device-group \
+  -H "Content-Type: application/json" \
+  -d '{"deviceGroupName": "new-group", "description": "My new device group"}'
+```
+
+### Adding Users to a Device Group
+
+```bash
+curl -X POST http://localhost:3003/core/add-user-to-group \
+  -H "Content-Type: application/json" \
+  -d '{"deviceGroupName": "production-servers", "users": ["john.doe", "jane.smith"]}'
+```
+
+## Architecture
+
+The server follows a modular architecture with:
+
+- **Controllers**: Handle HTTP request/response logic
+- **Services**: Business logic and external integrations
+- **Routes**: API endpoint definitions and middleware
+- **Middleware**: Request processing, error handling, and validation
+- **Types**: TypeScript type definitions
+
+## Health Monitoring
+
+The server provides comprehensive health monitoring:
+
+- **Basic Health Check**: `/health` - Quick status for load balancers
+- **Detailed Status**: `/status` - Complete service information including:
+  - Service version and uptime
+  - MeshCentral connection status
+  - Database connection status
+  - External service connectivity
+
+## Error Handling
+
+All endpoints return standardized error responses with:
+- HTTP status codes
+- Error messages
+- Timestamps
+- Request correlation information
+
+## Security
+
+The server implements:
+- CORS configuration
+- Helmet security headers
+- Request validation
+- Encrypted cookie handling for MeshCentral integration
+- Database connection pooling with proper error handling
+

package/dist/config/index.d.ts

@@ -0,0 +1,37 @@
+import { Config } from "../types";
+export declare class ConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): ConfigManager;
+    private loadConfig;
+    getConfig(): Config;
+    getMeshConfig(): {
+        user: string;
+        password: string;
+        server: string;
+        loginEncryptionKey: string;
+        inviteEncryptionKey: string;
+    };
+    getDbConfig(): {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        database: string;
+    };
+    getIcebergConfig(): {
+        eventsEndpoint: string;
+        introspectEndpoint: string;
+        HMAC_SECRET: string;
+    };
+    getLoggingConfig(): {
+        level: string;
+        directory: string;
+        filename: string;
+        datePattern: string;
+        maxSize: string;
+        maxFiles: string;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAgB;IACvC,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO;WAIO,WAAW,IAAI,aAAa;IAO1C,OAAO,CAAC,UAAU;IAwDX,SAAS,IAAI,MAAM;IAInB,aAAa;;;;;;;IAIb,WAAW;;;;;;;IAIX,gBAAgB;;;;;IAIhB,gBAAgB;;;;;;;;CAGxB"}

package/dist/config/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class ConfigManager {
+    constructor() {
+        this.config = this.loadConfig();
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    loadConfig() {
+        let configPath;
+        const expectedConfigPath = path_1.default.resolve("/rmm/plugins/aux-server/config.json");
+        if (fs_1.default.existsSync(expectedConfigPath)) {
+            configPath = expectedConfigPath;
+        }
+        else {
+            const findRootDir = (startDir) => {
+                let currentDir = startDir;
+                while (currentDir !== "/" && currentDir !== "") {
+                    if (path_1.default.basename(currentDir) === "aux-server" &&
+                        path_1.default.basename(path_1.default.dirname(currentDir)) === "plugins") {
+                        return currentDir;
+                    }
+                    if (fs_1.default.existsSync(path_1.default.join(currentDir, "config.json"))) {
+                        return currentDir;
+                    }
+                    const parentDir = path_1.default.dirname(currentDir);
+                    if (parentDir === currentDir) {
+                        break;
+                    }
+                    currentDir = parentDir;
+                }
+                return process.cwd();
+            };
+            const rootDir = findRootDir(__dirname);
+            configPath = path_1.default.join(rootDir, "config.json");
+        }
+        console.log(`Looking for config file at: ${configPath}`);
+        if (!fs_1.default.existsSync(configPath)) {
+            console.error(`Config file not found at ${configPath}. Please ensure config.json exists.`);
+            process.exit(1);
+        }
+        try {
+            return JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+        }
+        catch (error) {
+            console.error("Error parsing config file:", error);
+            process.exit(1);
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    getMeshConfig() {
+        return this.config.meshcentralConfig;
+    }
+    getDbConfig() {
+        return this.config.dbConfig;
+    }
+    getIcebergConfig() {
+        return this.config.icebergConfig;
+    }
+    getLoggingConfig() {
+        return this.config.logging;
+    }
+}
+exports.ConfigManager = ConfigManager;

package/dist/config/swagger.d.ts

@@ -0,0 +1,2 @@
+export declare const swaggerSpec: object;
+//# sourceMappingURL=swagger.d.ts.map

package/dist/config/swagger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swagger.d.ts","sourceRoot":"","sources":["../../src/config/swagger.ts"],"names":[],"mappings":"AAsQA,eAAO,MAAM,WAAW,QAAwB,CAAC"}

package/dist/config/swagger.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swaggerSpec = void 0;
+const swagger_jsdoc_1 = __importDefault(require("swagger-jsdoc"));
+const options = {
+    definition: {
+        openapi: "3.0.0",
+        info: {
+            title: "Aux Server API",
+            version: "1.0.0",
+            description: "Nexus EPM auxiliary server to facilitate additional functionality required by Scogo Iceberg",
+            contact: {
+                name: "API Support",
+                email: "support@example.com",
+            },
+        },
+        servers: [
+            {
+                url: "http://localhost:3003",
+                description: "Development server",
+            },
+        ],
+        components: {
+            schemas: {
+                ErrorResponse: {
+                    type: "object",
+                    properties: {
+                        error: {
+                            type: "string",
+                            description: "Error message",
+                            example: "Internal server error",
+                        },
+                        timestamp: {
+                            type: "string",
+                            format: "date-time",
+                            description: "Error timestamp",
+                            example: "2023-12-01T10:30:00.000Z",
+                        },
+                    },
+                    required: ["error"],
+                },
+                HealthResponse: {
+                    type: "object",
+                    properties: {
+                        status: {
+                            type: "string",
+                            description: "Service status",
+                            example: "healthy",
+                        },
+                        timestamp: {
+                            type: "string",
+                            format: "date-time",
+                            description: "Health check timestamp",
+                            example: "2023-12-01T10:30:00.000Z",
+                        },
+                        meshConnection: {
+                            type: "boolean",
+                            description: "MeshCentral connection status",
+                            example: true,
+                        },
+                        dbConnection: {
+                            type: "boolean",
+                            description: "Database connection status",
+                            example: true,
+                        },
+                    },
+                    required: ["status", "timestamp", "meshConnection", "dbConnection"],
+                },
+                StatusResponse: {
+                    type: "object",
+                    properties: {
+                        service: {
+                            type: "string",
+                            description: "Service name",
+                            example: "aux-server",
+                        },
+                        version: {
+                            type: "string",
+                            description: "Service version",
+                            example: "1.0.0",
+                        },
+                        meshCentral: {
+                            type: "object",
+                            properties: {
+                                connected: {
+                                    type: "boolean",
+                                    description: "MeshCentral connection status",
+                                    example: true,
+                                },
+                                server: {
+                                    type: "string",
+                                    description: "MeshCentral server URL",
+                                    example: "meshcentral.example.com",
+                                },
+                            },
+                            required: ["connected", "server"],
+                        },
+                        database: {
+                            type: "object",
+                            properties: {
+                                connected: {
+                                    type: "boolean",
+                                    description: "Database connection status",
+                                    example: true,
+                                },
+                                host: {
+                                    type: "string",
+                                    description: "Database host",
+                                    example: "localhost",
+                                },
+                            },
+                            required: ["connected", "host"],
+                        },
+                        uptime: {
+                            type: "number",
+                            description: "Server uptime in seconds",
+                            example: 3600,
+                        },
+                    },
+                    required: ["service", "version", "meshCentral", "database", "uptime"],
+                },
+                DownloadLinkRequest: {
+                    type: "object",
+                    properties: {
+                        deviceGroupName: {
+                            type: "string",
+                            description: "Name of the device group to get download link for (required if deviceGroupId not provided)",
+                            example: "production-servers",
+                        },
+                        deviceGroupId: {
+                            type: "string",
+                            description: "ID of the device group to get download link for (required if deviceGroupName not provided)",
+                            example: "mesh//abc123def456",
+                        },
+                    },
+                },
+                DownloadLinkResponse: {
+                    type: "object",
+                    properties: {
+                        download_link: {
+                            type: "string",
+                            format: "uri",
+                            description: "Download link for the mesh agent",
+                            example: "https://meshcentral.example.com/meshagents?id=10006&meshid=abc123&ac=02",
+                        },
+                        timestamp: {
+                            type: "string",
+                            format: "date-time",
+                            description: "Response timestamp",
+                            example: "2023-12-01T10:30:00.000Z",
+                        },
+                    },
+                    required: ["download_link", "timestamp"],
+                },
+                ConnectUrlsRequest: {
+                    type: "object",
+                    properties: {
+                        meshNodeId: {
+                            type: "string",
+                            description: "The mesh node ID to connect to",
+                            example: "node//abc123def456",
+                        },
+                        userId: {
+                            type: "string",
+                            description: "The user ID for authentication",
+                            example: "john.doe",
+                        },
+                    },
+                    required: ["meshNodeId", "userId"],
+                },
+                ConnectUrlsResponse: {
+                    type: "object",
+                    properties: {
+                        control: {
+                            type: "string",
+                            format: "uri",
+                            description: "URL for remote desktop control access",
+                            example: "https://meshcentral.example.com/?login=token&gotonode=node123&viewmode=11&hide=31",
+                        },
+                        terminal: {
+                            type: "string",
+                            format: "uri",
+                            description: "URL for terminal access",
+                            example: "https://meshcentral.example.com/?login=token&gotonode=node123&viewmode=12&hide=31",
+                        },
+                        file_system: {
+                            type: "string",
+                            format: "uri",
+                            description: "URL for file system access",
+                            example: "https://meshcentral.example.com/?login=token&gotonode=node123&viewmode=13&hide=31",
+                        },
+                        timestamp: {
+                            type: "string",
+                            format: "date-time",
+                            description: "Response timestamp",
+                            example: "2023-12-01T10:30:00.000Z",
+                        },
+                    },
+                    required: ["control", "terminal", "file_system", "timestamp"],
+                },
+            },
+            responses: {
+                BadRequest: {
+                    description: "Bad request - missing or invalid parameters",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: "#/components/schemas/ErrorResponse",
+                            },
+                            example: {
+                                error: "'deviceGroupName' body param is required",
+                                timestamp: "2023-12-01T10:30:00.000Z",
+                            },
+                        },
+                    },
+                },
+                InternalServerError: {
+                    description: "Internal server error",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: "#/components/schemas/ErrorResponse",
+                            },
+                            example: {
+                                error: "Internal server error",
+                                timestamp: "2023-12-01T10:30:00.000Z",
+                            },
+                        },
+                    },
+                },
+                NotFound: {
+                    description: "Resource not found",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: "#/components/schemas/ErrorResponse",
+                            },
+                            example: {
+                                error: "Endpoint not found",
+                                timestamp: "2023-12-01T10:30:00.000Z",
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        tags: [
+            {
+                name: "Health",
+                description: "Health check and status endpoints",
+            },
+            {
+                name: "API",
+                description: "Main API endpoints for MeshCentral integration",
+            },
+            {
+                name: "Core",
+                description: "Core functionality endpoints for device group management",
+            },
+        ],
+    },
+    apis: ["./src/routes/*.ts", "./src/controllers/*.ts"], // Path to the API files
+};
+exports.swaggerSpec = (0, swagger_jsdoc_1.default)(options);

package/dist/controllers/BaseController.d.ts

@@ -0,0 +1,16 @@
+import { Pool } from "pg";
+import WebSocket from "ws";
+import { IServiceContainer } from "../services/ServiceContainer";
+import { Config } from "../types";
+import { IWebSocketService } from "../services/WebSocketService";
+export declare abstract class BaseController {
+    protected serviceContainer: IServiceContainer;
+    constructor(serviceContainer?: IServiceContainer);
+    protected get dbPool(): Pool;
+    protected get webSocket(): WebSocket | null;
+    protected get WebSocketService(): IWebSocketService;
+    protected get config(): Config;
+    protected get isWebSocketConnected(): boolean;
+    protected get meshServer(): string;
+}
+//# sourceMappingURL=BaseController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BaseController.d.ts","sourceRoot":"","sources":["../../src/controllers/BaseController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC1B,OAAO,SAAS,MAAM,IAAI,CAAC;AAC3B,OAAO,EAEL,iBAAiB,EAClB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEjE,8BAAsB,cAAc;IAClC,SAAS,CAAC,gBAAgB,EAAE,iBAAiB,CAAC;gBAElC,gBAAgB,CAAC,EAAE,iBAAiB;IAIhD,SAAS,KAAK,MAAM,IAAI,IAAI,CAE3B;IAED,SAAS,KAAK,SAAS,IAAI,SAAS,GAAG,IAAI,CAE1C;IAED,SAAS,KAAK,gBAAgB,IAAI,iBAAiB,CAElD;IAED,SAAS,KAAK,MAAM,IAAI,MAAM,CAE7B;IAED,SAAS,KAAK,oBAAoB,IAAI,OAAO,CAE5C;IAED,SAAS,KAAK,UAAU,IAAI,MAAM,CAEjC;CACF"}

package/dist/controllers/BaseController.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseController = void 0;
+const ServiceContainer_1 = require("../services/ServiceContainer");
+class BaseController {
+    constructor(serviceContainer) {
+        this.serviceContainer = serviceContainer || ServiceContainer_1.ServiceContainer.getInstance();
+    }
+    get dbPool() {
+        return this.serviceContainer.getDatabaseService().getPool();
+    }
+    get webSocket() {
+        return this.serviceContainer.getWebSocketService().getWebSocket();
+    }
+    get WebSocketService() {
+        return this.serviceContainer.getWebSocketService();
+    }
+    get config() {
+        return this.serviceContainer.getConfig();
+    }
+    get isWebSocketConnected() {
+        return this.serviceContainer.getWebSocketService().isConnected();
+    }
+    get meshServer() {
+        return this.config.meshcentralConfig.server;
+    }
+}
+exports.BaseController = BaseController;

package/dist/controllers/apiController.d.ts

@@ -0,0 +1,8 @@
+import { Request, Response } from "express";
+import { BaseController } from "./BaseController";
+import { IServiceContainer } from "../services/ServiceContainer";
+export declare class ApiController extends BaseController {
+    constructor(serviceContainer?: IServiceContainer);
+    getConnectUrls: (req: Request, res: Response) => Promise<void>;
+}
+//# sourceMappingURL=apiController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apiController.d.ts","sourceRoot":"","sources":["../../src/controllers/apiController.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;AAIjE,qBAAa,aAAc,SAAQ,cAAc;gBACnC,gBAAgB,CAAC,EAAE,iBAAiB;IAIzC,cAAc,GACnB,KAAK,OAAO,EACZ,KAAK,QAAQ,KACZ,OAAO,CAAC,IAAI,CAAC,CAgEd;CACH"}

package/dist/controllers/apiController.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiController = void 0;
+const BaseController_1 = require("./BaseController");
+const utils_1 = require("../lib/utils");
+class ApiController extends BaseController_1.BaseController {
+    constructor(serviceContainer) {
+        super(serviceContainer);
+        this.getConnectUrls = async (req, res) => {
+            var _a;
+            try {
+                const meshNodeId = req.body.meshNodeId;
+                const userId = req.body.userId;
+                if (!meshNodeId || !userId) {
+                    const errorResponse = {
+                        error: "'meshNodeId' or 'userId' are missing in body params",
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(400).json(errorResponse);
+                    return;
+                }
+                const nexus_epm_user_id_query = "SELECT id FROM accounts_user WHERE username= $1";
+                const nexus_epm_user_id = await this.dbPool.query(nexus_epm_user_id_query, [userId]);
+                if (nexus_epm_user_id.rows.length === 0) {
+                    const errorResponse = {
+                        error: `'${userId}' Not Found`,
+                        timestamp: new Date().toISOString(),
+                    };
+                    res.status(400).json(errorResponse);
+                    return;
+                }
+                const meshUser = `user//${userId}___${(_a = nexus_epm_user_id.rows[0]) === null || _a === void 0 ? void 0 : _a.id}`;
+                const loginEncryptionKey = (0, utils_1.getBinaryKey)(this.config.meshcentralConfig.loginEncryptionKey);
+                const authRelayCookie = (0, utils_1.encodeCookie)({ a: 3, u: meshUser }, loginEncryptionKey);
+                const token_param = `login=${authRelayCookie}`;
+                const control = `https://${this.config.meshcentralConfig.server}/?${token_param}&gotonode=${meshNodeId}&viewmode=11&hide=31`;
+                const terminal = `https://${this.config.meshcentralConfig.server}/?${token_param}&gotonode=${meshNodeId}&viewmode=12&hide=31`;
+                const fileSystem = `https://${this.config.meshcentralConfig.server}/?${token_param}&gotonode=${meshNodeId}&viewmode=13&hide=31`;
+                const response = {
+                    control,
+                    terminal,
+                    file: fileSystem,
+                    timestamp: new Date().toISOString(),
+                };
+                res.status(200).json(response);
+                return;
+            }
+            catch (error) {
+                console.error("Error generating connect URLs:", error);
+                const errorResponse = {
+                    error: "Internal server error",
+                    timestamp: new Date().toISOString(),
+                };
+                res.status(500).json(errorResponse);
+                return;
+            }
+        };
+    }
+}
+exports.ApiController = ApiController;