feat(remoteingress): derive effective remote ingress listen ports from route configs and expose them via ops API

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '6.5.0',
+  version: '6.6.0',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

ts/classes.dcrouter.ts

@@ -955,10 +955,15 @@ export class DcRouter {
     
     // Update configuration
     this.options.smartProxyConfig = config;
-    
+
+    // Update routes on RemoteIngressManager so derived ports stay in sync
+    if (this.remoteIngressManager && config.routes) {
+      this.remoteIngressManager.setRoutes(config.routes as any[]);
+    }
+
     // Start new SmartProxy with updated configuration (will include email routes if configured)
     await this.setupSmartProxy();
-    
+
     console.log('SmartProxy configuration updated');
   }
   
@@ -1587,6 +1592,10 @@ export class DcRouter {
     this.remoteIngressManager = new RemoteIngressManager(this.storageManager);
     await this.remoteIngressManager.initialize();
 
+    // Pass current routes so the manager can derive edge ports from remoteIngress-tagged routes
+    const currentRoutes = this.options.smartProxyConfig?.routes || [];
+    this.remoteIngressManager.setRoutes(currentRoutes as any[]);
+
     // Create and start the tunnel manager
     this.tunnelManager = new TunnelManager(this.remoteIngressManager, {
       tunnelPort: this.options.remoteIngressConfig.tunnelPort ?? 8443,

ts/opsserver/handlers/remoteingress.handler.ts

@@ -20,10 +20,11 @@ export class RemoteIngressHandler {
           if (!manager) {
             return { edges: [] };
           }
-          // Return edges without secrets
+          // Return edges without secrets, enriched with effective listen ports
           const edges = manager.getAllEdges().map((e) => ({
             ...e,
             secret: '********', // Never expose secrets via API
+            effectiveListenPorts: manager.getEffectiveListenPorts(e),
           }));
           return { edges };
         },
@@ -47,7 +48,7 @@ export class RemoteIngressHandler {
 
           const edge = await manager.createEdge(
             dataArg.name,
-            dataArg.listenPorts,
+            dataArg.listenPorts || [],
             dataArg.tags,
           );
 

ts/remoteingress/classes.remoteingress-manager.ts

@@ -1,9 +1,30 @@
 import * as plugins from '../plugins.js';
 import type { StorageManager } from '../storage/classes.storagemanager.js';
-import type { IRemoteIngress } from '../../ts_interfaces/data/remoteingress.js';
+import type { IRemoteIngress, IDcRouterRouteConfig } from '../../ts_interfaces/data/remoteingress.js';
 
 const STORAGE_PREFIX = '/remote-ingress/';
 
+/**
+ * Flatten a port range (number | number[] | Array<{from, to}>) to a sorted unique number array.
+ */
+function extractPorts(portRange: number | number[] | Array<{ from: number; to: number }>): number[] {
+  const ports = new Set<number>();
+  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 StorageManager and provides
@@ -12,6 +33,7 @@ const STORAGE_PREFIX = '/remote-ingress/';
 export class RemoteIngressManager {
   private storageManager: StorageManager;
   private edges: Map<string, IRemoteIngress> = new Map();
+  private routes: IDcRouterRouteConfig[] = [];
 
   constructor(storageManager: StorageManager) {
     this.storageManager = storageManager;
@@ -30,12 +52,60 @@ export class RemoteIngressManager {
     }
   }
 
+  /**
+   * Store the current route configs for port derivation.
+   */
+  public setRoutes(routes: IDcRouterRouteConfig[]): void {
+    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.
+   */
+  public derivePortsForEdge(edgeId: string, edgeTags?: string[]): number[] {
+    const ports = new Set<number>();
+
+    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);
+  }
+
+  /**
+   * Get the effective listen ports for an edge.
+   * Returns manual listenPorts if non-empty, otherwise derives ports from tagged routes.
+   */
+  public getEffectiveListenPorts(edge: IRemoteIngress): number[] {
+    if (edge.listenPorts && edge.listenPorts.length > 0) {
+      return edge.listenPorts;
+    }
+    return this.derivePortsForEdge(edge.id, edge.tags);
+  }
+
   /**
    * Create a new edge registration.
    */
   public async createEdge(
     name: string,
-    listenPorts: number[],
+    listenPorts: number[] = [],
     tags?: string[],
   ): Promise<IRemoteIngress> {
     const id = plugins.uuid.v4();