@ninenity/neutrun 1.0.0 → 1.2.0

package/dist/Shared/ExpressApi.js

@@ -0,0 +1,676 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = exports.ApiRequestError = void 0;
+const express_1 = __importDefault(require("express"));
+const node_http_1 = require("node:http");
+const node_crypto_1 = require("node:crypto");
+const ConsoleLog_1 = require("./ConsoleLog");
+const ProcessManager_1 = __importDefault(require("./ProcessManager"));
+const TelemetryService_1 = require("./TelemetryService");
+class ApiRequestError extends Error {
+    status;
+    data;
+    response;
+    constructor(message, response, data) {
+        super(message);
+        this.name = 'ApiRequestError';
+        this.status = response.status;
+        this.response = response;
+        this.data = data;
+    }
+}
+exports.ApiRequestError = ApiRequestError;
+const DEFAULT_HOST = '127.0.0.1';
+const DEFAULT_PORT = 3000;
+const DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30 * 1000;
+const DEFAULT_RATE_LIMIT_WINDOW_MS = 60 * 1000;
+const DEFAULT_RATE_LIMIT_MAX = 60;
+const MAX_RATE_LIMIT_ENTRIES = 10_000;
+const SERVER_CLOSE_TIMEOUT_MS = 5_000;
+const MAX_INTERNAL_RESPONSE_BYTES = 2 * 1024 * 1024;
+class ExpressApiService {
+    app;
+    settings = normalizeSettings(undefined);
+    configured = false;
+    finalized = false;
+    server = null;
+    startPromise = null;
+    stopPromise = null;
+    idleTimer = null;
+    activeRequests = 0;
+    lastActivityAt = Date.now();
+    resourcesSuspended = false;
+    cleanupRegistered = false;
+    middlewareInstalled = false;
+    rateLimitEntries = new Map();
+    rateLimitLastSweepAt = 0;
+    resourceTransition = null;
+    constructor() {
+        this.app = (0, express_1.default)();
+        this.app.disable('x-powered-by');
+        this.app.configureNeutrun = (options) => this.configure(options);
+        this.app.finalize = () => this.finalize();
+        this.app.start = (options) => this.start(options);
+        this.app.ensureStarted = () => this.ensureStarted();
+        this.app.stop = () => this.stop();
+        this.app.fetch = (path, options) => this.fetch(path, options);
+        this.app.fetchJson = (path, options) => this.fetchJson(path, options);
+        Object.defineProperties(this.app, {
+            isRunning: {
+                enumerable: true,
+                get: () => this.server !== null
+            },
+            isSuspended: {
+                enumerable: true,
+                get: () => this.resourcesSuspended
+            },
+            url: {
+                enumerable: true,
+                get: () => this.url
+            }
+        });
+    }
+    configure(options) {
+        if (this.server) {
+            throw new Error('Api não pode ser reconfigurada enquanto o servidor está ativo.');
+        }
+        const nextSettings = normalizeSettings(options);
+        if (this.middlewareInstalled &&
+            String(nextSettings.security.bodyLimit ?? '1mb') !==
+                String(this.settings.security.bodyLimit ?? '1mb')) {
+            throw new Error('security.bodyLimit não pode mudar depois que os middlewares da Api foram instalados.');
+        }
+        this.settings = nextSettings;
+        this.configured = options !== false && options !== undefined;
+        this.app.set('trust proxy', this.settings.security.trustProxy ?? false);
+        this.app.disable('x-powered-by');
+        if (!this.configured || !this.settings.enabled)
+            return;
+        validateSettings(this.settings);
+        if (this.middlewareInstalled)
+            return;
+        this.installBuiltInMiddleware();
+    }
+    finalize() {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        this.app.use((_req, res) => {
+            res.status(404).json({
+                success: false,
+                error: 'Not Found'
+            });
+        });
+        this.app.use((error, _req, res, next) => {
+            const message = error instanceof Error ? error.message : String(error);
+            const status = isHttpStatus(error) ? error.status : 500;
+            (0, ConsoleLog_1.logError)(`Erro na mini API: ${message}`, 'Api');
+            if (res.headersSent)
+                return next(error);
+            res.status(status).json({
+                success: false,
+                error: status >= 500 ? 'Internal Server Error' : message
+            });
+        });
+    }
+    async start(options) {
+        if (this.stopPromise)
+            await this.stopPromise;
+        if (options !== undefined)
+            this.configure(options);
+        if (!this.configured || !this.settings.enabled)
+            return;
+        if (this.server)
+            return;
+        if (this.startPromise)
+            return this.startPromise;
+        validateSettings(this.settings);
+        this.finalize();
+        this.startPromise = new Promise((resolve, reject) => {
+            const server = (0, node_http_1.createServer)(this.app);
+            const requestTimeout = this.settings.security.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+            server.requestTimeout = requestTimeout;
+            server.headersTimeout = Math.max(requestTimeout + 1_000, 5_000);
+            server.keepAliveTimeout = Math.min(requestTimeout, 5_000);
+            const onError = (error) => {
+                server.removeListener('listening', onListening);
+                try {
+                    server.close();
+                }
+                catch {
+                    // O servidor ainda pode não ter aberto um handle.
+                }
+                reject(error);
+            };
+            const onListening = () => {
+                server.removeListener('error', onError);
+                this.server = server;
+                this.startPromise = null;
+                this.lastActivityAt = Date.now();
+                this.registerCleanup();
+                this.scheduleIdleCheck();
+                const address = server.address();
+                const actualPort = typeof address === 'object' && address ? address.port : this.settings.port;
+                (0, ConsoleLog_1.logSuccess)(`Mini API Express ativa em ${this.publicUrl(actualPort)}`, 'Api');
+                resolve();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(this.settings.port, this.settings.host);
+        }).catch((error) => {
+            this.startPromise = null;
+            (0, ConsoleLog_1.logError)(`Falha ao iniciar a mini API: ${error instanceof Error ? error.message : error}`, 'Api');
+            throw error;
+        });
+        return this.startPromise;
+    }
+    async ensureStarted() {
+        if (!this.configured || !this.settings.enabled) {
+            throw new Error('A mini API está desativada. Configure settings.api no Neutrun.init().');
+        }
+        if (!this.server)
+            await this.start();
+        await this.wakeResources();
+    }
+    async stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        this.clearIdleTimer();
+        if (this.startPromise) {
+            await this.startPromise.catch(() => undefined);
+        }
+        const server = this.server;
+        if (!server)
+            return;
+        this.server = null;
+        this.stopPromise = closeHttpServer(server).finally(() => {
+            this.stopPromise = null;
+        });
+        await this.stopPromise;
+        (0, ConsoleLog_1.logInfo)('Mini API Express encerrada.', 'Api');
+    }
+    async fetch(path, options = {}) {
+        await this.ensureStarted();
+        const url = this.resolveUrl(path);
+        const headers = new Headers(options.headers);
+        const token = this.resolveToken();
+        const authentication = this.settings.security.authentication;
+        if (token && authentication !== 'none' && !headers.has('authorization') && !headers.has('x-api-key')) {
+            if (authentication === 'api-key')
+                headers.set('x-api-key', token);
+            else
+                headers.set('authorization', `Bearer ${token}`);
+        }
+        const body = serializeBody(options.body, headers);
+        const { query, ...init } = options;
+        const requestInit = {
+            ...init,
+            method: options.method ?? (body === undefined ? 'GET' : 'POST'),
+            headers,
+            body
+        };
+        return globalThis.fetch(addQuery(url, query), requestInit);
+    }
+    async fetchJson(path, options = {}) {
+        const response = await this.fetch(path, options);
+        const data = await parseResponse(response);
+        if (!response.ok) {
+            throw new ApiRequestError(`Mini API request failed with HTTP ${response.status}.`, response, data);
+        }
+        return { data, response };
+    }
+    installBuiltInMiddleware() {
+        this.middlewareInstalled = true;
+        this.app.use(this.securityHeaders());
+        this.app.use(this.corsMiddleware());
+        this.app.use(this.requestTrackingMiddleware());
+        this.app.use(this.requestTimeoutMiddleware());
+        this.app.use(this.rateLimitMiddleware());
+        this.app.use(this.authenticationMiddleware());
+        this.app.use(this.wakeResourcesMiddleware());
+        this.app.use(express_1.default.json({ limit: this.settings.security.bodyLimit ?? '1mb' }));
+        this.app.use(express_1.default.urlencoded({
+            extended: true,
+            limit: this.settings.security.bodyLimit ?? '1mb'
+        }));
+    }
+    securityHeaders() {
+        return (_req, res, next) => {
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+            res.setHeader('X-Frame-Options', 'DENY');
+            res.setHeader('Referrer-Policy', 'no-referrer');
+            res.setHeader('Cross-Origin-Resource-Policy', 'same-origin');
+            next();
+        };
+    }
+    corsMiddleware() {
+        return (req, res, next) => {
+            const cors = this.settings.security.cors;
+            if (cors === false || cors === undefined)
+                return next();
+            const origin = req.headers.origin;
+            const allowed = cors === '*'
+                ? '*'
+                : origin && cors.includes(origin)
+                    ? origin
+                    : undefined;
+            if (allowed) {
+                res.setHeader('Access-Control-Allow-Origin', allowed);
+                res.setHeader('Vary', 'Origin');
+                res.setHeader('Access-Control-Allow-Headers', 'Authorization, Content-Type, X-API-Key');
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+            }
+            if (req.method === 'OPTIONS')
+                return res.sendStatus(allowed ? 204 : 403);
+            next();
+        };
+    }
+    requestTrackingMiddleware() {
+        return (req, res, next) => {
+            this.lastActivityAt = Date.now();
+            this.activeRequests += 1;
+            let completed = false;
+            const complete = () => {
+                if (completed)
+                    return;
+                completed = true;
+                this.activeRequests = Math.max(0, this.activeRequests - 1);
+                this.lastActivityAt = Date.now();
+                this.scheduleIdleCheck();
+                this.recordRequest(req, res, res.statusCode);
+            };
+            res.once('finish', complete);
+            res.once('close', complete);
+            next();
+        };
+    }
+    requestTimeoutMiddleware() {
+        return (_req, res, next) => {
+            const timeoutMs = this.settings.security.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+            res.setTimeout(timeoutMs, () => {
+                if (!res.headersSent) {
+                    res.status(504).json({ success: false, error: 'Gateway Timeout' });
+                }
+                else {
+                    res.destroy();
+                }
+            });
+            next();
+        };
+    }
+    wakeResourcesMiddleware() {
+        return (_req, _res, next) => {
+            void this.wakeResources().then(() => next()).catch(next);
+        };
+    }
+    rateLimitMiddleware() {
+        return (req, res, next) => {
+            const options = this.settings.security.rateLimit;
+            if (options === false || options === undefined)
+                return next();
+            const now = Date.now();
+            const key = req.ip || req.socket.remoteAddress || 'unknown';
+            const windowMs = Math.max(1_000, options.windowMs ?? DEFAULT_RATE_LIMIT_WINDOW_MS);
+            const max = Math.max(1, options.max ?? DEFAULT_RATE_LIMIT_MAX);
+            this.pruneRateLimits(now, windowMs);
+            const current = this.rateLimitEntries.get(key);
+            if (!current || now - current.startedAt >= windowMs) {
+                this.rateLimitEntries.set(key, { startedAt: now, count: 1 });
+                return next();
+            }
+            current.count += 1;
+            if (current.count > max) {
+                res.setHeader('Retry-After', Math.ceil((windowMs - (now - current.startedAt)) / 1_000));
+                return res.status(429).json({
+                    success: false,
+                    error: 'Too Many Requests'
+                });
+            }
+            next();
+        };
+    }
+    authenticationMiddleware() {
+        return (req, res, next) => {
+            const authentication = this.settings.security.authentication;
+            const token = this.resolveToken();
+            if (authentication === 'none' || !token || isPublicPath(req.path, this.settings.security.publicPaths)) {
+                return next();
+            }
+            const received = authentication === 'api-key'
+                ? req.get('x-api-key')
+                : extractBearerToken(req.get('authorization'));
+            if (!received || !timingSafeEqual(received, token)) {
+                return res.status(401).json({
+                    success: false,
+                    error: 'Unauthorized'
+                });
+            }
+            next();
+        };
+    }
+    resolveToken() {
+        const configured = this.settings.security.token?.trim();
+        if (configured)
+            return configured;
+        return process.env[this.settings.security.tokenEnv]?.trim() || '';
+    }
+    scheduleIdleCheck() {
+        this.clearIdleTimer();
+        const lifecycle = this.settings.lifecycle;
+        if (!this.server || lifecycle.mode === 'always')
+            return;
+        const idleTimeoutMs = lifecycle.idleTimeoutMs;
+        this.idleTimer = setTimeout(() => {
+            void this.handleIdle().catch((error) => {
+                (0, ConsoleLog_1.logWarn)(`Falha no ciclo de ociosidade da mini API: ${error instanceof Error ? error.message : error}`, 'Api');
+                this.lastActivityAt = Date.now();
+                this.scheduleIdleCheck();
+            });
+        }, Math.max(1_000, idleTimeoutMs - (Date.now() - this.lastActivityAt)));
+        this.idleTimer.unref?.();
+    }
+    async handleIdle() {
+        if (!this.server || this.activeRequests > 0) {
+            this.scheduleIdleCheck();
+            return;
+        }
+        if (Date.now() - this.lastActivityAt < this.settings.lifecycle.idleTimeoutMs) {
+            this.scheduleIdleCheck();
+            return;
+        }
+        await this.suspendResources();
+        if (this.settings.lifecycle.mode === 'idle') {
+            await this.stop();
+        }
+    }
+    async suspendResources() {
+        if (this.resourceTransition)
+            await this.resourceTransition;
+        if (this.resourcesSuspended)
+            return;
+        const transition = (async () => {
+            await this.settings.lifecycle.onIdle?.();
+            this.resourcesSuspended = true;
+            TelemetryService_1.Telemetry.registerEvent('api:idle');
+        })();
+        this.resourceTransition = transition;
+        try {
+            await transition;
+        }
+        finally {
+            if (this.resourceTransition === transition)
+                this.resourceTransition = null;
+        }
+    }
+    async wakeResources() {
+        if (this.resourceTransition)
+            await this.resourceTransition;
+        if (!this.resourcesSuspended)
+            return;
+        const transition = (async () => {
+            await this.settings.lifecycle.onWake?.();
+            this.resourcesSuspended = false;
+            TelemetryService_1.Telemetry.registerEvent('api:wake');
+        })();
+        this.resourceTransition = transition;
+        try {
+            await transition;
+        }
+        finally {
+            if (this.resourceTransition === transition)
+                this.resourceTransition = null;
+        }
+    }
+    registerCleanup() {
+        if (this.cleanupRegistered)
+            return;
+        this.cleanupRegistered = true;
+        ProcessManager_1.default.registerCleanupTask(() => this.stop(), 'mini API Express');
+    }
+    recordRequest(req, res, status, error = false) {
+        const path = req.path || req.originalUrl || '/';
+        TelemetryService_1.Telemetry.registerCounter('apiRequests');
+        TelemetryService_1.Telemetry.registerEvent(`api:${req.method}:${path}`.slice(0, 120), {
+            error: error || status >= 400
+        });
+        void res;
+    }
+    resolveUrl(path) {
+        const base = this.url;
+        if (!base)
+            throw new Error('A mini API ainda não está ativa.');
+        const resolved = /^https?:\/\//i.test(path)
+            ? new URL(path)
+            : new URL(path.replace(/^\/+/, ''), `${base}/`);
+        if (resolved.origin !== new URL(base).origin) {
+            throw new Error('Api.fetch aceita apenas URLs da própria mini API.');
+        }
+        return resolved.toString();
+    }
+    publicUrl(port) {
+        const host = this.settings.host === '0.0.0.0' || this.settings.host === '::'
+            ? '127.0.0.1'
+            : this.settings.host;
+        return `http://${formatHost(host)}:${port}`;
+    }
+    get url() {
+        if (!this.server)
+            return null;
+        const address = this.server.address();
+        const port = typeof address === 'object' && address ? address.port : this.settings.port;
+        return this.publicUrl(port);
+    }
+    clearIdleTimer() {
+        if (!this.idleTimer)
+            return;
+        clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+    }
+    pruneRateLimits(now, windowMs) {
+        if (this.rateLimitEntries.size < MAX_RATE_LIMIT_ENTRIES &&
+            now - this.rateLimitLastSweepAt < windowMs)
+            return;
+        this.rateLimitLastSweepAt = now;
+        for (const [key, entry] of this.rateLimitEntries) {
+            if (now - entry.startedAt >= windowMs)
+                this.rateLimitEntries.delete(key);
+        }
+        while (this.rateLimitEntries.size >= MAX_RATE_LIMIT_ENTRIES) {
+            const oldest = this.rateLimitEntries.keys().next().value;
+            if (!oldest)
+                break;
+            this.rateLimitEntries.delete(oldest);
+        }
+    }
+}
+const service = new ExpressApiService();
+exports.Api = service.app;
+function normalizeSettings(options) {
+    const api = options === false ? {} : options ?? {};
+    const host = api.host?.trim() || process.env.NEUTRUN_API_HOST?.trim() || DEFAULT_HOST;
+    const serverless = api.serverless;
+    const lifecycle = api.lifecycle ?? {};
+    const serverlessOptions = typeof serverless === 'object' ? serverless : {};
+    const serverlessEnabled = serverless === true || serverlessOptions.enabled === true;
+    const lifecycleMode = serverlessEnabled
+        ? lifecycle.mode ?? 'idle'
+        : lifecycle.mode ?? 'always';
+    const idleTimeoutMs = parseDuration(lifecycle.idleTimeoutMs ?? serverlessOptions.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS);
+    return {
+        enabled: api.enabled ?? (options !== undefined && options !== false),
+        host,
+        port: normalizePort(api.port ?? process.env.NEUTRUN_API_PORT),
+        lifecycle: {
+            mode: lifecycleMode,
+            idleTimeoutMs,
+            onIdle: lifecycle.onIdle ?? serverlessOptions.onIdle,
+            onWake: lifecycle.onWake ?? serverlessOptions.onWake
+        },
+        security: {
+            authentication: api.security?.authentication ?? (resolveToken(api.security) || isPublicHost(host) ? 'bearer' : 'none'),
+            token: api.security?.token,
+            tokenEnv: api.security?.tokenEnv ?? 'NEUTRUN_API_TOKEN',
+            publicPaths: api.security?.publicPaths ?? [],
+            cors: api.security?.cors,
+            bodyLimit: api.security?.bodyLimit,
+            rateLimit: api.security?.rateLimit,
+            requestTimeoutMs: api.security?.requestTimeoutMs,
+            trustProxy: api.security?.trustProxy
+        }
+    };
+}
+function validateSettings(settings) {
+    const hasToken = Boolean(resolveToken(settings.security));
+    if (settings.security.authentication !== 'none' && !hasToken) {
+        throw new Error('A mini API autenticada precisa de security.token ou NEUTRUN_API_TOKEN configurado.');
+    }
+}
+function isPublicHost(host) {
+    return !['127.0.0.1', 'localhost', '::1'].includes(host);
+}
+function resolveToken(security) {
+    const token = security?.token?.trim();
+    if (token)
+        return token;
+    return process.env[security?.tokenEnv ?? 'NEUTRUN_API_TOKEN']?.trim() || '';
+}
+function normalizePort(value) {
+    const parsed = Number(value ?? DEFAULT_PORT);
+    if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65_535) {
+        throw new TypeError('A porta da mini API deve ser um inteiro entre 0 e 65535.');
+    }
+    return parsed;
+}
+function parseDuration(value) {
+    if (typeof value === 'number')
+        return Math.max(1_000, value);
+    const normalized = value.trim().toLowerCase();
+    const match = normalized.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/);
+    if (!match)
+        throw new TypeError(`Duração inválida para a mini API: ${value}`);
+    const amount = Number(match[1]);
+    const multiplier = match[2] === 'h'
+        ? 60 * 60 * 1_000
+        : match[2] === 'm'
+            ? 60 * 1_000
+            : match[2] === 's'
+                ? 1_000
+                : 1;
+    return Math.max(1_000, Math.round(amount * multiplier));
+}
+function isPublicPath(path, paths) {
+    return (paths ?? []).some((entry) => {
+        const normalized = entry.trim();
+        if (!normalized)
+            return false;
+        if (normalized.endsWith('*'))
+            return path.startsWith(normalized.slice(0, -1));
+        return path === normalized;
+    });
+}
+function extractBearerToken(header) {
+    const match = header?.match(/^Bearer\s+(.+)$/i);
+    return match?.[1]?.trim() || '';
+}
+function timingSafeEqual(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    if (leftBuffer.length !== rightBuffer.length)
+        return false;
+    return (0, node_crypto_1.timingSafeEqual)(leftBuffer, rightBuffer);
+}
+function serializeBody(body, headers) {
+    if (body === undefined)
+        return undefined;
+    if (typeof body === 'string')
+        return body;
+    if (body instanceof URLSearchParams || body instanceof FormData || body instanceof Blob) {
+        return body;
+    }
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body))
+        return body;
+    if (!headers.has('Content-Type'))
+        headers.set('Content-Type', 'application/json');
+    return JSON.stringify(body);
+}
+function addQuery(url, query) {
+    if (!query)
+        return url;
+    const parsed = new URL(url);
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null)
+            parsed.searchParams.set(key, String(value));
+    }
+    return parsed.toString();
+}
+async function parseResponse(response) {
+    const text = await readResponseText(response, MAX_INTERNAL_RESPONSE_BYTES);
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function readResponseText(response, maxBytes) {
+    const contentLength = Number(response.headers.get('content-length'));
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+        throw new RangeError(`Resposta da mini API excedeu ${maxBytes} bytes.`);
+    }
+    if (!response.body)
+        return '';
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new RangeError(`Resposta da mini API excedeu ${maxBytes} bytes.`);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8');
+}
+async function closeHttpServer(server) {
+    await new Promise((resolve) => {
+        let finished = false;
+        const finish = () => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timeout);
+            resolve();
+        };
+        const timeout = setTimeout(() => {
+            server.closeAllConnections?.();
+            (0, ConsoleLog_1.logWarn)(`Encerramento da mini API excedeu ${SERVER_CLOSE_TIMEOUT_MS}ms; conexões restantes foram finalizadas.`, 'Api');
+            finish();
+        }, SERVER_CLOSE_TIMEOUT_MS);
+        server.close(() => finish());
+        server.closeIdleConnections?.();
+    });
+}
+function isHttpStatus(error) {
+    return typeof error === 'object' && error !== null &&
+        'status' in error && typeof error.status === 'number' &&
+        error.status >= 400 && error.status <= 599;
+}
+function formatHost(host) {
+    return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+}
+//# sourceMappingURL=ExpressApi.js.map