mwc-proxy 0.0.1

package/dist/api.js

@@ -0,0 +1,526 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSocksProxy = exports.currentState = void 0;
+exports.createProxyMiddleware = createProxyMiddleware;
+const net_1 = __importStar(require("net"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const express_1 = __importDefault(require("express"));
+const express_ws_1 = __importDefault(require("express-ws"));
+const socks_1 = require("socks");
+const authEndpoint_1 = __importDefault(require("./authEndpoint"));
+const metrics_1 = require("./metrics");
+const signal_client_1 = require("./signal-client");
+// Import version from package.json
+const packageJson = require('../package.json');
+const VERSION = packageJson.version;
+function generateToken() {
+    return crypto_1.default.randomBytes(32).toString('hex');
+}
+function checkTo(allowed, requested) {
+    if (!Array.isArray(allowed)) {
+        allowed = [allowed];
+    }
+    // For each rule
+    for (const to of allowed) {
+        if ((to.host === requested.host || !to.host) && (to.port === requested.port || !to.port)) {
+            return !to.blacklist;
+        }
+    }
+    // No rule found, access denied
+    return false;
+}
+exports.currentState = {
+    activeConnections: {},
+    pendingConnections: {},
+    everConnected: 0,
+};
+function ipToNumber(ip) {
+    if ((0, net_1.isIPv4)(ip)) {
+        const parts = ip.split('.');
+        let result = 0;
+        for (const part of parts) {
+            result = result * 256 + Number.parseInt(part, 10);
+        }
+        return BigInt(result);
+    }
+    // IPv6
+    const parts = ip.split(':').filter(part => part !== '');
+    let result = BigInt(0);
+    for (const part of parts) {
+        // eslint-disable-next-line no-bitwise
+        result = (result << BigInt(16)) + BigInt(`0x${part}`);
+    }
+    return result;
+}
+const getProxy = (proxies, requestIp) => {
+    const index = Number(ipToNumber(requestIp) % BigInt(proxies.length));
+    return proxies[index];
+};
+function createProxyMiddleware(options = {}, connectionListener = ws => { }) {
+    const startTimeFormmated = new Intl.DateTimeFormat('en', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: 'numeric',
+    }).format(new Date());
+    let myLog = typeof options.log === 'function' ? options.log : () => { };
+    if (options.log === true)
+        myLog = console.log;
+    const app = (0, express_1.default)();
+    app.use(express_1.default.urlencoded({ extended: true }));
+    app.use(express_1.default.json());
+    if (options.metricsEndpoint !== false) {
+        app.use(metrics_1.metricsMiddleware);
+    }
+    const urlRoot = options.urlRoot ?? '/api/vm/net';
+    let server = options.server;
+    if (!server) {
+        if (options.https) {
+            const key = fs_1.default.readFileSync(path_1.default.join(__dirname, './key.pem'));
+            const cert = fs_1.default.readFileSync(path_1.default.join(__dirname, './cert.pem'));
+            server = https_1.default.createServer({
+                key,
+                cert,
+            });
+        }
+        else {
+            server = http_1.default.createServer();
+        }
+    }
+    const sockets = {};
+    if (options.allowOrigin) {
+        let { allowOrigin } = options;
+        if (typeof options.allowOrigin !== 'string') {
+            allowOrigin = options.allowOrigin ? '*' : '';
+        }
+        if (allowOrigin) {
+            // Set Access-Control headers (CORS)
+            app.use((req, res, next) => {
+                if (!req.path.startsWith(urlRoot) && !options.allowOriginApp) {
+                    next();
+                    return;
+                }
+                res.header('Access-Control-Allow-Origin', allowOrigin);
+                if (req.method.toUpperCase() === 'OPTIONS') {
+                    // Preflighted requests
+                    res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+                    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+                    res.header('Access-Control-Max-Age', '1_728_000'); // Access-Control headers cached for 20 days
+                }
+                next();
+            });
+        }
+    }
+    const processConnectionRequest = async (req, res, proxies, connectionTimeLimit) => {
+        // Generate unique request ID for tracking pending connections
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(7)}`;
+        const cleanupPendingConnection = () => {
+            delete exports.currentState.pendingConnections[requestId];
+        };
+        try {
+            const { host, port } = req.body;
+            if (!host || !port) {
+                res.status(400).send({
+                    code: 400,
+                    error: 'No host and port specified',
+                });
+                return;
+            }
+            if (options.to && !checkTo(options.to, { host, port })) {
+                res.status(403).send({
+                    code: 403,
+                    error: 'Destination not allowed',
+                });
+                return;
+            }
+            const { activeConnections, pendingConnections } = exports.currentState;
+            const ip = 
+            // (req.headers['cf-connecting-ip'] as string | undefined) ||
+            req.headers['x-forwarded-for']?.split?.(',')?.[0] || req.connection?.remoteAddress || req.socket.remoteAddress || req.ip;
+            const isIpv6 = ip.includes(':');
+            // Count both active and pending connections to prevent race condition exploitation
+            const activeCount = Object.values(activeConnections).filter(c => c.ip === ip).length;
+            const pendingCount = Object.values(pendingConnections).filter(c => c.ip === ip).length;
+            const totalCount = activeCount + pendingCount;
+            const maxConnections = options.maxConnectionsPerIp ?? 5;
+            if (totalCount >= maxConnections) {
+                const errorMessage = options.mwcCallbacks?.getTooManyConnectionsMessage
+                    ? options.mwcCallbacks.getTooManyConnectionsMessage(totalCount, maxConnections)
+                    : `Too many connections from the same IP (${totalCount}/${maxConnections}). Please wait for existing connections to close.`;
+                res.status(429).send({
+                    code: 429,
+                    error: errorMessage,
+                });
+                return;
+            }
+            // Register this as a pending connection
+            exports.currentState.pendingConnections[requestId] = {
+                ip,
+                startTime: Date.now(),
+            };
+            // Clean up pending connection on response close/error
+            res.on('close', cleanupPendingConnection);
+            res.on('finish', cleanupPendingConnection);
+            // Safety timeout: clean up pending connection after 30 seconds if still pending
+            const pendingTimeout = setTimeout(() => {
+                cleanupPendingConnection();
+            }, 30_000);
+            res.on('close', () => clearTimeout(pendingTimeout));
+            res.on('finish', () => clearTimeout(pendingTimeout));
+            if (isIpv6 && options.allowIPv6 === false) {
+                res.status(403).send({
+                    code: 403,
+                    error: 'IPv6 not allowed',
+                });
+                return;
+            }
+            const lang = req.headers['accept-language']?.split(',')[0];
+            const logC = (addStr = '') => {
+                myLog(`[C]${addStr} ${host}:${port} from ${ip} (${lang})`);
+            };
+            let socket;
+            const connectTimeout = 1000 * 8;
+            if (proxies) {
+                const proxy = getProxy(proxies, ip);
+                logC(` ${proxies.indexOf(proxy)}`);
+                ({ socket } = await socks_1.SocksClient.createConnection({
+                    proxy: (0, exports.parseSocksProxy)(proxy),
+                    command: 'connect',
+                    destination: {
+                        host,
+                        port: Number(port),
+                    },
+                    timeout: connectTimeout,
+                }));
+            }
+            else {
+                logC();
+                socket = net_1.default.connect({
+                    host,
+                    port: Number(port),
+                    timeout: connectTimeout,
+                });
+            }
+            socket.setTimeout(1000 * 6);
+            socket.on('timeout', () => {
+                cleanupPendingConnection();
+                if (!res.finished) {
+                    res.status(504).send({
+                        code: 504,
+                        error: `Connection timed out. Ensure the server ${host} is reachable and the port ${port} is open.`
+                    });
+                }
+                socket.end();
+            });
+            socket.on('error', err => {
+                cleanupPendingConnection();
+                if (res.headersSent)
+                    return;
+                res.status(500).send({
+                    code: 500,
+                    error: err,
+                });
+            });
+            socket.on('connect', () => {
+                cleanupPendingConnection();
+                if (res.headersSent) {
+                    socket.end();
+                    return;
+                }
+                // Generate a token for this connection
+                const token = generateToken();
+                sockets[token] = socket;
+                exports.currentState.everConnected++;
+                activeConnections[token] = {
+                    startTime: Date.now(),
+                    ip,
+                    host,
+                };
+                metrics_1.updateMetrics.addConnection();
+                // Notify MWC of connection change if available
+                if (options.mwcCallbacks?.onConnectionChange) {
+                    options.mwcCallbacks.onConnectionChange(Object.keys(activeConnections).length);
+                }
+                // Remove the socket from the list when closed
+                socket.on('close', hadError => {
+                    myLog(`[D${hadError ? '-E' : ''}] ${host}:${port} (${activeConnections[token] && (Date.now() - activeConnections[token].startTime) / 1000}, ${token})`);
+                    if (sockets[token]) {
+                        const duration = (Date.now() - activeConnections[token].startTime) / 1000;
+                        const connectionInfo = activeConnections[token];
+                        metrics_1.updateMetrics.updateConnectionDuration(token, duration, host, connectionInfo.ip);
+                        metrics_1.updateMetrics.removeConnection();
+                        delete sockets[token];
+                        delete activeConnections[token];
+                        // Notify MWC of connection change if available
+                        if (options.mwcCallbacks?.onConnectionChange) {
+                            options.mwcCallbacks.onConnectionChange(Object.keys(activeConnections).length);
+                        }
+                    }
+                });
+                const { origin } = req.headers;
+                // todo also print username
+                myLog(`[U] ${req.body.host}:${req.body.port} ${origin} (${token})`);
+                const remote = socket.address();
+                res.send({
+                    token,
+                    remote,
+                });
+            });
+            const timeout = connectionTimeLimit
+                ? setTimeout(() => {
+                    // todo warn first!
+                    setTimeout(() => {
+                        socket.end();
+                    }, 1000 * 200);
+                }, connectionTimeLimit)
+                : undefined;
+            socket.on('close', () => {
+                if (timeout)
+                    clearTimeout(timeout);
+            });
+            if (proxies) {
+                // socksclient already gives us a connected socket
+                socket.emit('connect');
+            }
+            socket.on('error', (err) => {
+                cleanupPendingConnection();
+                if (res.writableEnded) {
+                    myLog(`Socket error after response closed: ${err}`);
+                    return;
+                }
+                res.status(502).send({
+                    code: 502,
+                    error: `Socket error: ${err.code}`,
+                    details: err,
+                });
+            });
+            if (connectionListener) {
+                connectionListener(socket);
+            }
+        }
+        catch (err) {
+            // mainly for socks awaiting
+            cleanupPendingConnection();
+            try {
+                res.status(500).send({
+                    code: 500,
+                    error: err.message,
+                });
+            }
+            catch { }
+        }
+    };
+    app.post(`${urlRoot}/connect`, async (req, res) => {
+        // Allow MWC to handle request with custom routing logic
+        if (options.mwcCallbacks?.handleConnectionRequest) {
+            const handled = await options.mwcCallbacks.handleConnectionRequest(req, res, async (proxies, timeLimit) => {
+                await processConnectionRequest(req, res, proxies, timeLimit);
+            });
+            if (handled)
+                return;
+        }
+        // Default: normal connection with no proxies
+        const timeLimit = 1000 * 60 * 60 * 12; // 12 hours
+        await processConnectionRequest(req, res, undefined, timeLimit);
+    });
+    if (options.debugUrlEndpoint !== false) {
+        app.get(`${urlRoot}/debug`, (req, res) => {
+            const headers = Object.entries(req.headers);
+            // print full request url including host + query params
+            res.send(`<pre>${req.protocol}://${req.get('host')}${req.originalUrl}\n\n${headers.map(([key, value]) => `${key}: ${value}`).join('\n')}</pre>`);
+        });
+    }
+    const authEndpoint = `${urlRoot}/auth`;
+    const sessionEndpoint = `${urlRoot}/session`;
+    app.get(`${urlRoot}/connect`, (req, res) => {
+        const json = {
+            version: VERSION,
+            capabilities: {
+                authEndpoint,
+                sessionEndpoint,
+                // ping: true
+            },
+        };
+        // Add custom data from MWC callbacks if available
+        if (options.mwcCallbacks?.getConnectData) {
+            const customData = options.mwcCallbacks.getConnectData();
+            Object.assign(json, customData);
+        }
+        res.send(json);
+    });
+    app.get(`${urlRoot}/connections`, (req, res) => {
+        const accessCodeQs = req.query.code;
+        const basicInfo = [
+            `Ever connected since ${startTimeFormmated}: ${exports.currentState.everConnected}`,
+            `Live: ${Object.keys(exports.currentState.activeConnections).length}`,
+        ];
+        if (!process.env.ACCESS_CODE || accessCodeQs !== process.env.ACCESS_CODE) {
+            try {
+                res.status(403).send({
+                    code: 403,
+                    error: 'Access code required',
+                    basicInfo,
+                });
+            }
+            catch { }
+            return;
+        }
+        const stateFormatted = [
+            ...Object.entries(exports.currentState.activeConnections).map(([token, { startTime, ip, host }], i) => `${i + 1}. (${(Date.now() - startTime) / 1000}s): ${ip} -> ${host}`),
+            ...basicInfo,
+        ].join('\n');
+        res.send(stateFormatted);
+    });
+    (0, authEndpoint_1.default)(app, authEndpoint, sessionEndpoint, str => myLog(str), urlRoot, options);
+    const wss = (0, express_ws_1.default)(app, server);
+    const appUntyhped = app;
+    appUntyhped.ws(`${urlRoot}/ping`, (ws, req) => {
+        try {
+            if (options.onPing) {
+                options.onPing(req);
+            }
+            ws.on('message', (data) => {
+                if (typeof data === 'string' && data.startsWith('ping:')) {
+                    const startTime = process.hrtime();
+                    const pingId = data.slice('ping:'.length);
+                    ws.send(`pong:${pingId}:${process.hrtime(startTime)[1] / 1_000_000}`, () => { });
+                }
+            });
+        }
+        catch {
+            // console.error('Error handling ping WebSocket connection:', err)
+        }
+    });
+    appUntyhped.ws(`${urlRoot}/socket`, (ws, req) => {
+        const { token } = req.query;
+        if (!sockets[token]) {
+            console.warn(`WARN: Unknown TCP connection with token "${token}"`);
+            ws.close();
+            return;
+        }
+        const socket = sockets[token];
+        //delete sockets[token];
+        // myLog(`Forwarding socket with token ${token}`)
+        ws.on('message', data => {
+            if (typeof data === 'string' && data.startsWith('ping:')) {
+                ws.send(`pong:${data.slice('ping:'.length)}`);
+                return;
+            }
+            socket.write(data, 'binary', () => {
+                //myLog('Sent: ', data.toString());
+            });
+        });
+        socket.on('data', chunk => {
+            //myLog('Received: ', chunk.toString());
+            // Providing a callback is important, otherwise errors can be thrown
+            ws.send(chunk, { binary: true }, err => { });
+        });
+        socket.on('end', () => {
+            // myLog(`TCP connection closed by remote (${token})`)
+            ws.close();
+        });
+        socket.on('error', err => {
+            const message = err.code === 'EADDRNOTAVAIL' ? 'Minecraft server is not reachable anymore.' : `Issue with the connection to the Minecraft server: ${err.message}`;
+            ws.send(`proxy-shutdown:${message}`, () => { });
+        });
+        ws.on('close', () => {
+            socket.end();
+            // myLog(`Websocket connection closed (${token})`)
+        });
+    });
+    app.on('mount', parentApp => {
+        // @see https://github.com/strongloop/express/blob/master/lib/application.js#L615
+        parentApp.listen = function () {
+            server.addListener('request', this);
+            // eslint-disable-next-line prefer-spread, prefer-rest-params
+            return server.listen.apply(server, arguments);
+        };
+    });
+    if (options.signal) {
+        const signalOpts = options.signal;
+        const signalClient = new signal_client_1.SignalClient({
+            signalServerUrl: signalOpts.serverUrl,
+            description: signalOpts.description,
+            domain: signalOpts.domain,
+            listenPort: signalOpts.listenPort,
+            urlRoot: options.urlRoot ?? '/api/vm/net',
+            getSystemInfo: () => ({
+                connectedPlayers: Object.keys(exports.currentState.activeConnections).length,
+                ...signalOpts.getExtraSystemInfo?.(),
+            }),
+        });
+        const stopSignal = () => signalClient.stop();
+        process.once('SIGTERM', stopSignal);
+        process.once('SIGINT', stopSignal);
+    }
+    return app;
+}
+exports.default = createProxyMiddleware;
+const parseSocksProxy = (proxy) => {
+    const proxyParts = proxy.split('@');
+    if (proxyParts.length === 1) {
+        const portStr = proxyParts[0].split(':')[1];
+        if (!portStr)
+            throw new Error('Missing port in socks5 proxy');
+        return {
+            ipaddress: proxyParts[0],
+            port: Number.parseInt(portStr, 10),
+            type: 5,
+        };
+    }
+    if (proxyParts.length === 2) {
+        const [ipaddress, portStr] = proxyParts[1].split(':');
+        const [userId, password] = proxyParts[0].split(':');
+        if (!portStr)
+            throw new Error('Missing port in socks5 proxy');
+        return {
+            ipaddress,
+            port: Number.parseInt(portStr, 10),
+            userId: userId,
+            password: password || undefined,
+            type: 5,
+        };
+    }
+    throw new Error('Invalid socks5 proxy format');
+};
+exports.parseSocksProxy = parseSocksProxy;

