@serve.zone/dcrouter 16.4.1 → 17.0.0

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

@@ -20,8 +20,14 @@ export type TRemoteIngressEgressProxyRequest = Omit<plugins.remoteingress.IEgres
   edgeFilter?: string[];
 };
 
+export type TRemoteIngressHubStatus = Awaited<ReturnType<
+  InstanceType<typeof plugins.remoteingress.RemoteIngressHub>['getStatus']
+>>;
+type TRemoteIngressHubEdgeStatus = TRemoteIngressHubStatus['connectedEdges'][number];
+
 /** Cooldown applied to an edge after a failed egress open before it is deprioritized. */
 const egressFailureCooldownMs = 30_000;
+const egressStatusFreshnessMs = 45_000;
 
 /**
  * Manages the RemoteIngressHub instance and tracks connected edge statuses.
@@ -38,6 +44,7 @@ export class TunnelManager {
   private egressProxyEdgeByProxyId: Map<string, string> = new Map();
   private activeEgressProxiesByEdge: Map<string, number> = new Map();
   private egressFailureCooldownUntil: Map<string, number> = new Map();
+  private onTopologyChanged?: (reason: string) => void;
 
   constructor(manager: RemoteIngressManager, config: ITunnelManagerConfig = {}) {
     this.manager = manager;
@@ -54,10 +61,12 @@ export class TunnelManager {
         lastHeartbeat: Date.now(),
         connectedAt: Date.now(),
       });
+      this.onTopologyChanged?.(`RemoteIngress edge connected: ${data.edgeId}`);
     });
 
     this.hub.on('edgeDisconnected', (data: { edgeId: string }) => {
       this.edgeStatuses.delete(data.edgeId);
+      this.onTopologyChanged?.(`RemoteIngress edge disconnected: ${data.edgeId}`);
     });
 
     this.hub.on('streamSummary', (data: {
@@ -94,6 +103,14 @@ export class TunnelManager {
         this.egressFailureCooldownUntil.set(data.edgeId, Date.now() + egressFailureCooldownMs);
       }
     });
+
+    this.hub.on('egressIdentityChanged', (data) => {
+      this.onTopologyChanged?.(`RemoteIngress egress identity changed: ${data.edgeId}`);
+    });
+  }
+
+  public setOnTopologyChanged(callback: (reason: string) => void): void {
+    this.onTopologyChanged = callback;
   }
 
   /**
@@ -165,6 +182,7 @@ export class TunnelManager {
     if (this.stopped) return;
     if (!hubStatus || !hubStatus.connectedEdges) return;
 
+    const before = this.getTopologySignature();
     const rustEdgeIds = new Set<string>();
 
     for (const rustEdge of hubStatus.connectedEdges) {
@@ -199,6 +217,10 @@ export class TunnelManager {
         this.edgeStatuses.delete(edgeId);
       }
     }
+    const after = this.getTopologySignature();
+    if (before !== after) {
+      this.onTopologyChanged?.('RemoteIngress mail egress topology changed');
+    }
   }
 
   /**
@@ -260,33 +282,43 @@ export class TunnelManager {
     );
   }
 
+  /** Authoritative hub state used by the source-bound mail identity adapter. */
+  public async getAuthoritativeHubStatus(): Promise<TRemoteIngressHubStatus | undefined> {
+    if (this.stopped) return undefined;
+    return await this.hub.getStatus();
+  }
+
   /**
    * Eligibility (connected + egressEnabled + egressTcpV1 + native QUIC), scoped by
    * edgeId/edgeFilter, capped by per-edge maxConcurrentStreams, ordered deterministically:
    * not-in-cooldown first, then fewest active tunnels, then edgeId.
    */
   private selectEgressCandidates(
-    connectedEdges: any[],
+    connectedEdges: TRemoteIngressHubEdgeStatus[],
     request: TRemoteIngressEgressProxyRequest,
   ): Array<{ edgeId: string; activeStreams: number }> {
     const eligible = connectedEdges.filter((edge: any) => {
       const hasEgressCapability = Array.isArray(edge.capabilities) && edge.capabilities.includes('egressTcpV1');
       const usesQuic = edge.transportMode === 'quic'
         || (edge.transportMode === 'quicWithFallback' && edge.fallbackUsed === false);
-      return edge.egressEnabled === true && hasEgressCapability && usesQuic;
+      const observed = this.edgeStatuses.get(edge.edgeId);
+      const fresh = observed?.connected
+        && observed.lastHeartbeat !== null
+        && Date.now() - observed.lastHeartbeat <= egressStatusFreshnessMs;
+      return edge.egressEnabled === true && hasEgressCapability && usesQuic && fresh;
     });
 
     let scoped = eligible;
     if (request.edgeId) {
-      scoped = eligible.filter((edge: any) => edge.edgeId === request.edgeId);
+      scoped = eligible.filter((edge) => edge.edgeId === request.edgeId);
     } else if (request.edgeFilter && request.edgeFilter.length > 0) {
       const allowedIds = new Set(
         this.manager.resolveEdgesByFilter(request.edgeFilter).map((edge) => edge.id),
       );
-      scoped = eligible.filter((edge: any) => allowedIds.has(edge.edgeId));
+      scoped = eligible.filter((edge) => allowedIds.has(edge.edgeId));
     }
 
-    const underCap = scoped.filter((edge: any) => {
+    const underCap = scoped.filter((edge) => {
       const cap = this.manager.getEdge(edge.edgeId)?.egress?.maxConcurrentStreams;
       if (!cap) return true;
       return (this.activeEgressProxiesByEdge.get(edge.edgeId) || 0) < cap;
@@ -295,7 +327,7 @@ export class TunnelManager {
     const now = Date.now();
     const inCooldown = (edgeId: string) => (this.egressFailureCooldownUntil.get(edgeId) || 0) > now;
     return underCap
-      .map((edge: any) => ({ edgeId: edge.edgeId as string, activeStreams: Number(edge.activeStreams) || 0 }))
+      .map((edge) => ({ edgeId: edge.edgeId, activeStreams: Number(edge.activeStreams) || 0 }))
       .sort((a, b) => {
         const cooldownDelta = Number(inCooldown(a.edgeId)) - Number(inCooldown(b.edgeId));
         if (cooldownDelta !== 0) return cooldownDelta;
@@ -355,7 +387,7 @@ export class TunnelManager {
     return await this.hub.stopEgressTcpProxy(proxyId);
   }
 
-  private applyRustStatus(status: IRemoteIngressStatus, rustEdge: any): void {
+  private applyRustStatus(status: IRemoteIngressStatus, rustEdge: TRemoteIngressHubEdgeStatus): void {
     status.transportMode = rustEdge.transportMode;
     status.fallbackUsed = rustEdge.fallbackUsed;
     status.capabilities = rustEdge.capabilities;
@@ -367,6 +399,20 @@ export class TunnelManager {
     status.udp = rustEdge.udp;
   }
 
+  private getTopologySignature(): string {
+    return [...this.edgeStatuses.values()]
+      .map((status) => [
+        status.edgeId,
+        status.connected,
+        status.egressEnabled,
+        status.transportMode,
+        status.fallbackUsed,
+        [...(status.capabilities || [])].sort().join(','),
+      ].join('|'))
+      .sort()
+      .join(';');
+  }
+
   /**
    * Get runtime statuses for all known edges.
    */

package/ts_web/00_commitinfo_data.ts

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

package/ts_web/appstate/email-domains.ts

@@ -8,10 +8,26 @@ import { getActionContext } from './login.js';
 // Email Domains State
 // ============================================================================
 
+export type TEmailDomainOperationName =
+  | 'create'
+  | 'update'
+  | 'delete'
+  | 'validate'
+  | 'provision'
+  | 'reconcile'
+  | 'rotate';
+
+export interface IEmailDomainOperationState extends interfaces.requests.IEmailDomainActionResult {
+  operation: TEmailDomainOperationName;
+  completedAt: number;
+}
+
 export interface IEmailDomainsState {
   domains: interfaces.data.IEmailDomain[];
   settings: interfaces.data.IEmailServerSettings | null;
   isLoading: boolean;
+  error: string | null;
+  lastOperation: IEmailDomainOperationState | null;
   lastUpdated: number;
 }
 
@@ -21,11 +37,84 @@ export const emailDomainsStatePart = await appState.getStatePart<IEmailDomainsSt
     domains: [],
     settings: null,
     isLoading: false,
+    error: null,
+    lastOperation: null,
     lastUpdated: 0,
   },
   'soft',
 );
 
+const createOperationState = (
+  operationArg: TEmailDomainOperationName,
+  responseArg: interfaces.requests.IEmailDomainActionResult,
+): IEmailDomainOperationState => ({
+  operation: operationArg,
+  completedAt: Date.now(),
+  ...responseArg,
+});
+
+const createFailedOperationState = (
+  operationArg: TEmailDomainOperationName,
+  errorArg: unknown,
+  fallbackMessageArg: string,
+): IEmailDomainOperationState => ({
+  operation: operationArg,
+  completedAt: Date.now(),
+  success: false,
+  message: errorArg instanceof Error ? errorArg.message : fallbackMessageArg,
+  code: 'EMAIL_DOMAIN_REQUEST_FAILED',
+  errors: [
+    {
+      code: 'EMAIL_DOMAIN_REQUEST_FAILED',
+      message: errorArg instanceof Error ? errorArg.message : fallbackMessageArg,
+      retryable: true,
+    },
+  ],
+});
+
+export const formatEmailDomainOperationMessage = (
+  operationArg: IEmailDomainOperationState,
+  fallbackMessageArg: string,
+): string => {
+  const primaryMessage = operationArg.message || fallbackMessageArg;
+  const messageParts = [
+    operationArg.code ? `${primaryMessage} [${operationArg.code}]` : primaryMessage,
+  ];
+  for (const error of operationArg.errors || []) {
+    const location = error.recordKey ? `${error.recordKey}: ` : '';
+    const detail = `${location}${error.message} [${error.code}]`;
+    const duplicatesPrimary =
+      !error.recordKey &&
+      error.message === primaryMessage &&
+      error.code === operationArg.code;
+    if (!duplicatesPrimary && !messageParts.includes(detail)) {
+      messageParts.push(detail);
+    }
+  }
+  if (operationArg.lifecycleStatus && operationArg.lifecycleStatus !== 'active') {
+    messageParts.push(`Lifecycle: ${operationArg.lifecycleStatus}`);
+  }
+  if (operationArg.capability === 'unsupported' && !messageParts.some((part) => part.includes('unsupported'))) {
+    messageParts.push('Required capability is unsupported');
+  }
+  if (operationArg.retryAt) {
+    messageParts.push(`Retry scheduled for ${operationArg.retryAt}`);
+  }
+  return messageParts.join(' — ');
+};
+
+const applyOperationState = (
+  stateArg: IEmailDomainsState,
+  operationArg: IEmailDomainOperationState,
+  fallbackMessageArg: string,
+): IEmailDomainsState => ({
+  ...stateArg,
+  error: operationArg.success
+    ? null
+    : formatEmailDomainOperationMessage(operationArg, fallbackMessageArg),
+  lastOperation: operationArg,
+});
+
 export const fetchEmailDomainsAction = emailDomainsStatePart.createAction(
   async (statePartArg): Promise<IEmailDomainsState> => {
     const context = getActionContext();
@@ -46,10 +135,15 @@ export const fetchEmailDomainsAction = emailDomainsStatePart.createAction(
         domains: response.domains,
         settings: settingsResponse.settings,
         isLoading: false,
+        error: null,
         lastUpdated: Date.now(),
       };
-    } catch {
-      return { ...currentState, isLoading: false };
+    } catch (error: unknown) {
+      return {
+        ...currentState,
+        isLoading: false,
+        error: error instanceof Error ? error.message : 'Failed to fetch email domains',
+      };
     }
   },
 );
@@ -61,17 +155,62 @@ export const createEmailDomainAction = emailDomainsStatePart.createAction<{
   dkimKeySize?: number;
   rotateKeys?: boolean;
   rotationIntervalDays?: number;
+  remoteIngress?: interfaces.data.IEmailDomainRemoteIngress;
 }>(async (statePartArg, args, actionContext) => {
   const context = getActionContext();
   const currentState = statePartArg.getState()!;
+  if (!context.identity) {
+    const operation = createFailedOperationState('create', new Error('Not authenticated'), 'Not authenticated');
+    return applyOperationState(currentState, operation, 'Failed to create email domain');
+  }
   try {
     const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
       interfaces.requests.IReq_CreateEmailDomain
     >('/typedrequest', 'createEmailDomain');
-    await request.fire({ identity: context.identity!, ...args });
-    return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-  } catch {
-    return currentState;
+    const response = await request.fire({ identity: context.identity, ...args });
+    const operation = createOperationState('create', response);
+    if (!response.success) {
+      return applyOperationState(currentState, operation, 'Failed to create email domain');
+    }
+    const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+    return applyOperationState(refreshedState, operation, 'Email domain created');
+  } catch (error: unknown) {
+    const operation = createFailedOperationState('create', error, 'Failed to create email domain');
+    return applyOperationState(currentState, operation, 'Failed to create email domain');
+  }
+});
+
+export const updateEmailDomainAction = emailDomainsStatePart.createAction<{
+  id: string;
+  rotateKeys?: boolean;
+  rotationIntervalDays?: number;
+  rateLimits?: interfaces.data.IEmailDomain['rateLimits'];
+  remoteIngress?: interfaces.data.IEmailDomainRemoteIngress | null;
+}>(async (statePartArg, args, actionContext) => {
+  const context = getActionContext();
+  const currentState = statePartArg.getState()!;
+  if (!context.identity) {
+    const operation = createFailedOperationState(
+      'update',
+      new Error('Not authenticated'),
+      'Not authenticated',
+    );
+    return applyOperationState(currentState, operation, 'Failed to update email domain');
+  }
+  try {
+    const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_UpdateEmailDomain
+    >('/typedrequest', 'updateEmailDomain');
+    const response = await request.fire({ identity: context.identity, ...args });
+    const operation = createOperationState('update', response);
+    if (!response.success) {
+      return applyOperationState(currentState, operation, 'Failed to update email domain');
+    }
+    const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+    return applyOperationState(refreshedState, operation, 'Email domain updated');
+  } catch (error: unknown) {
+    const operation = createFailedOperationState('update', error, 'Failed to update email domain');
+    return applyOperationState(currentState, operation, 'Failed to update email domain');
   }
 });
 
@@ -98,14 +237,24 @@ export const deleteEmailDomainAction = emailDomainsStatePart.createAction<string
   async (statePartArg, id, actionContext) => {
     const context = getActionContext();
     const currentState = statePartArg.getState()!;
+    if (!context.identity) {
+      const operation = createFailedOperationState('delete', new Error('Not authenticated'), 'Not authenticated');
+      return applyOperationState(currentState, operation, 'Failed to delete email domain');
+    }
     try {
       const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_DeleteEmailDomain
       >('/typedrequest', 'deleteEmailDomain');
-      await request.fire({ identity: context.identity!, id });
-      return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-    } catch {
-      return currentState;
+      const response = await request.fire({ identity: context.identity, id });
+      const operation = createOperationState('delete', response);
+      if (!response.success) {
+        return applyOperationState(currentState, operation, 'Failed to delete email domain');
+      }
+      const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+      return applyOperationState(refreshedState, operation, 'Email domain deleted');
+    } catch (error: unknown) {
+      const operation = createFailedOperationState('delete', error, 'Failed to delete email domain');
+      return applyOperationState(currentState, operation, 'Failed to delete email domain');
     }
   },
 );
@@ -114,14 +263,24 @@ export const validateEmailDomainAction = emailDomainsStatePart.createAction<stri
   async (statePartArg, id, actionContext) => {
     const context = getActionContext();
     const currentState = statePartArg.getState()!;
+    if (!context.identity) {
+      const operation = createFailedOperationState('validate', new Error('Not authenticated'), 'Not authenticated');
+      return applyOperationState(currentState, operation, 'Failed to validate email domain DNS');
+    }
     try {
       const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_ValidateEmailDomain
       >('/typedrequest', 'validateEmailDomain');
-      await request.fire({ identity: context.identity!, id });
-      return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-    } catch {
-      return currentState;
+      const response = await request.fire({ identity: context.identity, id });
+      const operation = createOperationState('validate', response);
+      if (!response.success) {
+        return applyOperationState(currentState, operation, 'Failed to validate email domain DNS');
+      }
+      const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+      return applyOperationState(refreshedState, operation, 'Email domain DNS validated');
+    } catch (error: unknown) {
+      const operation = createFailedOperationState('validate', error, 'Failed to validate email domain DNS');
+      return applyOperationState(currentState, operation, 'Failed to validate email domain DNS');
     }
   },
 );
@@ -130,14 +289,24 @@ export const provisionEmailDomainDnsAction = emailDomainsStatePart.createAction<
   async (statePartArg, id, actionContext) => {
     const context = getActionContext();
     const currentState = statePartArg.getState()!;
+    if (!context.identity) {
+      const operation = createFailedOperationState('provision', new Error('Not authenticated'), 'Not authenticated');
+      return applyOperationState(currentState, operation, 'Failed to provision email domain DNS');
+    }
     try {
       const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
         interfaces.requests.IReq_ProvisionEmailDomainDns
       >('/typedrequest', 'provisionEmailDomainDns');
-      await request.fire({ identity: context.identity!, id });
-      return await actionContext!.dispatch(fetchEmailDomainsAction, null);
-    } catch {
-      return currentState;
+      const response = await request.fire({ identity: context.identity, id });
+      const operation = createOperationState('provision', response);
+      if (!response.success) {
+        return applyOperationState(currentState, operation, 'Failed to provision email domain DNS');
+      }
+      const refreshedState = await actionContext!.dispatch(fetchEmailDomainsAction, null);
+      return applyOperationState(refreshedState, operation, 'Email domain DNS provisioned');
+    } catch (error: unknown) {
+      const operation = createFailedOperationState('provision', error, 'Failed to provision email domain DNS');
+      return applyOperationState(currentState, operation, 'Failed to provision email domain DNS');
     }
   },
 );

package/ts_web/elements/email/ops-view-email-domains.ts

@@ -218,12 +218,11 @@ export class OpsViewEmailDomains extends DeesElement {
               type: ['inRow', 'contextmenu'] as any,
               actionFunc: async (actionData: any) => {
                 const d = actionData.item as interfaces.data.IEmailDomain;
-                await appstate.emailDomainsStatePart.dispatchAction(
+                const nextState = await appstate.emailDomainsStatePart.dispatchAction(
                   appstate.validateEmailDomainAction,
                   d.id,
                 );
-                const { DeesToast } = await import('@design.estate/dees-catalog');
-                DeesToast.show({ message: `DNS validated for ${d.domain}`, type: 'success', duration: 2500 });
+                await this.showOperationToast(nextState, `DNS validated for ${d.domain}`);
               },
             },
             {
@@ -232,12 +231,11 @@ export class OpsViewEmailDomains extends DeesElement {
               type: ['inRow', 'contextmenu'] as any,
               actionFunc: async (actionData: any) => {
                 const d = actionData.item as interfaces.data.IEmailDomain;
-                await appstate.emailDomainsStatePart.dispatchAction(
+                const nextState = await appstate.emailDomainsStatePart.dispatchAction(
                   appstate.provisionEmailDomainDnsAction,
                   d.id,
                 );
-                const { DeesToast } = await import('@design.estate/dees-catalog');
-                DeesToast.show({ message: `DNS records provisioned for ${d.domain}`, type: 'success', duration: 2500 });
+                await this.showOperationToast(nextState, `DNS records provisioned for ${d.domain}`);
               },
             },
             {
@@ -255,10 +253,11 @@ export class OpsViewEmailDomains extends DeesElement {
               type: ['inRow', 'contextmenu'] as any,
               actionFunc: async (actionData: any) => {
                 const d = actionData.item as interfaces.data.IEmailDomain;
-                await appstate.emailDomainsStatePart.dispatchAction(
+                const nextState = await appstate.emailDomainsStatePart.dispatchAction(
                   appstate.deleteEmailDomainAction,
                   d.id,
                 );
+                await this.showOperationToast(nextState, `Email domain ${d.domain} deleted`);
               },
             },
           ]}
@@ -282,6 +281,32 @@ export class OpsViewEmailDomains extends DeesElement {
     return html`<span class="sourceBadge">${label}</span>`;
   }
 
+  private async showOperationToast(
+    stateArg: appstate.IEmailDomainsState,
+    successMessageArg: string,
+  ): Promise<boolean> {
+    const { DeesToast } = await import('@design.estate/dees-catalog');
+    const operation = stateArg.lastOperation;
+    if (!operation) {
+      DeesToast.show({
+        message: stateArg.error || 'Email domain operation returned no result',
+        type: 'error',
+        duration: 5000,
+      });
+      return false;
+    }
+
+    const isPending = operation.success &&
+      operation.lifecycleStatus !== undefined &&
+      operation.lifecycleStatus !== 'active';
+    DeesToast.show({
+      message: appstate.formatEmailDomainOperationMessage(operation, successMessageArg),
+      type: operation.success ? (isPending ? 'warning' : 'success') : 'error',
+      duration: operation.success && !isPending ? 3000 : 6000,
+    });
+    return operation.success;
+  }
+
   private parsePortList(value: string): number[] {
     return value
       .split(',')
@@ -454,7 +479,7 @@ export class OpsViewEmailDomains extends DeesElement {
                 : parseInt(data.dkimKeySize || '2048', 10);
 
             const subdomain = data.subdomain?.trim() || undefined;
-            await appstate.emailDomainsStatePart.dispatchAction(
+            const nextState = await appstate.emailDomainsStatePart.dispatchAction(
               appstate.createEmailDomainAction,
               {
                 linkedDomainId,
@@ -464,7 +489,11 @@ export class OpsViewEmailDomains extends DeesElement {
                 rotateKeys: Boolean(data.rotateKeys),
               },
             );
-            m.destroy();
+            const wasAccepted = await this.showOperationToast(
+              nextState,
+              `Email domain created`,
+            );
+            if (wasAccepted) m.destroy();
           },
         },
       ],
@@ -513,12 +542,15 @@ export class OpsViewEmailDomains extends DeesElement {
         {
           name: 'Auto-Provision All',
           action: async (m: any) => {
-            await appstate.emailDomainsStatePart.dispatchAction(
+            const nextState = await appstate.emailDomainsStatePart.dispatchAction(
               appstate.provisionEmailDomainDnsAction,
               emailDomain.id,
             );
-            DeesToast.show({ message: 'DNS records provisioned', type: 'success', duration: 2500 });
-            m.destroy();
+            const wasAccepted = await this.showOperationToast(
+              nextState,
+              `DNS records provisioned for ${emailDomain.domain}`,
+            );
+            if (wasAccepted) m.destroy();
           },
         },
         { name: 'Close', action: async (m: any) => m.destroy() },