@undefineds.co/xpod 0.1.7 → 0.2.0-preview.2

package/dist/http/admin/EdgeNodeSignalHttpHandler.js

@@ -1,674 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EdgeNodeSignalHttpHandler = void 0;
-const global_logger_factory_1 = require("global-logger-factory");
-const community_server_1 = require("@solid/community-server");
-const community_server_2 = require("@solid/community-server");
-const db_1 = require("../../identity/drizzle/db");
-const EdgeNodeRepository_1 = require("../../identity/drizzle/EdgeNodeRepository");
-const EdgeNodeModeDetector_1 = require("../../edge/EdgeNodeModeDetector");
-const EdgeNodeCapabilityDetector_1 = require("../../edge/EdgeNodeCapabilityDetector");
-class EdgeNodeSignalHttpHandler extends community_server_1.HttpHandler {
-    constructor(options) {
-        super();
-        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
-        this.repo = options.repository ?? new EdgeNodeRepository_1.EdgeNodeRepository((0, db_1.getIdentityDatabase)(options.identityDbUrl));
-        this.basePath = this.normalizeBasePath(options.basePath ?? '/api/signal');
-        this.basePathWithSlash = `${this.basePath}/`;
-        this.enabled = this.normalizeBoolean(options.edgeNodesEnabled);
-        this.dnsCoordinator = options.dnsCoordinator;
-        this.certificateProvisioner = options.certificateProvisioner;
-        this.tunnelManager = options.tunnelManager;
-        this.healthProbeService = options.healthProbeService;
-        this.modeDetector = options.modeDetector ?? (options.clusterBaseDomain ?
-            new EdgeNodeModeDetector_1.EdgeNodeModeDetector({ baseDomain: options.clusterBaseDomain }) :
-            undefined);
-        this.capabilityDetector = options.capabilityDetector;
-    }
-    async canHandle({ request }) {
-        if (!this.enabled) {
-            throw new community_server_2.NotImplementedHttpError('Edge node signaling is disabled.');
-        }
-        const pathname = this.parseUrl(request).pathname;
-        if (!this.matchesBase(pathname)) {
-            throw new community_server_2.NotImplementedHttpError('Not an edge node signaling request.');
-        }
-    }
-    async handle({ request, response }) {
-        try {
-            await this.handleRequest(request, response);
-        }
-        catch (error) {
-            this.writeError(response, error);
-        }
-    }
-    async handleRequest(request, response) {
-        const method = (request.method ?? 'GET').toUpperCase();
-        if (method === 'OPTIONS') {
-            this.writeOptions(response);
-            return;
-        }
-        if (method !== 'POST') {
-            throw new community_server_2.MethodNotAllowedHttpError(['POST', 'OPTIONS']);
-        }
-        const url = this.parseUrl(request);
-        const relative = this.toRelative(url.pathname);
-        if (relative !== '') {
-            throw new community_server_2.NotImplementedHttpError('Unknown signal endpoint.');
-        }
-        const payload = await this.readPayload(request);
-        const now = new Date();
-        const secret = await this.repo.getNodeSecret(payload.nodeId);
-        if (!secret || !secret.tokenHash || !this.repo.matchesToken(secret.tokenHash, payload.token)) {
-            throw new community_server_2.UnauthorizedHttpError('Edge node authentication failed.');
-        }
-        let merged = await this.mergeMetadata((secret.metadata ?? {}), payload, now);
-        if (this.tunnelManager) {
-            const enriched = await this.tunnelManager.ensureConnectivity(secret.nodeId, merged);
-            if (enriched) {
-                merged = enriched;
-            }
-        }
-        // Perform mode detection and update if necessary
-        const fallbackPublicIp = this.optionalString(payload.ipv4) ??
-            this.optionalString(merged.ipv4) ??
-            this.optionalString(merged.publicIp);
-        const connectivityInfo = await this.repo.getNodeConnectivityInfo(payload.nodeId);
-        // 提取 IPv6 地址
-        const ipv6Address = this.optionalString(payload.ipv6) ?? this.optionalString(merged.ipv6);
-        if (this.modeDetector && (fallbackPublicIp || ipv6Address)) {
-            const nodeRegistrationInfo = {
-                nodeId: payload.nodeId,
-                publicIp: fallbackPublicIp,
-                publicIpv6: ipv6Address,
-                publicPort: this.extractPortNumber(payload.publicAddress || merged.publicAddress),
-                capabilities: this.buildNodeCapabilities(payload, merged),
-            };
-            const currentConnectivity = connectivityInfo;
-            // Perform initial mode detection or recheck if in proxy mode
-            let modeResult;
-            const normalizedCurrentMode = this.normalizeAccessMode(currentConnectivity?.accessMode);
-            if (!normalizedCurrentMode) {
-                // Initial registration - perform full mode detection
-                modeResult = await this.modeDetector.detectMode(nodeRegistrationInfo);
-                this.logger.info(`Initial mode detection for node ${payload.nodeId}: ${modeResult.accessMode} (${modeResult.reason})`);
-            }
-            else if (normalizedCurrentMode === 'proxy') {
-                // Periodic recheck for proxy nodes to see if they can switch to redirect mode
-                modeResult = await this.modeDetector.recheckMode(normalizedCurrentMode, nodeRegistrationInfo);
-                if (modeResult) {
-                    this.logger.info(`Mode transition for node ${payload.nodeId}: ${normalizedCurrentMode} -> ${modeResult.accessMode} (${modeResult.reason})`);
-                }
-            }
-            // Update database with mode information if detection was performed
-            if (modeResult) {
-                await this.repo.updateNodeMode(payload.nodeId, {
-                    accessMode: modeResult.accessMode,
-                    publicIp: nodeRegistrationInfo.publicIp,
-                    publicPort: nodeRegistrationInfo.publicPort,
-                    subdomain: modeResult.subdomain,
-                    connectivityStatus: modeResult.connectivityTest?.success === true ? 'reachable' :
-                        modeResult.connectivityTest?.success === false ? 'unreachable' : 'unknown',
-                    capabilities: nodeRegistrationInfo.capabilities,
-                });
-                // Store mode information in merged metadata for coordinator services
-                merged.accessMode = modeResult.accessMode;
-                merged.subdomain = modeResult.subdomain;
-                merged.connectivityTest = modeResult.connectivityTest;
-                if (nodeRegistrationInfo.publicIp) {
-                    merged.publicIp = nodeRegistrationInfo.publicIp;
-                }
-                if (nodeRegistrationInfo.publicPort) {
-                    merged.publicPort = nodeRegistrationInfo.publicPort;
-                }
-            }
-        }
-        await this.applyRoutingDecision(payload.nodeId, merged, connectivityInfo);
-        try {
-            await this.repo.updateNodeHeartbeat(secret.nodeId, merged, now);
-            if (payload.pods !== undefined) {
-                await this.repo.replaceNodePods(secret.nodeId, payload.pods);
-            }
-            if (this.dnsCoordinator) {
-                await this.dnsCoordinator.synchronize(secret.nodeId, merged);
-            }
-            if (this.certificateProvisioner) {
-                await this.certificateProvisioner.handleCertificateRequest(secret.nodeId, merged);
-            }
-            if (this.healthProbeService) {
-                await this.healthProbeService.probeNode(secret.nodeId);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Failed to update node heartbeat: ${error.message}`);
-            throw new community_server_2.InternalServerError('Failed to record edge node status.', { cause: error });
-        }
-        response.statusCode = 200;
-        response.setHeader('Content-Type', 'application/json; charset=utf-8');
-        response.setHeader('Cache-Control', 'no-store');
-        response.end(JSON.stringify({
-            status: 'ok',
-            nodeId: secret.nodeId,
-            lastSeen: now.toISOString(),
-            metadata: merged,
-        }));
-    }
-    writeError(response, error) {
-        if (response.headersSent) {
-            return;
-        }
-        let statusCode = 500;
-        let message = 'Internal Server Error';
-        if (error instanceof community_server_2.UnauthorizedHttpError) {
-            statusCode = 401;
-            message = error.message;
-        }
-        else if (error instanceof community_server_2.BadRequestHttpError) {
-            statusCode = 400;
-            message = error.message;
-        }
-        else if (error instanceof community_server_2.MethodNotAllowedHttpError) {
-            statusCode = 405;
-            message = error.message;
-        }
-        else if (error instanceof community_server_2.NotImplementedHttpError) {
-            statusCode = 501;
-            message = error.message;
-        }
-        else if (error instanceof community_server_2.InternalServerError) {
-            statusCode = 500;
-            message = error.message;
-        }
-        else if (error instanceof Error) {
-            message = error.message;
-        }
-        response.statusCode = statusCode;
-        response.setHeader('Content-Type', 'application/json; charset=utf-8');
-        response.end(JSON.stringify({ error: message }));
-    }
-    async readPayload(request) {
-        const body = await this.readBody(request);
-        if (!body) {
-            throw new community_server_2.BadRequestHttpError('信令上报必须包含 JSON 请求体。');
-        }
-        let payload;
-        try {
-            payload = JSON.parse(body);
-        }
-        catch (error) {
-            throw new community_server_2.BadRequestHttpError('信令上报体必须是有效 JSON。', { cause: error });
-        }
-        if (payload == null || typeof payload !== 'object') {
-            throw new community_server_2.BadRequestHttpError('信令上报体必须是 JSON 对象。');
-        }
-        const data = payload;
-        const nodeId = this.requireString(data.nodeId, 'nodeId');
-        const token = this.requireString(data.token, 'token');
-        return {
-            nodeId,
-            token,
-            baseUrl: this.optionalUrl(data.baseUrl),
-            publicAddress: this.optionalUrl(data.publicAddress),
-            hostname: this.optionalString(data.hostname),
-            ipv4: this.optionalIP(data.ipv4),
-            ipv6: this.optionalIP(data.ipv6),
-            version: this.optionalString(data.version),
-            status: this.optionalStatus(data.status),
-            capabilities: this.optionalCapabilities(data.capabilities),
-            pods: this.optionalPods(data.pods),
-            reachability: this.optionalRecord(data.reachability, 'reachability'),
-            directCandidates: this.optionalUrlList(data.directCandidates, 'directCandidates'),
-            tunnel: this.optionalRecord(data.tunnel, 'tunnel'),
-            certificate: this.optionalRecord(data.certificate, 'certificate'),
-            metrics: this.optionalRecord(data.metrics, 'metrics'),
-            metadata: this.optionalRecord(data.metadata, 'metadata'),
-        };
-    }
-    optionalCapabilities(input) {
-        if (!Array.isArray(input)) {
-            return undefined;
-        }
-        const items = input.map((value) => typeof value === 'string' ? value.trim() : '').filter((value) => value.length > 0);
-        const unique = Array.from(new Set(items));
-        return unique.length > 0 ? unique : undefined;
-    }
-    optionalStatus(value) {
-        if (typeof value !== 'string') {
-            return undefined;
-        }
-        const normalized = value.trim().toLowerCase();
-        return normalized.length > 0 ? normalized : undefined;
-    }
-    async mergeMetadata(previous, payload, now) {
-        const next = { ...previous };
-        next.lastHeartbeatAt = now.toISOString();
-        if (payload.baseUrl) {
-            next.baseUrl = payload.baseUrl;
-        }
-        if (payload.publicAddress) {
-            next.publicAddress = payload.publicAddress;
-        }
-        if (payload.hostname) {
-            next.hostname = payload.hostname;
-        }
-        if (payload.ipv4) {
-            next.ipv4 = payload.ipv4;
-        }
-        if (payload.ipv6) {
-            next.ipv6 = payload.ipv6;
-        }
-        if (payload.version) {
-            next.version = payload.version;
-        }
-        if (payload.status) {
-            next.status = payload.status;
-        }
-        if (payload.capabilities) {
-            next.capabilities = payload.capabilities;
-        }
-        // Enhanced capability reporting using EdgeNodeCapabilityDetector
-        if (this.capabilityDetector) {
-            try {
-                // Get structured capabilities from the detector
-                const detectedCapabilities = await this.capabilityDetector.detectCapabilities();
-                // Merge detected capabilities with existing metadata
-                next.detectedCapabilities = detectedCapabilities;
-                // Convert to string array format for backward compatibility
-                const capabilityStrings = EdgeNodeCapabilityDetector_1.EdgeNodeCapabilityDetector.capabilitiesToStringArray(detectedCapabilities);
-                // Merge with user-provided capabilities if any
-                const existingCapabilities = (payload.capabilities ?? []);
-                const mergedCapabilities = [...new Set([...existingCapabilities, ...capabilityStrings])];
-                next.capabilities = mergedCapabilities;
-                this.logger.debug(`Enhanced node capabilities for ${payload.nodeId}: ${JSON.stringify({
-                    original: existingCapabilities,
-                    detected: detectedCapabilities,
-                    merged: mergedCapabilities
-                })}`);
-            }
-            catch (error) {
-                this.logger.warn(`Failed to detect capabilities for node ${payload.nodeId}: ${error.message}`);
-                // Continue with user-provided capabilities if detection fails
-            }
-        }
-        if (payload.pods) {
-            next.pods = payload.pods;
-        }
-        if (payload.reachability) {
-            next.reachability = this.mergeRecord(next.reachability, payload.reachability);
-            next.reachabilityUpdatedAt = now.toISOString();
-        }
-        if (payload.directCandidates) {
-            next.directCandidates = this.uniqueList(payload.directCandidates);
-        }
-        if (payload.tunnel) {
-            next.tunnel = this.mergeRecord(next.tunnel, payload.tunnel);
-        }
-        if (payload.certificate) {
-            next.certificate = this.mergeRecord(next.certificate, payload.certificate);
-        }
-        if (payload.metrics) {
-            next.metrics = payload.metrics;
-            next.metricsUpdatedAt = now.toISOString();
-        }
-        if (payload.metadata) {
-            const previousExtra = this.asRecord(next.extra);
-            next.extra = { ...previousExtra, ...payload.metadata };
-        }
-        return next;
-    }
-    writeOptions(response) {
-        response.statusCode = 204;
-        response.setHeader('Allow', 'POST,OPTIONS');
-        response.end();
-    }
-    readBody(request) {
-        return new Promise((resolve, reject) => {
-            let data = '';
-            if (typeof request.setEncoding === 'function') {
-                request.setEncoding('utf8');
-            }
-            request.on('data', (chunk) => {
-                data += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-            });
-            request.on('end', () => resolve(data));
-            request.on('error', reject);
-        });
-    }
-    optionalString(value) {
-        if (typeof value !== 'string') {
-            return undefined;
-        }
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : undefined;
-    }
-    optionalUrl(value) {
-        const candidate = this.optionalString(value);
-        if (!candidate) {
-            return undefined;
-        }
-        try {
-            // eslint-disable-next-line no-new
-            new URL(candidate);
-            return candidate;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    optionalIP(value) {
-        const candidate = this.optionalString(value);
-        if (!candidate) {
-            return undefined;
-        }
-        const ipRegex = /^(?:\d{1,3}(?:\.\d{1,3}){3}|[0-9a-fA-F:]+)$/u;
-        return ipRegex.test(candidate) ? candidate : undefined;
-    }
-    optionalPods(value) {
-        if (value === undefined) {
-            return undefined;
-        }
-        if (!Array.isArray(value)) {
-            throw new community_server_2.BadRequestHttpError('pods 必须是字符串数组。');
-        }
-        const result = [];
-        for (const entry of value) {
-            if (typeof entry !== 'string') {
-                continue;
-            }
-            const trimmed = entry.trim();
-            if (trimmed.length === 0) {
-                continue;
-            }
-            try {
-                const normalized = new URL(trimmed).toString();
-                if (!result.includes(normalized)) {
-                    result.push(normalized);
-                }
-            }
-            catch {
-                this.logger.warn(`忽略无效 pod 基址: ${trimmed}`);
-            }
-        }
-        return result;
-    }
-    optionalRecord(value, field) {
-        if (value === undefined) {
-            return undefined;
-        }
-        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-            throw new community_server_2.BadRequestHttpError(`${field} 必须是 JSON 对象。`);
-        }
-        return value;
-    }
-    optionalUrlList(value, field) {
-        if (value === undefined) {
-            return undefined;
-        }
-        if (!Array.isArray(value)) {
-            throw new community_server_2.BadRequestHttpError(`${field} 必须是字符串数组。`);
-        }
-        const result = [];
-        for (const entry of value) {
-            if (typeof entry !== 'string') {
-                continue;
-            }
-            const trimmed = entry.trim();
-            if (trimmed.length === 0) {
-                continue;
-            }
-            try {
-                const normalized = new URL(trimmed).toString();
-                if (!result.includes(normalized)) {
-                    result.push(normalized);
-                }
-            }
-            catch {
-                this.logger.warn(`忽略无效 ${field} 候选: ${trimmed}`);
-            }
-        }
-        return result.length > 0 ? result : undefined;
-    }
-    mergeRecord(current, update) {
-        const base = this.asRecord(current);
-        return { ...base, ...update };
-    }
-    asRecord(value) {
-        if (value === null || value === undefined) {
-            return {};
-        }
-        if (typeof value !== 'object' || Array.isArray(value)) {
-            return {};
-        }
-        return value;
-    }
-    uniqueList(list) {
-        return Array.from(new Set(list));
-    }
-    requireString(value, field) {
-        if (typeof value !== 'string') {
-            throw new community_server_2.BadRequestHttpError(`${field} 必须是字符串。`);
-        }
-        const trimmed = value.trim();
-        if (trimmed.length === 0) {
-            throw new community_server_2.BadRequestHttpError(`${field} 不能为空。`);
-        }
-        return trimmed;
-    }
-    matchesBase(pathname) {
-        return pathname === this.basePath || pathname.startsWith(this.basePathWithSlash);
-    }
-    toRelative(pathname) {
-        if (pathname === this.basePath) {
-            return '';
-        }
-        if (!pathname.startsWith(this.basePathWithSlash)) {
-            return null;
-        }
-        return pathname.slice(this.basePathWithSlash.length);
-    }
-    parseUrl(request) {
-        const hostHeader = request.headers.host ?? request.headers.Host ?? 'localhost';
-        const protoHeader = request.headers['x-forwarded-proto'] ?? request.headers['X-Forwarded-Proto'];
-        const protocol = Array.isArray(protoHeader) ? protoHeader[0] : protoHeader;
-        const scheme = typeof protocol === 'string' ? protocol.split(',')[0]?.trim() ?? 'http' : 'http';
-        const rawUrl = request.url ?? '/';
-        return new URL(rawUrl, `${scheme}://${hostHeader}`);
-    }
-    normalizeBasePath(input) {
-        if (!input.startsWith('/')) {
-            throw new community_server_2.BadRequestHttpError('Signal base path must start with /.');
-        }
-        return input.endsWith('/') ? input.slice(0, -1) : input;
-    }
-    normalizeBoolean(value) {
-        if (typeof value === 'boolean') {
-            return value;
-        }
-        if (typeof value === 'string') {
-            const normalized = value.trim().toLowerCase();
-            return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
-        }
-        return false;
-    }
-    extractPortNumber(address) {
-        if (typeof address !== 'string') {
-            return undefined;
-        }
-        try {
-            const url = new URL(address);
-            const port = url.port;
-            if (port) {
-                const parsed = parseInt(port, 10);
-                return isNaN(parsed) ? undefined : parsed;
-            }
-            // Return default port based on protocol
-            return url.protocol === 'https:' ? 443 : url.protocol === 'http:' ? 80 : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    buildNodeCapabilities(payload, merged) {
-        // Start with basic capability information from payload and metadata
-        const capabilityStrings = Array.isArray(payload.capabilities) ?
-            payload.capabilities :
-            Array.isArray(merged.capabilities) ? merged.capabilities : undefined;
-        let capabilities = {
-            solidProtocolVersion: payload.version || merged.version || '1.0.0',
-            storageBackends: this.parseStorageBackends(capabilityStrings),
-            authMethods: this.parseAuthMethods(capabilityStrings),
-            maxBandwidth: merged.maxBandwidth,
-            location: merged.location,
-            supportedModes: this.parseSupportedModes(capabilityStrings) ?? ['direct', 'proxy'],
-        };
-        // If we have structured capabilities from the detector, use them to enhance the information
-        if (merged.detectedCapabilities) {
-            try {
-                const detected = merged.detectedCapabilities;
-                capabilities = {
-                    solidProtocolVersion: detected.solidProtocolVersion || capabilities.solidProtocolVersion,
-                    storageBackends: detected.storageBackends || capabilities.storageBackends,
-                    authMethods: detected.authMethods || capabilities.authMethods,
-                    maxBandwidth: detected.maxBandwidth || capabilities.maxBandwidth,
-                    location: detected.location || capabilities.location,
-                };
-            }
-            catch (error) {
-                this.logger.warn(`Failed to use detected capabilities: ${error.message}`);
-            }
-        }
-        return capabilities;
-    }
-    parseStorageBackends(capabilityStrings) {
-        if (!capabilityStrings || capabilityStrings.length === 0) {
-            return ['filesystem']; // default
-        }
-        const storageBackends = capabilityStrings
-            .filter(cap => cap.startsWith('storage:'))
-            .map(cap => cap.substring(8)); // remove 'storage:' prefix
-        return storageBackends.length > 0 ? storageBackends : ['filesystem'];
-    }
-    parseAuthMethods(capabilityStrings) {
-        if (!capabilityStrings || capabilityStrings.length === 0) {
-            return ['webid', 'client-credentials']; // defaults
-        }
-        const authMethods = capabilityStrings
-            .filter(cap => cap.startsWith('auth:'))
-            .map(cap => cap.substring(5)); // remove 'auth:' prefix
-        return authMethods.length > 0 ? authMethods : ['webid', 'client-credentials'];
-    }
-    parseSupportedModes(capabilityStrings) {
-        if (!capabilityStrings || capabilityStrings.length === 0) {
-            return undefined;
-        }
-        const modes = new Set();
-        for (const entry of capabilityStrings) {
-            if (typeof entry !== 'string' || !entry.startsWith('mode:')) {
-                continue;
-            }
-            const mode = entry.slice(5).trim().toLowerCase();
-            if (mode === 'redirect' || mode === 'direct') {
-                modes.add('direct');
-            }
-            if (mode === 'proxy') {
-                modes.add('proxy');
-            }
-        }
-        return modes.size > 0 ? [...modes] : undefined;
-    }
-    getSupportedModeFlags(metadata) {
-        const capabilityStrings = Array.isArray(metadata.capabilities) ?
-            metadata.capabilities.filter((entry) => typeof entry === 'string') :
-            undefined;
-        const parsed = this.parseSupportedModes(capabilityStrings) ?? ['direct', 'proxy'];
-        const set = new Set(parsed);
-        return {
-            supportsDirect: set.has('direct'),
-            supportsProxy: set.has('proxy'),
-        };
-    }
-    async applyRoutingDecision(nodeId, metadata, currentConnectivity) {
-        const desiredMode = this.determineAccessMode(metadata);
-        if (!desiredMode) {
-            return;
-        }
-        const currentMode = this.normalizeAccessMode(currentConnectivity?.accessMode);
-        if (currentMode === desiredMode.accessMode &&
-            currentConnectivity?.publicIp === desiredMode.publicIp &&
-            currentConnectivity?.subdomain === desiredMode.subdomain) {
-            metadata.accessMode = desiredMode.accessMode;
-            return;
-        }
-        await this.repo.updateNodeMode(nodeId, {
-            accessMode: desiredMode.accessMode,
-            publicIp: desiredMode.publicIp,
-            publicPort: desiredMode.publicPort,
-            subdomain: desiredMode.subdomain,
-            connectivityStatus: desiredMode.connectivityStatus,
-            capabilities: metadata.capabilities,
-        });
-        metadata.accessMode = desiredMode.accessMode;
-        metadata.subdomain = desiredMode.subdomain ?? metadata.subdomain;
-    }
-    determineAccessMode(metadata) {
-        const { supportsDirect, supportsProxy } = this.getSupportedModeFlags(metadata);
-        const reachability = this.asRecord(metadata.reachability);
-        const status = typeof reachability.status === 'string' ? reachability.status.trim().toLowerCase() : undefined;
-        const tunnel = this.asRecord(metadata.tunnel);
-        // Prefer direct if it is healthy and supported
-        const directHealthy = status === 'direct' || status === 'reachable' || status === 'redirect';
-        if (directHealthy && supportsDirect) {
-            return {
-                accessMode: 'direct',
-                publicIp: typeof metadata.publicIp === 'string' ? metadata.publicIp : undefined,
-                publicPort: typeof metadata.publicPort === 'number' ? metadata.publicPort : undefined,
-                subdomain: typeof metadata.subdomain === 'string' ? metadata.subdomain : undefined,
-                connectivityStatus: 'reachable',
-            };
-        }
-        // Fallback to proxy if supported and tunnel is active
-        if (supportsProxy && tunnel?.status === 'active') {
-            return {
-                accessMode: 'proxy',
-                publicIp: typeof metadata.publicIp === 'string' ? metadata.publicIp : undefined,
-                publicPort: typeof metadata.publicPort === 'number' ? metadata.publicPort : undefined,
-                subdomain: typeof metadata.subdomain === 'string' ? metadata.subdomain : undefined,
-                connectivityStatus: 'reachable',
-            };
-        }
-        // Proxy supported but inactive
-        if (supportsProxy && !supportsDirect) {
-            return {
-                accessMode: 'proxy',
-                connectivityStatus: 'unreachable',
-                subdomain: typeof metadata.subdomain === 'string' ? metadata.subdomain : undefined,
-            };
-        }
-        // Direct supported but currently unreachable
-        if (supportsDirect && status === 'unreachable') {
-            return {
-                accessMode: 'direct',
-                publicIp: typeof metadata.publicIp === 'string' ? metadata.publicIp : undefined,
-                publicPort: typeof metadata.publicPort === 'number' ? metadata.publicPort : undefined,
-                subdomain: typeof metadata.subdomain === 'string' ? metadata.subdomain : undefined,
-                connectivityStatus: 'unreachable',
-            };
-        }
-        return undefined;
-    }
-    normalizeAccessMode(mode) {
-        if (!mode) {
-            return undefined;
-        }
-        const normalized = mode.trim().toLowerCase();
-        if (normalized === 'redirect' || normalized === 'direct') {
-            return 'direct';
-        }
-        if (normalized === 'proxy') {
-            return 'proxy';
-        }
-        return undefined;
-    }
-}
-exports.EdgeNodeSignalHttpHandler = EdgeNodeSignalHttpHandler;
-//# sourceMappingURL=EdgeNodeSignalHttpHandler.js.map