@serve.zone/dcrouter 13.17.0 → 13.17.2

package/dist_ts/remoteingress/classes.remoteingress-manager.js

@@ -0,0 +1,291 @@
+import * as plugins from '../plugins.js';
+import { RemoteIngressEdgeDoc } from '../db/index.js';
+/**
+ * Flatten a port range (number | number[] | Array<{from, to}>) to a sorted unique number array.
+ */
+function extractPorts(portRange) {
+    const ports = new Set();
+    if (typeof portRange === 'number') {
+        ports.add(portRange);
+    }
+    else if (Array.isArray(portRange)) {
+        for (const entry of portRange) {
+            if (typeof entry === 'number') {
+                ports.add(entry);
+            }
+            else if (typeof entry === 'object' && 'from' in entry && 'to' in entry) {
+                for (let p = entry.from; p <= entry.to; p++) {
+                    ports.add(p);
+                }
+            }
+        }
+    }
+    return [...ports].sort((a, b) => a - b);
+}
+/**
+ * Manages CRUD for remote ingress edge registrations.
+ * Persists edge configs via smartdata document classes and provides
+ * the allowed edges list for the Rust hub.
+ */
+export class RemoteIngressManager {
+    edges = new Map();
+    routes = [];
+    constructor() {
+    }
+    /**
+     * Load all edge registrations from the database into memory.
+     */
+    async initialize() {
+        const docs = await RemoteIngressEdgeDoc.findAll();
+        for (const doc of docs) {
+            // Migration: old edges without autoDerivePorts default to true
+            if (doc.autoDerivePorts === undefined) {
+                doc.autoDerivePorts = true;
+                await doc.save();
+            }
+            const edge = {
+                id: doc.id,
+                name: doc.name,
+                secret: doc.secret,
+                listenPorts: doc.listenPorts,
+                listenPortsUdp: doc.listenPortsUdp,
+                enabled: doc.enabled,
+                autoDerivePorts: doc.autoDerivePorts,
+                tags: doc.tags,
+                createdAt: doc.createdAt,
+                updatedAt: doc.updatedAt,
+            };
+            this.edges.set(edge.id, edge);
+        }
+    }
+    /**
+     * Store the current route configs for port derivation.
+     */
+    setRoutes(routes) {
+        this.routes = routes;
+    }
+    /**
+     * Derive listen ports for an edge from routes tagged with remoteIngress.enabled.
+     * When a route specifies edgeFilter, only edges whose id or tags match get that route's ports.
+     * When edgeFilter is absent, the route applies to all edges.
+     */
+    derivePortsForEdge(edgeId, edgeTags) {
+        const ports = new Set();
+        for (const route of this.routes) {
+            if (!route.remoteIngress?.enabled)
+                continue;
+            // Apply edge filter if present
+            const filter = route.remoteIngress.edgeFilter;
+            if (filter && filter.length > 0) {
+                const idMatch = filter.includes(edgeId);
+                const tagMatch = edgeTags?.some((tag) => filter.includes(tag)) ?? false;
+                if (!idMatch && !tagMatch)
+                    continue;
+            }
+            // Extract ports from the route match
+            if (route.match?.ports) {
+                for (const p of extractPorts(route.match.ports)) {
+                    ports.add(p);
+                }
+            }
+        }
+        return [...ports].sort((a, b) => a - b);
+    }
+    /**
+     * Derive UDP listen ports for an edge from routes with transport 'udp' or 'all'.
+     * These ports need UDP listeners on the edge (e.g. for QUIC/HTTP3).
+     */
+    deriveUdpPortsForEdge(edgeId, edgeTags) {
+        const ports = new Set();
+        for (const route of this.routes) {
+            if (!route.remoteIngress?.enabled)
+                continue;
+            // Apply edge filter if present
+            const filter = route.remoteIngress.edgeFilter;
+            if (filter && filter.length > 0) {
+                const idMatch = filter.includes(edgeId);
+                const tagMatch = edgeTags?.some((tag) => filter.includes(tag)) ?? false;
+                if (!idMatch && !tagMatch)
+                    continue;
+            }
+            // Only include ports from routes that listen on UDP
+            const transport = route.match?.transport;
+            if (transport === 'udp' || transport === 'all') {
+                if (route.match?.ports) {
+                    for (const p of extractPorts(route.match.ports)) {
+                        ports.add(p);
+                    }
+                }
+            }
+        }
+        return [...ports].sort((a, b) => a - b);
+    }
+    /**
+     * Get the effective listen ports for an edge.
+     * Manual ports are always included. Auto-derived ports are added (union) when autoDerivePorts is true.
+     */
+    getEffectiveListenPorts(edge) {
+        const manualPorts = edge.listenPorts || [];
+        const shouldDerive = edge.autoDerivePorts !== false;
+        if (!shouldDerive)
+            return [...manualPorts].sort((a, b) => a - b);
+        const derivedPorts = this.derivePortsForEdge(edge.id, edge.tags);
+        return [...new Set([...manualPorts, ...derivedPorts])].sort((a, b) => a - b);
+    }
+    /**
+     * Get the effective UDP listen ports for an edge.
+     * Manual UDP ports are always included. Auto-derived UDP ports are added when autoDerivePorts is true.
+     */
+    getEffectiveListenPortsUdp(edge) {
+        const manualPorts = edge.listenPortsUdp || [];
+        const shouldDerive = edge.autoDerivePorts !== false;
+        if (!shouldDerive)
+            return [...manualPorts].sort((a, b) => a - b);
+        const derivedPorts = this.deriveUdpPortsForEdge(edge.id, edge.tags);
+        return [...new Set([...manualPorts, ...derivedPorts])].sort((a, b) => a - b);
+    }
+    /**
+     * Get manual and derived port breakdown for an edge (used in API responses).
+     * Derived ports exclude any ports already present in the manual list.
+     */
+    getPortBreakdown(edge) {
+        const manual = edge.listenPorts || [];
+        const shouldDerive = edge.autoDerivePorts !== false;
+        if (!shouldDerive)
+            return { manual, derived: [] };
+        const manualSet = new Set(manual);
+        const allDerived = this.derivePortsForEdge(edge.id, edge.tags);
+        const derived = allDerived.filter((p) => !manualSet.has(p));
+        return { manual, derived };
+    }
+    /**
+     * Create a new edge registration.
+     */
+    async createEdge(name, listenPorts = [], tags, autoDerivePorts = true) {
+        const id = plugins.uuid.v4();
+        const secret = plugins.crypto.randomBytes(32).toString('hex');
+        const now = Date.now();
+        const edge = {
+            id,
+            name,
+            secret,
+            listenPorts,
+            enabled: true,
+            autoDerivePorts,
+            tags: tags || [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        const doc = new RemoteIngressEdgeDoc();
+        Object.assign(doc, edge);
+        await doc.save();
+        this.edges.set(id, edge);
+        return edge;
+    }
+    /**
+     * Get an edge by ID.
+     */
+    getEdge(id) {
+        return this.edges.get(id);
+    }
+    /**
+     * Get all edge registrations.
+     */
+    getAllEdges() {
+        return Array.from(this.edges.values());
+    }
+    /**
+     * Update an edge registration.
+     */
+    async updateEdge(id, updates) {
+        const edge = this.edges.get(id);
+        if (!edge) {
+            return null;
+        }
+        if (updates.name !== undefined)
+            edge.name = updates.name;
+        if (updates.listenPorts !== undefined)
+            edge.listenPorts = updates.listenPorts;
+        if (updates.autoDerivePorts !== undefined)
+            edge.autoDerivePorts = updates.autoDerivePorts;
+        if (updates.enabled !== undefined)
+            edge.enabled = updates.enabled;
+        if (updates.tags !== undefined)
+            edge.tags = updates.tags;
+        edge.updatedAt = Date.now();
+        const doc = await RemoteIngressEdgeDoc.findById(id);
+        if (doc) {
+            Object.assign(doc, edge);
+            await doc.save();
+        }
+        this.edges.set(id, edge);
+        return edge;
+    }
+    /**
+     * Delete an edge registration.
+     */
+    async deleteEdge(id) {
+        if (!this.edges.has(id)) {
+            return false;
+        }
+        const doc = await RemoteIngressEdgeDoc.findById(id);
+        if (doc) {
+            await doc.delete();
+        }
+        this.edges.delete(id);
+        return true;
+    }
+    /**
+     * Regenerate the secret for an edge.
+     */
+    async regenerateSecret(id) {
+        const edge = this.edges.get(id);
+        if (!edge) {
+            return null;
+        }
+        edge.secret = plugins.crypto.randomBytes(32).toString('hex');
+        edge.updatedAt = Date.now();
+        const doc = await RemoteIngressEdgeDoc.findById(id);
+        if (doc) {
+            Object.assign(doc, edge);
+            await doc.save();
+        }
+        this.edges.set(id, edge);
+        return edge.secret;
+    }
+    /**
+     * Verify an edge's secret using constant-time comparison.
+     */
+    verifySecret(id, secret) {
+        const edge = this.edges.get(id);
+        if (!edge) {
+            return false;
+        }
+        const expected = Buffer.from(edge.secret);
+        const provided = Buffer.from(secret);
+        if (expected.length !== provided.length) {
+            return false;
+        }
+        return plugins.crypto.timingSafeEqual(expected, provided);
+    }
+    /**
+     * Get the list of allowed edges (enabled only) for the Rust hub.
+     * Includes listenPortsUdp when routes with transport 'udp' or 'all' are present.
+     */
+    getAllowedEdges() {
+        const result = [];
+        for (const edge of this.edges.values()) {
+            if (edge.enabled) {
+                const listenPortsUdp = this.getEffectiveListenPortsUdp(edge);
+                result.push({
+                    id: edge.id,
+                    secret: edge.secret,
+                    listenPorts: this.getEffectiveListenPorts(edge),
+                    ...(listenPortsUdp.length > 0 ? { listenPortsUdp } : {}),
+                });
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.remoteingress-manager.js","sourceRoot":"","sources":["../../../ts/remoteingress/classes.remoteingress-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/remoteingress/classes.tunnel-manager.d.ts

@@ -0,0 +1,59 @@
+import type { IRemoteIngressStatus } from '../../dist_ts_interfaces/data/remoteingress.js';
+import type { RemoteIngressManager } from './classes.remoteingress-manager.js';
+export interface ITunnelManagerConfig {
+    tunnelPort?: number;
+    targetHost?: string;
+    tls?: {
+        certPem?: string;
+        keyPem?: string;
+    };
+}
+/**
+ * Manages the RemoteIngressHub instance and tracks connected edge statuses.
+ */
+export declare class TunnelManager {
+    private hub;
+    private manager;
+    private config;
+    private edgeStatuses;
+    private reconcileInterval;
+    constructor(manager: RemoteIngressManager, config?: ITunnelManagerConfig);
+    /**
+     * Start the tunnel hub and load allowed edges.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the tunnel hub.
+     */
+    stop(): Promise<void>;
+    /**
+     * Reconcile TS-side edge statuses with the authoritative Rust hub status.
+     * Overwrites event-derived activeTunnels with the real activeStreams count.
+     */
+    private reconcile;
+    /**
+     * Sync allowed edges from the manager to the hub.
+     * Call this after creating/deleting/updating edges.
+     */
+    syncAllowedEdges(): Promise<void>;
+    /**
+     * Get runtime statuses for all known edges.
+     */
+    getEdgeStatuses(): IRemoteIngressStatus[];
+    /**
+     * Get status for a specific edge.
+     */
+    getEdgeStatus(edgeId: string): IRemoteIngressStatus | undefined;
+    /**
+     * Get the count of connected edges.
+     */
+    getConnectedCount(): number;
+    /**
+     * Get the public IPs of all connected edges.
+     */
+    getConnectedEdgeIps(): string[];
+    /**
+     * Get the total number of active tunnels across all edges.
+     */
+    getTotalActiveTunnels(): number;
+}

package/dist_ts/remoteingress/classes.tunnel-manager.js

@@ -0,0 +1,165 @@
+import * as plugins from '../plugins.js';
+/**
+ * Manages the RemoteIngressHub instance and tracks connected edge statuses.
+ */
+export class TunnelManager {
+    hub;
+    manager;
+    config;
+    edgeStatuses = new Map();
+    reconcileInterval = null;
+    constructor(manager, config = {}) {
+        this.manager = manager;
+        this.config = config;
+        this.hub = new plugins.remoteingress.RemoteIngressHub();
+        // Listen for edge connect/disconnect events
+        this.hub.on('edgeConnected', (data) => {
+            this.edgeStatuses.set(data.edgeId, {
+                edgeId: data.edgeId,
+                connected: true,
+                publicIp: data.peerAddr || null,
+                activeTunnels: 0,
+                lastHeartbeat: Date.now(),
+                connectedAt: Date.now(),
+            });
+        });
+        this.hub.on('edgeDisconnected', (data) => {
+            this.edgeStatuses.delete(data.edgeId);
+        });
+        this.hub.on('streamOpened', (data) => {
+            const existing = this.edgeStatuses.get(data.edgeId);
+            if (existing) {
+                existing.activeTunnels++;
+                existing.lastHeartbeat = Date.now();
+            }
+        });
+        this.hub.on('streamClosed', (data) => {
+            const existing = this.edgeStatuses.get(data.edgeId);
+            if (existing && existing.activeTunnels > 0) {
+                existing.activeTunnels--;
+            }
+        });
+    }
+    /**
+     * Start the tunnel hub and load allowed edges.
+     */
+    async start() {
+        await this.hub.start({
+            tunnelPort: this.config.tunnelPort ?? 8443,
+            targetHost: this.config.targetHost ?? '127.0.0.1',
+            tls: this.config.tls,
+        });
+        // Send allowed edges to the hub
+        await this.syncAllowedEdges();
+        // Periodically reconcile with authoritative Rust hub status
+        this.reconcileInterval = setInterval(() => {
+            this.reconcile().catch(() => { });
+        }, 15_000);
+    }
+    /**
+     * Stop the tunnel hub.
+     */
+    async stop() {
+        if (this.reconcileInterval) {
+            clearInterval(this.reconcileInterval);
+            this.reconcileInterval = null;
+        }
+        // Remove event listeners before stopping to prevent leaks
+        this.hub.removeAllListeners();
+        await this.hub.stop();
+        this.edgeStatuses.clear();
+    }
+    /**
+     * Reconcile TS-side edge statuses with the authoritative Rust hub status.
+     * Overwrites event-derived activeTunnels with the real activeStreams count.
+     */
+    async reconcile() {
+        const hubStatus = await this.hub.getStatus();
+        if (!hubStatus || !hubStatus.connectedEdges)
+            return;
+        const rustEdgeIds = new Set();
+        for (const rustEdge of hubStatus.connectedEdges) {
+            rustEdgeIds.add(rustEdge.edgeId);
+            const existing = this.edgeStatuses.get(rustEdge.edgeId);
+            if (existing) {
+                existing.activeTunnels = rustEdge.activeStreams;
+                existing.lastHeartbeat = Date.now();
+                // Update peer address if available from Rust hub
+                if (rustEdge.peerAddr) {
+                    existing.publicIp = rustEdge.peerAddr;
+                }
+            }
+            else {
+                // Missed edgeConnected event — add entry
+                this.edgeStatuses.set(rustEdge.edgeId, {
+                    edgeId: rustEdge.edgeId,
+                    connected: true,
+                    publicIp: rustEdge.peerAddr || null,
+                    activeTunnels: rustEdge.activeStreams,
+                    lastHeartbeat: Date.now(),
+                    connectedAt: rustEdge.connectedAt * 1000,
+                });
+            }
+        }
+        // Remove entries for edges no longer connected in Rust (missed edgeDisconnected)
+        for (const edgeId of this.edgeStatuses.keys()) {
+            if (!rustEdgeIds.has(edgeId)) {
+                this.edgeStatuses.delete(edgeId);
+            }
+        }
+    }
+    /**
+     * Sync allowed edges from the manager to the hub.
+     * Call this after creating/deleting/updating edges.
+     */
+    async syncAllowedEdges() {
+        const edges = this.manager.getAllowedEdges();
+        await this.hub.updateAllowedEdges(edges);
+    }
+    /**
+     * Get runtime statuses for all known edges.
+     */
+    getEdgeStatuses() {
+        return Array.from(this.edgeStatuses.values());
+    }
+    /**
+     * Get status for a specific edge.
+     */
+    getEdgeStatus(edgeId) {
+        return this.edgeStatuses.get(edgeId);
+    }
+    /**
+     * Get the count of connected edges.
+     */
+    getConnectedCount() {
+        let count = 0;
+        for (const status of this.edgeStatuses.values()) {
+            if (status.connected)
+                count++;
+        }
+        return count;
+    }
+    /**
+     * Get the public IPs of all connected edges.
+     */
+    getConnectedEdgeIps() {
+        const ips = [];
+        for (const status of this.edgeStatuses.values()) {
+            if (status.connected && status.publicIp) {
+                ips.push(status.publicIp);
+            }
+        }
+        return ips;
+    }
+    /**
+     * Get the total number of active tunnels across all edges.
+     */
+    getTotalActiveTunnels() {
+        let total = 0;
+        for (const status of this.edgeStatuses.values()) {
+            total += status.activeTunnels;
+        }
+        return total;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/remoteingress/index.d.ts

@@ -0,0 +1,2 @@
+export * from './classes.remoteingress-manager.js';
+export * from './classes.tunnel-manager.js';

package/dist_ts/remoteingress/index.js

@@ -0,0 +1,3 @@
+export * from './classes.remoteingress-manager.js';
+export * from './classes.tunnel-manager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9yZW1vdGVpbmdyZXNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyw2QkFBNkIsQ0FBQyJ9