@serve.zone/dcrouter 5.5.0 → 6.0.0

package/dist_ts_web/elements/ops-view-certificates.js

@@ -129,13 +129,13 @@ let OpsViewCertificates = (() => {
         color: ${cssManager.bdTheme('#374151', '#d1d5db')};
       }
 
-      .domainPills {
+      .routePills {
         display: flex;
         flex-wrap: wrap;
         gap: 4px;
       }
 
-      .domainPill {
+      .routePill {
         display: inline-flex;
         align-items: center;
         padding: 2px 8px;
@@ -160,6 +160,17 @@ let OpsViewCertificates = (() => {
         white-space: nowrap;
       }
 
+      .backoffIndicator {
+        display: inline-flex;
+        align-items: center;
+        gap: 4px;
+        font-size: 11px;
+        color: ${cssManager.bdTheme('#9a3412', '#fb923c')};
+        padding: 2px 6px;
+        border-radius: 4px;
+        background: ${cssManager.bdTheme('#fff7ed', '#431407')};
+      }
+
       .expiryInfo {
         font-size: 12px;
       }
@@ -245,14 +256,16 @@ let OpsViewCertificates = (() => {
       <dees-table
         .data=${this.certState.certificates}
         .displayFunction=${(cert) => ({
-                Route: cert.routeName,
-                Domains: this.renderDomainPills(cert.domains),
+                Domain: cert.domain,
+                Routes: this.renderRoutePills(cert.routeNames),
                 Status: this.renderStatusBadge(cert.status),
                 Source: this.renderSourceBadge(cert.source),
                 Expires: this.renderExpiry(cert.expiryDate),
-                Error: cert.error
-                    ? html `<span class="errorText" title="${cert.error}">${cert.error}</span>`
-                    : '',
+                Error: cert.backoffInfo
+                    ? html `<span class="backoffIndicator">${cert.backoffInfo.failures} failures, retry ${this.formatRetryTime(cert.backoffInfo.retryAfter)}</span>`
+                    : cert.error
+                        ? html `<span class="errorText" title="${cert.error}">${cert.error}</span>`
+                        : '',
             })}
         .dataActions=${[
                 {
@@ -270,10 +283,10 @@ let OpsViewCertificates = (() => {
                             });
                             return;
                         }
-                        await appstate.certificateStatePart.dispatchAction(appstate.reprovisionCertificateAction, cert.routeName);
+                        await appstate.certificateStatePart.dispatchAction(appstate.reprovisionCertificateAction, cert.domain);
                         const { DeesToast } = await import('@design.estate/dees-catalog');
                         DeesToast.show({
-                            message: `Reprovisioning triggered for ${cert.routeName}`,
+                            message: `Reprovisioning triggered for ${cert.domain}`,
                             type: 'success',
                             duration: 3000,
                         });
@@ -287,7 +300,7 @@ let OpsViewCertificates = (() => {
                         const cert = actionData.item;
                         const { DeesModal } = await import('@design.estate/dees-catalog');
                         await DeesModal.createAndShow({
-                            heading: `Certificate: ${cert.routeName}`,
+                            heading: `Certificate: ${cert.domain}`,
                             content: html `
                   <div style="padding: 20px;">
                     <dees-dataview-codebox
@@ -299,10 +312,10 @@ let OpsViewCertificates = (() => {
                 `,
                             menuOptions: [
                                 {
-                                    name: 'Copy Route Name',
+                                    name: 'Copy Domain',
                                     iconName: 'copy',
                                     action: async () => {
-                                        await navigator.clipboard.writeText(cert.routeName);
+                                        await navigator.clipboard.writeText(cert.domain);
                                     },
                                 },
                             ],
@@ -311,7 +324,7 @@ let OpsViewCertificates = (() => {
                 },
             ]}
         heading1="Certificate Status"
-        heading2="TLS certificates across all routes"
+        heading2="TLS certificates by domain"
         searchable
         .pagination=${true}
         .paginationSize=${50}
@@ -319,13 +332,13 @@ let OpsViewCertificates = (() => {
       ></dees-table>
     `;
         }
-        renderDomainPills(domains) {
+        renderRoutePills(routeNames) {
             const maxShow = 3;
-            const visible = domains.slice(0, maxShow);
-            const remaining = domains.length - maxShow;
+            const visible = routeNames.slice(0, maxShow);
+            const remaining = routeNames.length - maxShow;
             return html `
-      <span class="domainPills">
-        ${visible.map((d) => html `<span class="domainPill">${d}</span>`)}
+      <span class="routePills">
+        ${visible.map((r) => html `<span class="routePill">${r}</span>`)}
         ${remaining > 0 ? html `<span class="moreCount">+${remaining} more</span>` : ''}
       </span>
     `;
@@ -369,6 +382,20 @@ let OpsViewCertificates = (() => {
       </span>
     `;
         }
+        formatRetryTime(retryAfter) {
+            if (!retryAfter)
+                return 'soon';
+            const retryDate = new Date(retryAfter);
+            const now = new Date();
+            const diffMs = retryDate.getTime() - now.getTime();
+            if (diffMs <= 0)
+                return 'now';
+            const diffMin = Math.ceil(diffMs / 60000);
+            if (diffMin < 60)
+                return `in ${diffMin}m`;
+            const diffHours = Math.ceil(diffMin / 60);
+            return `in ${diffHours}h`;
+        }
         static {
             __runInitializers(_classThis, _classExtraInitializers);
         }
@@ -376,4 +403,4 @@ let OpsViewCertificates = (() => {
     return OpsViewCertificates = _classThis;
 })();
 export { OpsViewCertificates };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ops-view-certificates.js","sourceRoot":"","sources":["../../ts_web/elements/ops-view-certificates.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ops-view-certificates.js","sourceRoot":"","sources":["../../ts_web/elements/ops-view-certificates.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@serve.zone/dcrouter",
   "private": false,
-  "version": "5.5.0",
+  "version": "6.0.0",
   "description": "A multifaceted routing service handling mail and SMS delivery functions.",
   "type": "module",
   "exports": {
@@ -42,14 +42,14 @@
     "@push.rocks/smartfile": "^13.1.2",
     "@push.rocks/smartguard": "^3.1.0",
     "@push.rocks/smartjwt": "^2.2.1",
-    "@push.rocks/smartlog": "^3.1.10",
+    "@push.rocks/smartlog": "^3.1.11",
     "@push.rocks/smartmetrics": "^2.0.10",
     "@push.rocks/smartmongo": "^5.1.0",
     "@push.rocks/smartmta": "^5.2.2",
     "@push.rocks/smartnetwork": "^4.4.0",
     "@push.rocks/smartpath": "^6.0.0",
     "@push.rocks/smartpromise": "^4.2.3",
-    "@push.rocks/smartproxy": "^25.3.0",
+    "@push.rocks/smartproxy": "^25.3.1",
     "@push.rocks/smartradius": "^1.1.1",
     "@push.rocks/smartrequest": "^5.0.1",
     "@push.rocks/smartrx": "^3.0.10",

package/ts/00_commitinfo_data.ts

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

package/ts/classes.cert-provision-scheduler.ts

@@ -0,0 +1,176 @@
+import { logger } from './logger.js';
+import type { StorageManager } from './storage/index.js';
+
+interface IBackoffEntry {
+  failures: number;
+  lastFailure: string; // ISO string
+  retryAfter: string;  // ISO string
+  lastError?: string;
+}
+
+/**
+ * Manages certificate provisioning scheduling with:
+ * - Per-domain exponential backoff persisted in StorageManager
+ * - Serial stagger queue with configurable delay between provisions
+ */
+export class CertProvisionScheduler {
+  private storageManager: StorageManager;
+  private staggerDelayMs: number;
+  private maxBackoffHours: number;
+
+  // In-memory serial queue
+  private queue: Array<{
+    domain: string;
+    fn: () => Promise<any>;
+    resolve: (value: any) => void;
+    reject: (err: any) => void;
+  }> = [];
+  private processing = false;
+
+  // In-memory backoff cache (mirrors storage for fast lookups)
+  private backoffCache = new Map<string, IBackoffEntry>();
+
+  constructor(
+    storageManager: StorageManager,
+    options?: { staggerDelayMs?: number; maxBackoffHours?: number }
+  ) {
+    this.storageManager = storageManager;
+    this.staggerDelayMs = options?.staggerDelayMs ?? 3000;
+    this.maxBackoffHours = options?.maxBackoffHours ?? 24;
+  }
+
+  /**
+   * Storage key for a domain's backoff entry
+   */
+  private backoffKey(domain: string): string {
+    const clean = domain.replace(/\*/g, '_wildcard_').replace(/[^a-zA-Z0-9._-]/g, '_');
+    return `/cert-backoff/${clean}`;
+  }
+
+  /**
+   * Load backoff entry from storage (with in-memory cache)
+   */
+  private async loadBackoff(domain: string): Promise<IBackoffEntry | null> {
+    const cached = this.backoffCache.get(domain);
+    if (cached) return cached;
+
+    const entry = await this.storageManager.getJSON<IBackoffEntry>(this.backoffKey(domain));
+    if (entry) {
+      this.backoffCache.set(domain, entry);
+    }
+    return entry;
+  }
+
+  /**
+   * Save backoff entry to both cache and storage
+   */
+  private async saveBackoff(domain: string, entry: IBackoffEntry): Promise<void> {
+    this.backoffCache.set(domain, entry);
+    await this.storageManager.setJSON(this.backoffKey(domain), entry);
+  }
+
+  /**
+   * Check if a domain is currently in backoff
+   */
+  async isInBackoff(domain: string): Promise<boolean> {
+    const entry = await this.loadBackoff(domain);
+    if (!entry) return false;
+
+    const retryAfter = new Date(entry.retryAfter);
+    return retryAfter.getTime() > Date.now();
+  }
+
+  /**
+   * Record a provisioning failure for a domain.
+   * Sets exponential backoff: min(failures^2 * 1h, maxBackoffHours)
+   */
+  async recordFailure(domain: string, error?: string): Promise<void> {
+    const existing = await this.loadBackoff(domain);
+    const failures = (existing?.failures ?? 0) + 1;
+
+    // Exponential backoff: failures^2 hours, capped
+    const backoffHours = Math.min(failures * failures, this.maxBackoffHours);
+    const retryAfter = new Date(Date.now() + backoffHours * 60 * 60 * 1000);
+
+    const entry: IBackoffEntry = {
+      failures,
+      lastFailure: new Date().toISOString(),
+      retryAfter: retryAfter.toISOString(),
+      lastError: error,
+    };
+
+    await this.saveBackoff(domain, entry);
+    logger.log('warn', `Cert backoff for ${domain}: ${failures} failures, retry after ${retryAfter.toISOString()}`);
+  }
+
+  /**
+   * Clear backoff for a domain (on success or manual override)
+   */
+  async clearBackoff(domain: string): Promise<void> {
+    this.backoffCache.delete(domain);
+    try {
+      await this.storageManager.delete(this.backoffKey(domain));
+    } catch {
+      // Ignore delete errors (key may not exist)
+    }
+  }
+
+  /**
+   * Get backoff info for UI display
+   */
+  async getBackoffInfo(domain: string): Promise<{
+    failures: number;
+    retryAfter?: string;
+    lastError?: string;
+  } | null> {
+    const entry = await this.loadBackoff(domain);
+    if (!entry) return null;
+
+    // Only return if still in backoff
+    const retryAfter = new Date(entry.retryAfter);
+    if (retryAfter.getTime() <= Date.now()) return null;
+
+    return {
+      failures: entry.failures,
+      retryAfter: entry.retryAfter,
+      lastError: entry.lastError,
+    };
+  }
+
+  /**
+   * Enqueue a provision operation for serial execution with stagger delay.
+   * Returns the result of the provision function.
+   */
+  enqueueProvision<T>(domain: string, fn: () => Promise<T>): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      this.queue.push({ domain, fn, resolve, reject });
+      this.processQueue();
+    });
+  }
+
+  /**
+   * Process the stagger queue serially
+   */
+  private async processQueue(): Promise<void> {
+    if (this.processing) return;
+    this.processing = true;
+
+    while (this.queue.length > 0) {
+      const item = this.queue.shift()!;
+      try {
+        logger.log('info', `Processing cert provision for ${item.domain}`);
+        const result = await item.fn();
+        item.resolve(result);
+      } catch (err) {
+        item.reject(err);
+      }
+
+      // Stagger delay between provisions
+      if (this.queue.length > 0) {
+        await new Promise<void>((r) => setTimeout(r, this.staggerDelayMs));
+      }
+    }
+
+    this.processing = false;
+  }
+}

package/ts/classes.dcrouter.ts

@@ -14,6 +14,7 @@ import { logger } from './logger.js';
 // Import storage manager
 import { StorageManager, type IStorageConfig } from './storage/index.js';
 import { StorageBackedCertManager } from './classes.storage-cert-manager.js';
+import { CertProvisionScheduler } from './classes.cert-provision-scheduler.js';
 // Import cache system
 import { CacheDb, CacheCleaner, type ICacheDbOptions } from './cache/index.js';
 
@@ -184,16 +185,19 @@ export class DcRouter {
   public cacheDb?: CacheDb;
   public cacheCleaner?: CacheCleaner;
 
-  // Certificate status tracking from SmartProxy events
+  // Certificate status tracking from SmartProxy events (keyed by domain)
   public certificateStatusMap = new Map<string, {
     status: 'valid' | 'failed';
-    domain: string;
+    routeNames: string[];
     expiryDate?: string;
     issuedAt?: string;
     source?: string;
     error?: string;
   }>();
 
+  // Certificate provisioning scheduler with backoff + stagger
+  public certProvisionScheduler?: CertProvisionScheduler;
+
   // TypedRouter for API endpoints
   public typedrouter = new plugins.typedrequest.TypedRouter();
 
@@ -467,6 +471,9 @@ export class DcRouter {
         },
       };
       
+      // Initialize cert provision scheduler
+      this.certProvisionScheduler = new CertProvisionScheduler(this.storageManager);
+
       // If we have DNS challenge handlers, create SmartAcme and wire to certProvisionFunction
       if (challengeHandlers.length > 0) {
         this.smartAcme = new plugins.smartacme.SmartAcme({
@@ -478,24 +485,41 @@ export class DcRouter {
         });
         await this.smartAcme.start();
 
+        const scheduler = this.certProvisionScheduler;
         smartProxyConfig.certProvisionFunction = async (domain, eventComms) => {
+          // Check backoff before attempting provision
+          if (await scheduler.isInBackoff(domain)) {
+            const info = await scheduler.getBackoffInfo(domain);
+            const msg = `Domain ${domain} is in backoff (${info?.failures} failures), retry after ${info?.retryAfter}`;
+            eventComms.warn(msg);
+            throw new Error(msg);
+          }
+
           try {
-            eventComms.log(`Attempting DNS-01 via SmartAcme for ${domain}`);
-            eventComms.setSource('smartacme-dns-01');
-            const cert = await this.smartAcme.getCertificateForDomain(domain);
-            if (cert.validUntil) {
-              eventComms.setExpiryDate(new Date(cert.validUntil));
-            }
-            return {
-              id: cert.id,
-              domainName: cert.domainName,
-              created: cert.created,
-              validUntil: cert.validUntil,
-              privateKey: cert.privateKey,
-              publicKey: cert.publicKey,
-              csr: cert.csr,
-            };
+            const result = await scheduler.enqueueProvision(domain, async () => {
+              eventComms.log(`Attempting DNS-01 via SmartAcme for ${domain}`);
+              eventComms.setSource('smartacme-dns-01');
+              const cert = await this.smartAcme.getCertificateForDomain(domain);
+              if (cert.validUntil) {
+                eventComms.setExpiryDate(new Date(cert.validUntil));
+              }
+              return {
+                id: cert.id,
+                domainName: cert.domainName,
+                created: cert.created,
+                validUntil: cert.validUntil,
+                privateKey: cert.privateKey,
+                publicKey: cert.publicKey,
+                csr: cert.csr,
+              };
+            });
+
+            // Success — clear any backoff
+            await scheduler.clearBackoff(domain);
+            return result;
           } catch (err) {
+            // Record failure for backoff tracking
+            await scheduler.recordFailure(domain, err.message);
             eventComms.warn(`SmartAcme DNS-01 failed for ${domain}: ${err.message}, falling back to http-01`);
             return 'http01';
           }
@@ -519,39 +543,34 @@ export class DcRouter {
       });
       
       // Always listen for certificate events — emitted by both ACME and certProvisionFunction paths
+      // Events are keyed by domain for domain-centric certificate tracking
       this.smartProxy.on('certificate-issued', (event: plugins.smartproxy.ICertificateIssuedEvent) => {
         console.log(`[DcRouter] Certificate issued for ${event.domain} via ${event.source}, expires ${event.expiryDate}`);
-        const routeName = this.findRouteNameForDomain(event.domain);
-        if (routeName) {
-          this.certificateStatusMap.set(routeName, {
-            status: 'valid', domain: event.domain,
-            expiryDate: event.expiryDate, issuedAt: new Date().toISOString(),
-            source: event.source,
-          });
-        }
+        const routeNames = this.findRouteNamesForDomain(event.domain);
+        this.certificateStatusMap.set(event.domain, {
+          status: 'valid', routeNames,
+          expiryDate: event.expiryDate, issuedAt: new Date().toISOString(),
+          source: event.source,
+        });
       });
 
       this.smartProxy.on('certificate-renewed', (event: plugins.smartproxy.ICertificateIssuedEvent) => {
         console.log(`[DcRouter] Certificate renewed for ${event.domain} via ${event.source}, expires ${event.expiryDate}`);
-        const routeName = this.findRouteNameForDomain(event.domain);
-        if (routeName) {
-          this.certificateStatusMap.set(routeName, {
-            status: 'valid', domain: event.domain,
-            expiryDate: event.expiryDate, issuedAt: new Date().toISOString(),
-            source: event.source,
-          });
-        }
+        const routeNames = this.findRouteNamesForDomain(event.domain);
+        this.certificateStatusMap.set(event.domain, {
+          status: 'valid', routeNames,
+          expiryDate: event.expiryDate, issuedAt: new Date().toISOString(),
+          source: event.source,
+        });
       });
 
       this.smartProxy.on('certificate-failed', (event: plugins.smartproxy.ICertificateFailedEvent) => {
         console.error(`[DcRouter] Certificate failed for ${event.domain} (${event.source}):`, event.error);
-        const routeName = this.findRouteNameForDomain(event.domain);
-        if (routeName) {
-          this.certificateStatusMap.set(routeName, {
-            status: 'failed', domain: event.domain, error: event.error,
-            source: event.source,
-          });
-        }
+        const routeNames = this.findRouteNamesForDomain(event.domain);
+        this.certificateStatusMap.set(event.domain, {
+          status: 'failed', routeNames, error: event.error,
+          source: event.source,
+        });
       });
       
       // Start SmartProxy
@@ -724,7 +743,7 @@ export class DcRouter {
   }
 
   /**
-   * Find the route name that matches a given domain
+   * Find the first route name that matches a given domain
    */
   private findRouteNameForDomain(domain: string): string | undefined {
     if (!this.smartProxy) return undefined;
@@ -740,6 +759,27 @@ export class DcRouter {
     return undefined;
   }
 
+  /**
+   * Find ALL route names that match a given domain
+   */
+  public findRouteNamesForDomain(domain: string): string[] {
+    if (!this.smartProxy) return [];
+    const names: string[] = [];
+    for (const route of this.smartProxy.routeManager.getRoutes()) {
+      if (!route.match.domains || !route.name) continue;
+      const routeDomains = Array.isArray(route.match.domains)
+        ? route.match.domains
+        : [route.match.domains];
+      for (const pattern of routeDomains) {
+        if (this.isDomainMatch(domain, pattern)) {
+          names.push(route.name);
+          break; // This route already matched, no need to check other patterns
+        }
+      }
+    }
+    return names;
+  }
+
   public async stop() {
     console.log('Stopping DcRouter services...');