@serve.zone/dcrouter 15.4.1 → 15.6.0

package/ts/dns/classes.dns-server-runtime.ts

@@ -73,86 +73,99 @@ export class DnsServerRuntime {
     });
     this.dcRouterRef.dnsServer = dnsServer;
 
-    // Start the DNS server (UDP only)
+    // Start the DNS server. smartdns owns UDP and DNS-over-TCP; dcrouter
+    // keeps DNS-over-HTTPS routed through SmartProxy manual HTTPS mode.
     await dnsServer.start();
-    logger.log('info', `DNS server started on UDP ${vmIpAddress}:53`);
-
-    // Wire DNS query events to MetricsManager and logger with adaptive rate limiting
-    if (this.dcRouterRef.metricsManager) {
-      const flushDnsBatch = () => {
-        if (this.batchCount > 0) {
-          logger.log('info', `DNS: ${this.batchCount} queries processed (rate limited)`, { zone: 'dns' });
-          this.batchCount = 0;
-        }
-        this.batchTimer = null;
-      };
-
-      dnsServer.on('query', (event: plugins.smartdns.dnsServerMod.IDnsQueryCompletedEvent) => {
-        // Metrics tracking
-        for (const question of event.questions) {
-          this.dcRouterRef.metricsManager?.trackDnsQuery(
-            question.type,
-            question.name,
-            false,
-            event.responseTimeMs,
-            event.answered,
-          );
-        }
+    try {
+      logger.log('info', `DNS server started on UDP/TCP ${vmIpAddress}:53`);
+
+      // Wire DNS query events to MetricsManager and logger with adaptive rate limiting
+      if (this.dcRouterRef.metricsManager) {
+        const flushDnsBatch = () => {
+          if (this.batchCount > 0) {
+            logger.log('info', `DNS: ${this.batchCount} queries processed (rate limited)`, { zone: 'dns' });
+            this.batchCount = 0;
+          }
+          this.batchTimer = null;
+        };
 
-        // Adaptive logging: individual logs up to 2/sec, then batch
-        const nowSec = Math.floor(Date.now() / 1000);
-        if (nowSec !== this.logWindowSecond) {
-          this.logWindowSecond = nowSec;
-          this.logWindowCount = 0;
-        }
+        dnsServer.on('query', (event: plugins.smartdns.dnsServerMod.IDnsQueryCompletedEvent) => {
+          // Metrics tracking
+          for (const question of event.questions) {
+            this.dcRouterRef.metricsManager?.trackDnsQuery(
+              question.type,
+              question.name,
+              false,
+              event.responseTimeMs,
+              event.answered,
+            );
+          }
 
-        if (this.logWindowCount < 2) {
-          this.logWindowCount++;
-          const summary = event.questions.map(q => `${q.type} ${q.name}`).join(', ');
-          logger.log('info', `DNS query: ${summary} (${event.responseTimeMs}ms, ${event.answered ? 'answered' : 'unanswered'})`, { zone: 'dns' });
-        } else {
-          this.batchCount++;
-          if (!this.batchTimer) {
-            this.batchTimer = setTimeout(flushDnsBatch, 5000);
+          // Adaptive logging: individual logs up to 2/sec, then batch
+          const nowSec = Math.floor(Date.now() / 1000);
+          if (nowSec !== this.logWindowSecond) {
+            this.logWindowSecond = nowSec;
+            this.logWindowCount = 0;
           }
-        }
-      });
-    }
 
-    // Validate DNS configuration
-    await this.validateConfiguration();
+          if (this.logWindowCount < 2) {
+            this.logWindowCount++;
+            const summary = event.questions.map(q => `${q.type} ${q.name}`).join(', ');
+            logger.log('info', `DNS query: ${summary} (${event.responseTimeMs}ms, ${event.answered ? 'answered' : 'unanswered'})`, { zone: 'dns' });
+          } else {
+            this.batchCount++;
+            if (!this.batchTimer) {
+              this.batchTimer = setTimeout(flushDnsBatch, 5000);
+            }
+          }
+        });
+      }
 
-    // Generate and register authoritative records
-    const authoritativeRecords = await this.generateAuthoritativeRecords();
+      // Validate DNS configuration
+      await this.validateConfiguration();
 
-    // Generate email DNS records
-    const emailDnsRecords = await this.generateEmailDnsRecords();
+      // Generate and register authoritative records
+      const authoritativeRecords = await this.generateAuthoritativeRecords();
 
-    // Ensure DKIM keys exist for internal-dns domains before generating records.
-    await this.initializeDkimForEmailDomains();
+      // Generate email DNS records
+      const emailDnsRecords = await this.generateEmailDnsRecords();
 
-    // Generate DKIM records directly from smartmta.
-    const dkimRecords = await this.loadDkimRecords();
+      // Ensure DKIM keys exist for internal-dns domains before generating records.
+      await this.initializeDkimForEmailDomains();
 
-    // Combine all records: authoritative, email, DKIM, and user-defined
-    const allRecords: TDnsRecordSeed[] = [...authoritativeRecords, ...emailDnsRecords, ...dkimRecords];
-    if (options.dnsRecords && options.dnsRecords.length > 0) {
-      allRecords.push(...options.dnsRecords);
-    }
+      // Generate DKIM records directly from smartmta.
+      const dkimRecords = await this.loadDkimRecords();
 
-    // Apply proxy IP replacement if configured
-    await this.applyProxyIpReplacement(allRecords);
+      // Combine all records: authoritative, email, DKIM, and user-defined
+      const allRecords: TDnsRecordSeed[] = [...authoritativeRecords, ...emailDnsRecords, ...dkimRecords];
+      if (options.dnsRecords && options.dnsRecords.length > 0) {
+        allRecords.push(...options.dnsRecords);
+      }
 
-    // Register all DNS records
-    if (allRecords.length > 0) {
-      this.registerRecords(allRecords);
-      logger.log('info', `Registered ${allRecords.length} DNS records (${authoritativeRecords.length} authoritative, ${emailDnsRecords.length} email, ${dkimRecords.length} DKIM, ${options.dnsRecords?.length || 0} user-defined)`);
-    }
+      // Apply proxy IP replacement if configured
+      await this.applyProxyIpReplacement(allRecords);
+
+      // Register all DNS records
+      if (allRecords.length > 0) {
+        this.registerRecords(allRecords);
+        logger.log('info', `Registered ${allRecords.length} DNS records (${authoritativeRecords.length} authoritative, ${emailDnsRecords.length} email, ${dkimRecords.length} DKIM, ${options.dnsRecords?.length || 0} user-defined)`);
+      }
 
-    // Hand the DnsServer to DnsManager so DB-backed local records on
-    // dcrouter-hosted domains get registered too.
-    if (this.dcRouterRef.dnsManager) {
-      await this.dcRouterRef.dnsManager.attachDnsServer(dnsServer);
+      // Hand the DnsServer to DnsManager so DB-backed local records on
+      // dcrouter-hosted domains get registered too.
+      if (this.dcRouterRef.dnsManager) {
+        await this.dcRouterRef.dnsManager.attachDnsServer(dnsServer);
+      }
+    } catch (error) {
+      dnsServer.removeAllListeners();
+      await dnsServer.stop().catch((stopError: Error) => {
+        logger.log('warn', `Failed to stop DNS server after setup failure: ${stopError.message}`);
+      });
+      if (this.dcRouterRef.dnsServer === dnsServer) {
+        this.dcRouterRef.dnsServer = undefined;
+      }
+      this.flushQueryLogBatch();
+      throw error;
     }
   }
 
@@ -204,6 +217,11 @@ export class DnsServerRuntime {
     }
   }
 
