@serve.zone/dcrouter 18.6.2 → 18.7.1

package/ts/email/classes.mail-egress-coordinator.ts

@@ -6,7 +6,8 @@ import * as plugins from '../plugins.js';
 import { logger } from '../logger.js';
 import type { IEmailOutboundEgressStatus, TEmailOutboundMode } from '../../ts_interfaces/data/email-settings.js';
 import type { DcRouter } from '../classes.dcrouter.js';
-import type { MailEdgeEligibility } from './classes.mail-edge-eligibility.js';
+import type { IEligibleMailEdge, MailEdgeEligibility } from './classes.mail-edge-eligibility.js';
+import { EmailDomainDoc } from '../db/documents/classes.email-domain.doc.js';
 
 /**
  * Routes outbound SMTP deliveries over RemoteIngress edges: resolves the
@@ -33,7 +34,10 @@ export class MailEgressCoordinator {
   ): Promise<IOutboundConnectionProxy | null> {
     const mode = this.resolveOutboundModeStrict();
     if (mode === 'direct') {
-      if (context.senderDomain && await this.dcRouterRef.emailDomainManager?.getByDomain(context.senderDomain)) {
+      if (context.senderDomain && !this.dcRouterRef.emailDomainManager) {
+        throw new Error('EmailDomainManager is unavailable; refusing to classify a sender for direct hub delivery');
+      }
+      if (context.senderDomain && await this.dcRouterRef.emailDomainManager!.getByDomain(context.senderDomain)) {
         throw new Error(
           `Managed sender domain ${context.senderDomain} has no validated direct-egress identity policy; refusing direct hub delivery`,
         );
@@ -101,8 +105,16 @@ export class MailEgressCoordinator {
     await this.assertTargetIsNotOwnMailEdge(context);
 
     const managedDoc = context.senderDomain
-      ? await (await import('../db/documents/classes.email-domain.doc.js')).EmailDomainDoc.findByDomain(context.senderDomain)
+      ? await EmailDomainDoc.findByDomain(context.senderDomain)
       : null;
+    if (managedDoc) {
+      const readiness = await this.dcRouterRef.emailDomainManager?.getOutboundReadiness(managedDoc.domain);
+      if (!readiness?.ready) {
+        throw new Error(
+          `Outbound SMTP is not eligible for ${managedDoc.domain}: ${readiness?.reason || 'EmailDomainManager is unavailable'}`,
+        );
+      }
+    }
     const eligible = managedDoc
       ? await this.edgeEligibility.resolveActiveForDomain(managedDoc)
       : await this.edgeEligibility.resolveForDomain();
@@ -111,7 +123,9 @@ export class MailEgressCoordinator {
         `Outbound SMTP is not eligible${context.senderDomain ? ` for ${context.senderDomain}` : ''}: ${eligible.reason || 'no validated mail edge'}`,
       );
     }
-    const eligibleById = new Map(eligible.edges.map((candidate) => [candidate.edge.id, candidate]));
+    const eligibleById = new Map<string, IEligibleMailEdge>(
+      eligible.edges.map((candidate) => [candidate.edge.id, candidate]),
+    );
     const edgeFilter = [...eligibleById.keys()];
 
     const connectionTimeoutMs = this.dcRouterRef.options.emailConfig?.outbound?.connectionTimeout ?? 30_000;

package/ts/email/reconcile-mail-dns-singleton.ts

@@ -24,6 +24,7 @@ export interface IMailDnsMutationClient {
   updateRecord(args: {
     id: string;
     name?: string;
+    type?: 'MX' | 'TXT' | 'A' | 'AAAA';
     value?: string;
     ttl?: number;
   }): Promise<{ success: boolean; message?: string }>;
@@ -183,10 +184,16 @@ export async function reconcileMailDnsSingleton(
     return true;
   }
   if (managed) {
-    if (managed.value.trim() !== intent.value.trim() || managed.name !== intent.name) {
+    if (
+      managed.value.trim() !== intent.value.trim()
+      || managed.name !== intent.name
+      || managed.type !== intent.type
+      || managed.ttl !== intent.ttl
+    ) {
       const result = await options.dnsManager.updateRecord({
         id: managed.id,
         name: intent.name,
+        type: intent.type,
         value: intent.value,
         ttl: intent.ttl,
       });

package/ts/opsserver/handlers/dns-provider.handler.ts

@@ -119,6 +119,7 @@ export class DnsProviderHandler {
               changedIds: [dataArg.id],
               reason: 'dns-provider-updated',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('DNS provider updated');
           }
           return ok ? { success: true } : { success: false, message: 'Provider not found' };
         },
@@ -148,6 +149,7 @@ export class DnsProviderHandler {
               changedIds: [dataArg.id],
               reason: 'dns-provider-deleted',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('DNS provider deleted');
           }
           return result;
         },

package/ts/opsserver/handlers/dns-record.handler.ts

@@ -65,28 +65,31 @@ export class DnsRecordHandler {
           const userId = await this.requireAuth(dataArg, 'dns-records:write');
           const dnsManager = this.opsServerRef.dcRouterRef.dnsManager;
           if (!dnsManager) return { success: false, message: 'DnsManager not initialized' };
-          const claimError = await this.rejectClaimedHostnameMutation(
-            dataArg.domainId,
-            dataArg.name,
-            dataArg.type,
-            userId,
-            'create',
-          );
-          if (claimError) return { success: false, message: claimError };
-          const result = await dnsManager.createRecord({
-            domainId: dataArg.domainId,
-            name: dataArg.name,
-            type: dataArg.type,
-            value: dataArg.value,
-            ttl: dataArg.ttl,
-            proxied: dataArg.proxied,
-            createdBy: userId,
+          const result = await dnsManager.runManagedMailDnsMutationExclusive(async () => {
+            const claimError = await this.rejectClaimedHostnameMutation(
+              dataArg.domainId,
+              dataArg.name,
+              dataArg.type,
+              userId,
+              'create',
+            );
+            if (claimError) return { success: false, message: claimError };
+            return await dnsManager.createRecord({
+              domainId: dataArg.domainId,
+              name: dataArg.name,
+              type: dataArg.type,
+              value: dataArg.value,
+              ttl: dataArg.ttl,
+              proxied: dataArg.proxied,
+              createdBy: userId,
+            });
           });
           if (result.success) {
             this.opsServerRef.invalidateRealtime?.(['dns', 'emailDomains'], {
               changedIds: result.id ? [result.id] : undefined,
               reason: 'dns-record-created',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('operator DNS record created');
           }
           return result;
         },
@@ -101,39 +104,42 @@ export class DnsRecordHandler {
           const userId = await this.requireAuth(dataArg, 'dns-records:write');
           const dnsManager = this.opsServerRef.dcRouterRef.dnsManager;
           if (!dnsManager) return { success: false, message: 'DnsManager not initialized' };
-          const existing = await dnsManager.getRecord(dataArg.id);
-          if (existing) {
-            const currentClaimError = await this.rejectClaimedHostnameMutation(
-              existing.domainId,
-              existing.name,
-              existing.type,
-              userId,
-              'update',
-            );
-            if (currentClaimError) return { success: false, message: currentClaimError };
-            if (dataArg.name !== undefined) {
-              const nextClaimError = await this.rejectClaimedHostnameMutation(
+          const result = await dnsManager.runManagedMailDnsMutationExclusive(async () => {
+            const existing = await dnsManager.getRecord(dataArg.id);
+            if (existing) {
+              const currentClaimError = await this.rejectClaimedHostnameMutation(
                 existing.domainId,
-                dataArg.name,
+                existing.name,
                 existing.type,
                 userId,
                 'update',
               );
-              if (nextClaimError) return { success: false, message: nextClaimError };
+              if (currentClaimError) return { success: false, message: currentClaimError };
+              if (dataArg.name !== undefined) {
+                const nextClaimError = await this.rejectClaimedHostnameMutation(
+                  existing.domainId,
+                  dataArg.name,
+                  existing.type,
+                  userId,
+                  'update',
+                );
+                if (nextClaimError) return { success: false, message: nextClaimError };
+              }
             }
-          }
-          const result = await dnsManager.updateRecord({
-            id: dataArg.id,
-            name: dataArg.name,
-            value: dataArg.value,
-            ttl: dataArg.ttl,
-            proxied: dataArg.proxied,
+            return await dnsManager.updateRecord({
+              id: dataArg.id,
+              name: dataArg.name,
+              value: dataArg.value,
+              ttl: dataArg.ttl,
+              proxied: dataArg.proxied,
+            });
           });
           if (result.success) {
             this.opsServerRef.invalidateRealtime?.(['dns', 'emailDomains'], {
               changedIds: [dataArg.id],
               reason: 'dns-record-updated',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('operator DNS record updated');
           }
           return result;
         },
@@ -148,23 +154,26 @@ export class DnsRecordHandler {
           const userId = await this.requireAuth(dataArg, 'dns-records:write');
           const dnsManager = this.opsServerRef.dcRouterRef.dnsManager;
           if (!dnsManager) return { success: false, message: 'DnsManager not initialized' };
-          const existing = await dnsManager.getRecord(dataArg.id);
-          if (existing) {
-            const claimError = await this.rejectClaimedHostnameMutation(
-              existing.domainId,
-              existing.name,
-              existing.type,
-              userId,
-              'delete',
-            );
-            if (claimError) return { success: false, message: claimError };
-          }
-          const result = await dnsManager.deleteRecord(dataArg.id);
+          const result = await dnsManager.runManagedMailDnsMutationExclusive(async () => {
+            const existing = await dnsManager.getRecord(dataArg.id);
+            if (existing) {
+              const claimError = await this.rejectClaimedHostnameMutation(
+                existing.domainId,
+                existing.name,
+                existing.type,
+                userId,
+                'delete',
+              );
+              if (claimError) return { success: false, message: claimError };
+            }
+            return await dnsManager.deleteRecord(dataArg.id);
+          });
           if (result.success) {
             this.opsServerRef.invalidateRealtime?.(['dns', 'emailDomains'], {
               changedIds: [dataArg.id],
               reason: 'dns-record-deleted',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('operator DNS record deleted');
           }
           return result;
         },

package/ts/opsserver/handlers/domain.handler.ts

@@ -72,6 +72,7 @@ export class DomainHandler {
               changedIds: [id],
               reason: 'domain-created',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('DNS domain created');
             return { success: true, id };
           } catch (err: unknown) {
             return { success: false, message: (err as Error).message };
@@ -98,6 +99,7 @@ export class DomainHandler {
               changedIds: importedIds,
               reason: 'domains-imported',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('DNS provider domains imported');
             return { success: true, importedIds };
           } catch (err: unknown) {
             return { success: false, message: (err as Error).message };
@@ -136,7 +138,12 @@ export class DomainHandler {
           await this.requireAuth(dataArg, 'domains:write');
           const dnsManager = this.opsServerRef.dcRouterRef.dnsManager;
           if (!dnsManager) return { success: false, message: 'DnsManager not initialized' };
-          const ok = await dnsManager.deleteDomain(dataArg.id);
+          let ok: boolean;
+          try {
+            ok = await dnsManager.deleteDomain(dataArg.id);
+          } catch (error: unknown) {
+            return { success: false, message: (error as Error).message };
+          }
           if (ok) {
             // The private-route DNS overlay is derived from routes but gated on
             // domain ownership, so deleting a domain invalidates it even though no
@@ -149,6 +156,7 @@ export class DomainHandler {
               changedIds: [dataArg.id],
               reason: 'domain-deleted',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('DNS domain deleted');
           }
           return ok ? { success: true } : { success: false, message: 'Domain not found' };
         },
@@ -169,6 +177,7 @@ export class DomainHandler {
               changedIds: [dataArg.id],
               reason: 'domain-synced',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('DNS provider domain synchronized');
           }
           return result;
         },
@@ -199,6 +208,7 @@ export class DomainHandler {
               changedIds: [dataArg.id],
               reason: 'domain-migrated',
             });
+            this.opsServerRef.dcRouterRef.mailDnsSync.requestSync('DNS domain migrated');
           }
           return result;
         },

package/ts/remoteingress/classes.hub-lifecycle.ts

@@ -176,6 +176,7 @@ export class RemoteIngressHubLifecycle {
         this.dcRouterRef.tunnelManager = undefined;
       }
     }
+    this.dcRouterRef.mailDnsSync.requestEdgeEligibilityCheck('RemoteIngress hub stopped');
   }
 
   private async restartTunnelHubLocked(): Promise<void> {

package/ts_web/00_commitinfo_data.ts

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