@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/http/admin/EdgeNodeSignalHttpHandler.js

@@ -0,0 +1,674 @@
+"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