package/dist/app.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI / Docker entry point.
+ *
+ * Reads configuration from environment variables and command-line arguments,
+ * then starts the proxy server. No MWC-specific code lives here.
+ *
+ * Supported env vars:
+ *   PORT                   — listen port (default 2344, overridden by argv[2])
+ *   URL_ROOT               — API path prefix (default /api/vm/net)
+ *   ALLOW_ORIGIN           — CORS origin header value (default *)
+ *   MAX_CONNECTIONS_PER_IP — per-IP connection cap (default 5)
+ *   ACCESS_CODE            — secret for /connections endpoint
+ *   SIGNAL_SERVER_URL      — signal server URL (default https://signal.mcraft.fun)
+ *   SIGNAL_DESCRIPTION     — description forwarded to signal server
+ *   SIGNAL_DOMAIN          — domain forwarded to signal server
+ *   DISABLE_SIGNAL         — set to 1 or true to disable signal server reporting
+ */
+export {};
+//# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;GAgBG"}

package/dist/app.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Standalone CLI / Docker entry point.
+ *
+ * Reads configuration from environment variables and command-line arguments,
+ * then starts the proxy server. No MWC-specific code lives here.
+ *
+ * Supported env vars:
+ *   PORT                   — listen port (default 2344, overridden by argv[2])
+ *   URL_ROOT               — API path prefix (default /api/vm/net)
+ *   ALLOW_ORIGIN           — CORS origin header value (default *)
+ *   MAX_CONNECTIONS_PER_IP — per-IP connection cap (default 5)
+ *   ACCESS_CODE            — secret for /connections endpoint
+ *   SIGNAL_SERVER_URL      — signal server URL (default https://signal.mcraft.fun)
+ *   SIGNAL_DESCRIPTION     — description forwarded to signal server
+ *   SIGNAL_DOMAIN          — domain forwarded to signal server
+ *   DISABLE_SIGNAL         — set to 1 or true to disable signal server reporting
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const https_1 = __importDefault(require("https"));
+const fs_1 = __importDefault(require("fs"));
+const express_1 = __importDefault(require("express"));
+const compression_1 = __importDefault(require("compression"));
+const index_1 = require("./index");
+if (fs_1.default.existsSync(path_1.default.join(__dirname, './env.js'))) {
+    require('./env.js');
+}
+const app = (0, express_1.default)();
+const keyFile = path_1.default.join(__dirname, './key.pem');
+let httpsServer;
+if (fs_1.default.existsSync(keyFile)) {
+    const key = fs_1.default.readFileSync(keyFile);
+    const cert = fs_1.default.readFileSync(path_1.default.join(__dirname, './cert.pem'));
+    httpsServer = https_1.default.createServer({ key, cert }, app);
+}
+app.use((0, compression_1.default)());
+const logsDir = path_1.default.join(__dirname, 'logs');
+fs_1.default.mkdirSync(logsDir, { recursive: true });
+const accessFile = fs_1.default.createWriteStream(path_1.default.join(logsDir, 'access.log'), { flags: 'a' });
+const urlRoot = process.env.URL_ROOT ?? '/api/vm/net';
+const portArg = process.argv.indexOf('--port');
+const port = process.argv[2] && !process.argv[2].startsWith('-')
+    ? process.argv[2]
+    : portArg === -1
+        ? process.env.PORT ?? 2344
+        : process.argv[portArg + 1];
+app.use((0, index_1.createProxyMiddleware)({
+    allowOrigin: process.env.ALLOW_ORIGIN ?? '*',
+    server: httpsServer,
+    urlRoot,
+    log(line) {
+        const ts = new Date().toISOString().replace('T', ' ').split('.')[0];
+        accessFile.write(`[${ts}] ${line}\n`);
+    },
+    allowOriginApp: true,
+    maxConnectionsPerIp: process.env.MAX_CONNECTIONS_PER_IP ? Number(process.env.MAX_CONNECTIONS_PER_IP) : 5,
+    signal: process.env.DISABLE_SIGNAL === '1' || process.env.DISABLE_SIGNAL?.toLowerCase() === 'true'
+        ? undefined
+        : {
+            serverUrl: process.env.SIGNAL_SERVER_URL ?? 'https://signal.mcraft.fun',
+            description: process.env.SIGNAL_DESCRIPTION,
+            domain: process.env.SIGNAL_DOMAIN,
+            listenPort: Number(port),
+        },
+}));
+app.use(express_1.default.static(path_1.default.join(__dirname, './dist')));
+(httpsServer ?? app).listen(port, () => {
+    console.log(`Proxy server listening on port ${port}`);
+    setInterval(() => { });
+});

package/dist/authEndpoint.d.ts

@@ -0,0 +1,5 @@
+import { type Express } from 'express';
+import type { ProxyMiddlewareOptions } from './api';
+declare const _default: (app: Express, authTokensEndpoint?: string, sessionServerProxy?: string, authLog?: (str: string) => void, urlRoot?: string, options?: ProxyMiddlewareOptions) => void;
+export default _default;
+//# sourceMappingURL=authEndpoint.d.ts.map

package/dist/authEndpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authEndpoint.d.ts","sourceRoot":"","sources":["../src/authEndpoint.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAKtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,OAAO,CAAA;yBAoCnC,KAAK,OAAO,EAAE,2BAAwB,EAAE,2BAA+B,EAAE,WAAW,KAAK,MAAM,SAAO,EAAE,gBAAY,EAAE,UAAS,sBAA2B;AAA1K,wBA4KC"}