+  /** Stop runtime-owned bookkeeping. smartdns owns network listener cleanup. */
+  public async stop(): Promise<void> {
+    this.flushQueryLogBatch();
+  }
+
   private registerRecords(records: TDnsRecordSeed[]): void {
     const dnsServer = this.dcRouterRef.dnsServer;
     if (!dnsServer) return;

package/ts/email/classes.accepted-email-spool.ts

@@ -50,6 +50,18 @@ type TStoredCachedEmailRouteData = {
   session?: TStoredCachedEmailSession;
 };
 
+export interface IAcceptRawEmailOptions {
+  rawMessage: string | plugins.buffer.Buffer;
+  envelope: {
+    mailFrom: string;
+    rcptTo: string[];
+  };
+  session: IExtendedSmtpSession;
+  messageId?: string;
+  subject?: string;
+  processAfterAccept?: boolean;
+}
+
 /**
  * Accept-then-spool pipeline for inbound SMTP messages: persists accepted
  * messages as CachedEmail docs, replays them through SmartMTA on an interval,
@@ -131,6 +143,55 @@ export class AcceptedEmailSpool {
     };
   }
 
+  public async acceptRawMessage(optionsArg: IAcceptRawEmailOptions): Promise<IMessageAcceptanceDecision & { spoolItemId: string }> {
+    if (!this.dcRouterRef.dcRouterDb?.isReady()) {
+      throw new Error('DcRouterDb is not available for email acceptance');
+    }
+
+    const rawMessage = plugins.buffer.Buffer.isBuffer(optionsArg.rawMessage)
+      ? optionsArg.rawMessage.toString('utf8')
+      : optionsArg.rawMessage;
+    const cachedEmail = CachedEmail.createNew();
+    cachedEmail.messageId = optionsArg.messageId || this.extractHeader(rawMessage, 'message-id') || cachedEmail.id;
+    cachedEmail.from = optionsArg.envelope.mailFrom;
+    cachedEmail.to = optionsArg.envelope.rcptTo;
+    cachedEmail.cc = [];
+    cachedEmail.bcc = [];
+    cachedEmail.subject = optionsArg.subject || this.extractHeader(rawMessage, 'subject') || '';
+    cachedEmail.rawContent = this.setDcRouterCacheIdHeader(rawMessage, cachedEmail.id);
+    cachedEmail.status = 'pending';
+    cachedEmail.nextAttempt = new Date();
+    cachedEmail.routeData = JSON.stringify({
+      acceptedAt: new Date().toISOString(),
+      session: {
+        id: optionsArg.session.id,
+        remoteAddress: optionsArg.session.remoteAddress,
+        clientHostname: optionsArg.session.clientHostname,
+        secure: !!optionsArg.session.secure,
+        authenticated: !!optionsArg.session.authenticated,
+        user: optionsArg.session.user,
+        envelope: optionsArg.session.envelope,
+      },
+    });
+    cachedEmail.updateSenderDomain();
+    await cachedEmail.save();
+
+    if (optionsArg.processAfterAccept !== false) {
+      this.run();
+    } else {
+      cachedEmail.markDelivered();
+      await cachedEmail.save();
+    }
+
+    return {
+      accepted: true,
+      spoolItemId: cachedEmail.id,
+      smtpCode: 250,
+      smtpMessage: '2.0.0 Message accepted for delivery',
+      continueProcessing: false,
+    };
+  }
+
   /** Start the interval-driven spool processor and trigger an immediate run. */
   public start(): void {
     this.clearSpoolTimer();
@@ -267,6 +328,19 @@ export class AcceptedEmailSpool {
     await cachedEmail.save();
 
     try {
+      if (plugins.buffer.Buffer.isBuffer(emailData)) {
+        const handledByTypedEndpoint = await this.dcRouterRef.workAppMailManager?.deliverCachedEmailToTypedEndpoint(
+          cachedEmail,
+          emailData,
+          session,
+        );
+        if (handledByTypedEndpoint) {
+          cachedEmail.markDelivered();
+          await cachedEmail.save();
+          return;
+        }
+      }
+
       await emailServer.processEmailByMode(emailData, session);
       if (session.matchedRoute?.action.type === 'forward') {
         cachedEmail.markDelivered();
@@ -333,6 +407,16 @@ export class AcceptedEmailSpool {
     }
   }
 
+  private extractHeader(rawMessageArg: string, headerNameArg: string): string | undefined {
+    const lowerName = `${headerNameArg.toLowerCase()}:`;
+    for (const line of rawMessageArg.split(/\r?\n/)) {
+      if (!line) return undefined;
+      if (line.toLowerCase().startsWith(lowerName)) {
+        return line.slice(lowerName.length).trim();
+      }
+    }
+  }
+
   private async updateAcceptedEmailFromQueueItem(
     item: TSmartMtaQueueItemLike,
     status: 'queued' | 'delivered' | 'failed',