mwc-proxy 0.0.1

package/dist/authEndpoint.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const prismarine_auth_1 = require("prismarine-auth");
+const yggdrasil_1 = __importDefault(require("yggdrasil"));
+const debug_1 = __importDefault(require("debug"));
+const metrics_1 = require("./metrics");
+const yggdrasilServer = yggdrasil_1.default.server({ host: 'https://sessionserver.mojang.com' });
+class FakeFileCache {
+    cacheName;
+    sharedCache;
+    cache;
+    constructor(cacheName, initial, sharedCache) {
+        this.cacheName = cacheName;
+        this.sharedCache = sharedCache;
+        this.cache = initial;
+    }
+    async loadInitialValue() {
+        return {};
+    }
+    async getCached() {
+        if (this.cache === undefined) {
+            this.cache = await this.loadInitialValue();
+        }
+        return this.cache;
+    }
+    async setCached(cached) {
+        this.cache = cached;
+        this.sharedCache[this.cacheName] = cached;
+    }
+    async setCachedPartial(cached) {
+        await this.setCached({
+            ...this.cache,
+            ...cached,
+        });
+    }
+}
+exports.default = (app, authTokensEndpoint = '/', sessionServerProxy = '/session', authLog = (str) => { }, urlRoot = '', options = {}) => {
+    const authActiveConnections = new Map();
+    const maxPerIp = options.authMaxConcurrentPerIp ?? 2;
+    const maxTotal = options.authMaxConcurrentTotal ?? 5;
+    if (options.authToggleDebugEndpoint) {
+        const endpoint = typeof options.authToggleDebugEndpoint === 'string' ? `${urlRoot}/${options.authToggleDebugEndpoint}` : `${urlRoot}/toggle-debug`;
+        app.get(endpoint, (req, res) => {
+            const SCOPES = ['prismarine-auth'];
+            if (debug_1.default.enabled(SCOPES.join(','))) {
+                debug_1.default.disable();
+                return res.send('Debug disabled');
+            }
+            debug_1.default.enable(SCOPES.join(','));
+            return res.send('Debug enabled');
+        });
+    }
+    app.use((req, res, next) => {
+        if (req.path === authTokensEndpoint && req.method === 'POST') {
+            const { ip } = req;
+            const currentCount = authActiveConnections.get(ip) || 0;
+            if (currentCount >= maxPerIp) {
+                res.status(429).send('Too many requests from this IP, please slow down.');
+                return;
+            }
+            const totalConnections = [...authActiveConnections.values()].reduce((acc, val) => acc + val, 0);
+            if (totalConnections >= maxTotal) {
+                res.status(429).send('Server is busy with other requests, please try again later.');
+                return;
+            }
+            authActiveConnections.set(ip, currentCount + 1);
+            res.on('close', () => {
+                // console.log('close auth req')
+                const currentCount = authActiveConnections.get(ip) || 0;
+                authActiveConnections.set(ip, currentCount - 1);
+            });
+            next();
+        }
+        next();
+    });
+    app.post(authTokensEndpoint, async (req, res) => {
+        const sendString = (string) => {
+            res.write(`${string}\n\n`);
+            //@ts-expect-error
+            res.flush();
+        };
+        try {
+            const cachesAndOptions = req.body;
+            authLog(`Starting auth request: ${cachesAndOptions.connectingServer} ${cachesAndOptions.connectingServerVersion} ${req.ip} ${req.headers.origin}`);
+            // from minecraft-protocol, for easier testing
+            const bannedServers = ['mc.hypixel.net', 'hypixel.net'];
+            if (cachesAndOptions.connectingServer && bannedServers.includes(cachesAndOptions.connectingServer)) {
+                res.status(403).send({
+                    error: 'Server is not supported yet. If you interested, please let us know in the discord.',
+                });
+                return;
+            }
+            if (!cachesAndOptions.flow) {
+                cachesAndOptions.authTitle = prismarine_auth_1.Titles.MinecraftNintendoSwitch;
+                cachesAndOptions.deviceType = 'Nintendo';
+                cachesAndOptions.flow = 'live';
+            }
+            const newCache = {};
+            // Set headers for SSE
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            const authflow = new prismarine_auth_1.Authflow('', 
+            //@ts-expect-error
+            ({ cacheName, username }) => new FakeFileCache(cacheName, cachesAndOptions[cacheName], newCache), {
+                flow: cachesAndOptions.flow,
+                msalConfig: cachesAndOptions.msalConfig,
+                authTitle: cachesAndOptions.authTitle,
+                deviceType: cachesAndOptions.deviceType,
+                deviceVersion: cachesAndOptions.deviceVersion,
+            }, data => {
+                sendString(`${JSON.stringify(data)}`);
+                setTimeout(() => {
+                    res.end();
+                }, data.expires_in * 1000);
+            });
+            // Send an event to the client
+            sendString(`data: ${JSON.stringify({ message: 'Hello from the authentication server! Starting your request now.' })}`);
+            // Keep the connection open by sending a comment every 5 seconds
+            const interval = setInterval(() => {
+                sendString(`: ${new Date().toISOString()}`);
+            }, 5000);
+            res.on('close', () => {
+                res.end();
+                clearInterval(interval);
+                //@ts-expect-error
+                const { msa } = authflow;
+                if (msa) {
+                    msa.polling = false;
+                }
+            });
+            const tokenData = await authflow.getMinecraftJavaToken({
+                fetchCertificates: true,
+                fetchProfile: true,
+                ...cachesAndOptions.getJavaTokenOptions,
+            });
+            transformAllKeysDeep(tokenData);
+            sendString(`${JSON.stringify({ newCache })}`);
+            sendString(`${JSON.stringify(tokenData)}`);
+            // profileKeys.public.export
+            sendString('data: {"message": "Request complete. Bye!"}');
+            authLog(`Auth request complete: ${Object.keys(tokenData).join(', ')}; ${Object.keys(newCache).join(', ')}`);
+            metrics_1.updateMetrics.recordAuthRequest(true);
+            res.end();
+        }
+        catch (e) {
+            try {
+                console.error(e);
+                sendString(`${JSON.stringify({ error: e.message })}`);
+                res.status(500).send({
+                    error: e.message,
+                });
+                metrics_1.updateMetrics.recordAuthRequest(false);
+                res.end();
+            }
+            catch { }
+        }
+    });
+    app.post(sessionServerProxy, async (req, res) => {
+        try {
+            authLog(`Join request received`);
+            yggdrasilServer.join(req.body.accessToken, req.body.selectedProfile, req.body.serverId, new Uint8Array(req.body.sharedSecret.data), new Uint8Array(req.body.publicKey.data), err => {
+                if (err) {
+                    console.error(err);
+                    return res.status(403).send({
+                        error: err.message,
+                    });
+                }
+                return res.status(204).send();
+            });
+        }
+        catch (err) {
+            console.error(err);
+            try {
+                res.status(500).send({
+                    error: err.message,
+                });
+            }
+            catch { }
+        }
+    });
+};
+const transformAllKeysDeep = obj => {
+    if (typeof obj !== 'object' || obj === null)
+        return obj;
+    const keys = Object.keys(obj);
+    const result = {};
+    for (const key of keys) {
+        const value = obj[key];
+        if (value instanceof crypto_1.KeyObject) {
+            const isPrivate = value.type === 'private';
+            result[key] = value.export({
+                format: 'der',
+                type: isPrivate ? 'pkcs8' : 'spki',
+            });
+        }
+        transformAllKeysDeep(value);
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * minecraft-web-proxy — library entry point
+ *
+ * Import from here when using this package as a library (npm) or when building
+ * a custom server (like src-mwc). Zero side-effects: nothing starts, nothing
+ * listens. See src/app.ts for the standalone CLI/Docker entry.
+ */
+export { createProxyMiddleware, currentState, parseSocksProxy } from './api';
+export type { ProxyMiddlewareOptions } from './api';
+export { SignalClient } from './signal-client';
+export type { SignalClientOptions } from './signal-client';
+//# 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":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,OAAO,CAAA;AAC5E,YAAY,EAAE,sBAAsB,EAAE,MAAM,OAAO,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * minecraft-web-proxy — library entry point
+ *
+ * Import from here when using this package as a library (npm) or when building
+ * a custom server (like src-mwc). Zero side-effects: nothing starts, nothing
+ * listens. See src/app.ts for the standalone CLI/Docker entry.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalClient = exports.parseSocksProxy = exports.currentState = exports.createProxyMiddleware = void 0;
+var api_1 = require("./api");
+Object.defineProperty(exports, "createProxyMiddleware", { enumerable: true, get: function () { return api_1.createProxyMiddleware; } });
+Object.defineProperty(exports, "currentState", { enumerable: true, get: function () { return api_1.currentState; } });
+Object.defineProperty(exports, "parseSocksProxy", { enumerable: true, get: function () { return api_1.parseSocksProxy; } });
+var signal_client_1 = require("./signal-client");
+Object.defineProperty(exports, "SignalClient", { enumerable: true, get: function () { return signal_client_1.SignalClient; } });

package/dist/metrics.d.ts

@@ -0,0 +1,18 @@
+import promBundle from 'express-prom-bundle';
+export declare const systemMetrics: {
+    cpuUsage: any;
+    memoryUsage: any;
+    processMemory: any;
+};
+export declare const activeConnectionsGauge: any;
+export declare const totalConnectionsCounter: any;
+export declare const authRequestsCounter: any;
+export declare const connectionDurationGauge: any;
+export declare const metricsMiddleware: promBundle.Middleware;
+export declare const updateMetrics: {
+    addConnection(): void;
+    removeConnection(): void;
+    recordAuthRequest(success: boolean): void;
+    updateConnectionDuration(token: string, duration: number, host: string, ip: string): void;
+};
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../src/metrics.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,qBAAqB,CAAA;AAsC5C,eAAO,MAAM,aAAa;;;;CAoDzB,CAAA;AAGD,eAAO,MAAM,sBAAsB,KAIjC,CAAA;AAEF,eAAO,MAAM,uBAAuB,KAIlC,CAAA;AAEF,eAAO,MAAM,mBAAmB,KAK9B,CAAA;AAEF,eAAO,MAAM,uBAAuB,KAKlC,CAAA;AAGF,eAAO,MAAM,iBAAiB,uBAQ5B,CAAA;AAGF,eAAO,MAAM,aAAa;;;+BAgBK,OAAO;oCAOF,MAAM,YAAY,MAAM,QAAQ,MAAM,MAAM,MAAM;CAOrF,CAAA"}

package/dist/metrics.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateMetrics = exports.metricsMiddleware = exports.connectionDurationGauge = exports.authRequestsCounter = exports.totalConnectionsCounter = exports.activeConnectionsGauge = exports.systemMetrics = void 0;
+const os_1 = __importDefault(require("os"));
+const express_prom_bundle_1 = __importDefault(require("express-prom-bundle"));
+const prom_client_1 = require("prom-client");
+// Create a new registry
+const register = new prom_client_1.Registry();
+// Enable collection of default metrics with custom prefix and error handling
+try {
+    (0, prom_client_1.collectDefaultMetrics)({
+        register,
+        prefix: 'minecraft_proxy_',
+        gcDurationBuckets: [0.001, 0.01, 0.1, 1, 2, 5],
+    });
+}
+catch (error) {
+    console.error('Error collecting default metrics:', error);
+}
+// Safely create and manage metrics
+const createMetric = (MetricClass, config) => {
+    try {
+        return new MetricClass(config);
+    }
+    catch (error) {
+        console.error(`Error creating metric ${config.name}:`, error);
+        // Return a dummy metric that won't crash on operations
+        return {
+            inc() { },
+            dec() { },
+            set() { },
+            labels: () => ({
+                inc() { },
+                dec() { },
+                set() { },
+            }),
+        };
+    }
+};
+// System metrics with error handling
+exports.systemMetrics = {
+    cpuUsage: createMetric(prom_client_1.Gauge, {
+        name: 'minecraft_proxy_cpu_usage_percentage',
+        help: 'CPU usage percentage',
+        registers: [register],
+        collect() {
+            try {
+                const cpus = os_1.default.cpus();
+                const totalCpuTime = cpus.reduce((acc, cpu) => acc + Object.values(cpu.times).reduce((sum, time) => sum + time, 0), 0);
+                const idleTime = cpus.reduce((acc, cpu) => acc + cpu.times.idle, 0);
+                const usagePercentage = ((totalCpuTime - idleTime) / totalCpuTime) * 100;
+                this.set(usagePercentage);
+            }
+            catch (error) {
+                console.error('Error collecting CPU metrics:', error);
+            }
+        }
+    }),
+    memoryUsage: createMetric(prom_client_1.Gauge, {
+        name: 'minecraft_proxy_memory_usage_bytes',
+        help: 'Memory usage in bytes',
+        registers: [register],
+        labelNames: ['type'],
+        collect() {
+            try {
+                const used = os_1.default.totalmem() - os_1.default.freemem();
+                this.set({ type: 'total' }, os_1.default.totalmem());
+                this.set({ type: 'free' }, os_1.default.freemem());
+                this.set({ type: 'used' }, used);
+            }
+            catch (error) {
+                console.error('Error collecting memory metrics:', error);
+            }
+        }
+    }),
+    processMemory: createMetric(prom_client_1.Gauge, {
+        name: 'minecraft_proxy_process_memory_bytes',
+        help: 'Process memory usage in bytes',
+        registers: [register],
+        labelNames: ['type'],
+        collect() {
+            try {
+                const usage = process.memoryUsage();
+                this.set({ type: 'rss' }, usage.rss);
+                this.set({ type: 'heapTotal' }, usage.heapTotal);
+                this.set({ type: 'heapUsed' }, usage.heapUsed);
+                this.set({ type: 'external' }, usage.external);
+            }
+            catch (error) {
+                console.error('Error collecting process memory metrics:', error);
+            }
+        }
+    })
+};
+// Custom metrics with proper label definitions
+exports.activeConnectionsGauge = createMetric(prom_client_1.Gauge, {
+    name: 'minecraft_proxy_active_connections',
+    help: 'Number of active connections',
+    registers: [register],
+});
+exports.totalConnectionsCounter = createMetric(prom_client_1.Counter, {
+    name: 'minecraft_proxy_total_connections',
+    help: 'Total number of connections ever made',
+    registers: [register],
+});
+exports.authRequestsCounter = createMetric(prom_client_1.Counter, {
+    name: 'minecraft_proxy_auth_requests_total',
+    help: 'Total number of authentication requests',
+    labelNames: ['status'],
+    registers: [register],
+});
+exports.connectionDurationGauge = createMetric(prom_client_1.Gauge, {
+    name: 'minecraft_proxy_connection_duration_seconds',
+    help: 'Duration of connections in seconds',
+    labelNames: ['token', 'host', 'ip'],
+    registers: [register],
+});
+// Express middleware with error handling
+exports.metricsMiddleware = (0, express_prom_bundle_1.default)({
+    includeMethod: true,
+    includePath: true,
+    promRegistry: register,
+    normalizePath: [
+        ['^/api/vm/net/.*', '/api/vm/net/#endpoint']
+    ],
+    buckets: [0.1, 0.5, 1, 2, 5],
+});
+// Safe metric update functions
+exports.updateMetrics = {
+    addConnection() {
+        try {
+            exports.activeConnectionsGauge.inc();
+            exports.totalConnectionsCounter.inc();
+        }
+        catch (error) {
+            console.error('Error updating connection metrics:', error);
+        }
+    },
+    removeConnection() {
+        try {
+            exports.activeConnectionsGauge.dec();
+        }
+        catch (error) {
+            console.error('Error updating connection metrics:', error);
+        }
+    },
+    recordAuthRequest(success) {
+        try {
+            exports.authRequestsCounter.inc({ status: success ? 'success' : 'failure' });
+        }
+        catch (error) {
+            console.error('Error updating auth metrics:', error);
+        }
+    },
+    updateConnectionDuration(token, duration, host, ip) {
+        try {
+            exports.connectionDurationGauge.set({ token, host, ip }, duration);
+        }
+        catch (error) {
+            console.error('Error updating duration metrics:', error);
+        }
+    }
+};
+// Initialize frequent CPU metrics collection
+// setInterval(() => {
+//     try {
+//         systemMetrics.cpuUsage.collect()
+//     } catch (error) {
+//         console.error('Error collecting CPU metrics:', error)
+//     }
+// }, 2000) // Update every 2 seconds

package/dist/signal-client.d.ts

@@ -0,0 +1,32 @@
+export type SignalClientOptions = {
+    enabled: boolean;
+    signalServerUrl: string;
+    description?: string;
+    domain?: string;
+    acknowledgeInterval?: number;
+    /** Port this proxy listens on; when set, self-check (public IP + loop request) runs before reporting */
+    listenPort?: number;
+    /** URL path prefix for self-check request (e.g. /api/vm/net) */
+    urlRoot?: string;
+    getSystemInfo?: () => {
+        cpuLoad?: number;
+        ramLoad?: number;
+        connectedPlayers?: number;
+    };
+};
+export declare class SignalClient {
+    private readonly options;
+    private intervalId?;
+    private backoffUntil;
+    private selfCheckPassed;
+    private selfCheckDone;
+    constructor(options: Partial<SignalClientOptions>);
+    private runSelfCheckAndStart;
+    private getPublicIp;
+    private selfCheckLoop;
+    private start;
+    private sendAcknowledgment;
+    stop(): void;
+    isEnabled(): boolean;
+}
+//# sourceMappingURL=signal-client.d.ts.map

package/dist/signal-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-client.d.ts","sourceRoot":"","sources":["../src/signal-client.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,mBAAmB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,wGAAwG;IACxG,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,MAAM;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAC5B,CAAA;CACJ,CAAA;AAED,qBAAa,YAAY;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,UAAU,CAAC,CAAgB;IACnC,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,aAAa,CAAQ;gBAEjB,OAAO,EAAE,OAAO,CAAC,mBAAmB,CAAC;YAuBnC,oBAAoB;YA6BpB,WAAW;IAQzB,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,kBAAkB;IA+D1B,IAAI;IAOJ,SAAS,IAAI,OAAO;CAGvB"}

package/dist/signal-client.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalClient = void 0;
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const public_ip_1 = require("public-ip");
+const SELF_CHECK_TIMEOUT_MS = 8000;
+const BACKOFF_AFTER_502_MS = 5 * 60 * 1000; // 5 minutes
+class SignalClient {
+    options;
+    intervalId;
+    backoffUntil = 0;
+    selfCheckPassed = false;
+    selfCheckDone = false;
+    constructor(options) {
+        this.options = {
+            enabled: options.enabled ?? true,
+            signalServerUrl: options.signalServerUrl ?? 'https://signal.mcraft.fun',
+            description: options.description,
+            domain: options.domain,
+            acknowledgeInterval: options.acknowledgeInterval ?? 10_000,
+            listenPort: options.listenPort,
+            urlRoot: options.urlRoot ?? '/api/vm/net',
+            getSystemInfo: options.getSystemInfo,
+        };
+        if (this.options.enabled) {
+            if (this.options.listenPort != null) {
+                this.runSelfCheckAndStart();
+            }
+            else {
+                this.selfCheckPassed = true;
+                this.selfCheckDone = true;
+                this.start();
+            }
+        }
+    }
+    async runSelfCheckAndStart() {
+        const port = this.options.listenPort;
+        const urlRoot = (this.options.urlRoot ?? '').replace(/\/$/, '');
+        try {
+            const publicIp = await this.getPublicIp();
+            if (!publicIp) {
+                console.warn('Signal: could not get public IP, skipping signal server integration');
+                this.selfCheckDone = true;
+                return;
+            }
+            const ok = await this.selfCheckLoop(publicIp, port, urlRoot);
+            this.selfCheckDone = true;
+            if (!ok) {
+                console.warn(`Signal: self-check failed (not reachable at ${publicIp}:${port}), skipping signal server integration`);
+                return;
+            }
+            this.selfCheckPassed = true;
+            this.start();
+        }
+        catch (err) {
+            this.selfCheckDone = true;
+            console.warn('Signal: self-check failed:', err.message);
+        }
+    }
+    async getPublicIp() {
+        try {
+            return await (0, public_ip_1.publicIpv4)();
+        }
+        catch {
+            return null;
+        }
+    }
+    selfCheckLoop(publicIp, port, urlRoot) {
+        return new Promise((resolve) => {
+            const path = `${urlRoot}/connect`;
+            const url = `http://${publicIp}:${port}${path}`;
+            const req = http_1.default.get(url, (res) => {
+                if (res.statusCode === 502) {
+                    resolve(false);
+                    return;
+                }
+                resolve(res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 500);
+            });
+            req.on('error', () => resolve(false));
+            req.setTimeout(SELF_CHECK_TIMEOUT_MS, () => {
+                req.destroy();
+                resolve(false);
+            });
+        });
+    }
+    start() {
+        console.log(`Signal Server integration enabled, reporting to ${this.options.signalServerUrl}`);
+        this.sendAcknowledgment();
+        this.intervalId = setInterval(() => {
+            this.sendAcknowledgment();
+        }, this.options.acknowledgeInterval);
+    }
+    sendAcknowledgment() {
+        if (!this.options.enabled || !this.selfCheckPassed)
+            return;
+        if (Date.now() < this.backoffUntil)
+            return;
+        const params = new URLSearchParams();
+        if (this.options.description) {
+            params.append('description', this.options.description);
+        }
+        if (this.options.domain) {
+            params.append('domain', this.options.domain);
+        }
+        const info = this.options.getSystemInfo?.();
+        if (info?.connectedPlayers !== undefined) {
+            params.append('players', info.connectedPlayers.toString());
+        }
+        if (info?.cpuLoad !== undefined) {
+            params.append('cpuLoad', info.cpuLoad.toString());
+        }
+        if (info?.ramLoad !== undefined) {
+            params.append('ramLoad', info.ramLoad.toString());
+        }
+        const url = `${this.options.signalServerUrl}/api/acknowledge?${params.toString()}`;
+        const protocol = this.options.signalServerUrl.startsWith('https') ? https_1.default : http_1.default;
+        const req = protocol.get(url, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                if (res.statusCode === 502) {
+                    this.backoffUntil = Date.now() + BACKOFF_AFTER_502_MS;
+                    console.warn(`Signal server returned 502, stopping reports for ${BACKOFF_AFTER_502_MS / 60000} minutes`);
+                    return;
+                }
+                if (res.statusCode === 200) {
+                    try {
+                        const response = JSON.parse(data);
+                        if (response.ok && response.approved) {
+                            // Successfully acknowledged
+                        }
+                    }
+                    catch (err) {
+                        console.error('Failed to parse signal server response:', err);
+                    }
+                }
+                else {
+                    console.error(`Signal server returned status ${res.statusCode}: ${data}`);
+                }
+            });
+        });
+        req.on('error', (err) => {
+            console.error('Failed to send acknowledgment to signal server:', err.message);
+        });
+        req.setTimeout(5000, () => {
+            req.destroy();
+            console.error('Signal server acknowledgment timed out');
+        });
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    isEnabled() {
+        return this.options.enabled;
+    }
+}
+exports.SignalClient = SignalClient;