@serve.zone/dcrouter 16.5.0 → 17.1.0

package/ts_web/appstate/runtime.ts

@@ -10,14 +10,124 @@ import { securityPolicyStatePart, fetchSecurityPolicyAction } from './security.j
 import { certificateStatePart, fetchCertificateOverviewAction } from './certificates.js';
 import { remoteIngressStatePart, fetchRemoteIngressAction } from './remoteingress.js';
 import { vpnStatePart, fetchVpnAction } from './vpn.js';
-
+import { emailDomainsStatePart, fetchEmailDomainsAction } from './email-domains.js';
+import { emailOpsStatePart, fetchAllEmailsAction } from './email-ops.js';
+import {
+  domainsStatePart,
+  fetchDnsRecordsForDomainAction,
+  fetchDomainsAndProvidersAction,
+} from './domains.js';
+import {
+  fetchHttpRedirectsAction,
+  fetchMergedRoutesAction,
+  routeManagementStatePart,
+} from './routes.js';
+import { opsRealtimeFreshness } from './realtime.js';
 
 // ============================================================================
 // TypedSocket Client for Real-time Log Streaming
 // ============================================================================
 
 let socketClient: plugins.typedsocket.TypedSocket | null = null;
+let socketStatusSubscription: { unsubscribe: () => void } | null = null;
+let socketConnectInFlight = false;
+let socketGeneration = 0;
 const socketRouter = new plugins.domtools.plugins.typedrequest.TypedRouter();
+type TRealtimeRefreshGroup =
+  | 'emailDomains'
+  | 'emailOps'
+  | 'dns'
+  | 'routes'
+  | 'edges'
+  | 'certificates';
+
+const pendingRealtimeRefreshes = new Set<TRealtimeRefreshGroup>();
+let realtimeRefreshLoopRunning = false;
+
+const resourceRefreshGroups: Record<
+  interfaces.requests.TOpsRealtimeResource,
+  TRealtimeRefreshGroup
+> = {
+  emailDomains: 'emailDomains',
+  emailQueue: 'emailOps',
+  smtpAttempts: 'emailOps',
+  dns: 'dns',
+  routes: 'routes',
+  edges: 'edges',
+  certificates: 'certificates',
+};
+
+const refreshRealtimeGroup = async (groupArg: TRealtimeRefreshGroup): Promise<void> => {
+  switch (groupArg) {
+    case 'emailDomains':
+      await emailDomainsStatePart.dispatchAction(fetchEmailDomainsAction, null);
+      break;
+    case 'emailOps':
+      await emailOpsStatePart.dispatchAction(fetchAllEmailsAction, null);
+      break;
+    case 'dns': {
+      const selectedDomainId = domainsStatePart.getState()!.selectedDomainId;
+      await domainsStatePart.dispatchAction(fetchDomainsAndProvidersAction, null);
+      if (selectedDomainId) {
+        await domainsStatePart.dispatchAction(
+          fetchDnsRecordsForDomainAction,
+          { domainId: selectedDomainId },
+        );
+      }
+      break;
+    }
+    case 'routes':
+      await Promise.all([
+        routeManagementStatePart.dispatchAction(fetchMergedRoutesAction, null),
+        routeManagementStatePart.dispatchAction(fetchHttpRedirectsAction, null),
+      ]);
+      break;
+    case 'edges':
+      await remoteIngressStatePart.dispatchAction(fetchRemoteIngressAction, null);
+      break;
+    case 'certificates':
+      await certificateStatePart.dispatchAction(fetchCertificateOverviewAction, null);
+      break;
+  }
+};
+
+const runRealtimeRefreshLoop = async (): Promise<void> => {
+  if (realtimeRefreshLoopRunning) return;
+  realtimeRefreshLoopRunning = true;
+  try {
+    while (pendingRealtimeRefreshes.size > 0) {
+      const groups = Array.from(pendingRealtimeRefreshes);
+      pendingRealtimeRefreshes.clear();
+      await Promise.all(
+        groups.map(async (group) => {
+          try {
+            await refreshRealtimeGroup(group);
+          } catch (error) {
+            console.error('Realtime resource refresh failed:', group, error);
+          }
+        }),
+      );
+    }
+  } finally {
+    realtimeRefreshLoopRunning = false;
+    if (pendingRealtimeRefreshes.size > 0) {
+      queueMicrotask(() => void runRealtimeRefreshLoop());
+    }
+  }
+};
+
+const acceptRealtimeInvalidations = (
+  serverEpochArg: string,
+  invalidationsArg: interfaces.requests.IOpsRealtimeInvalidation[],
+): void => {
+  const accepted = opsRealtimeFreshness.accept(serverEpochArg, invalidationsArg);
+  for (const invalidation of accepted) {
+    pendingRealtimeRefreshes.add(resourceRefreshGroups[invalidation.resource]);
+  }
+  if (accepted.length > 0) {
+    queueMicrotask(() => void runRealtimeRefreshLoop());
+  }
+};
 
 // Batched log entry handler — buffers incoming entries and flushes once per animation frame
 let logEntryBuffer: interfaces.data.ILogEntry[] = [];
@@ -51,28 +161,85 @@ socketRouter.addTypedHandler(
   )
 );
 
+socketRouter.addTypedHandler(
+  new plugins.domtools.plugins.typedrequest.TypedHandler<
+    interfaces.requests.IReq_PushOpsRealtimeInvalidation
+  >(
+    'pushOpsRealtimeInvalidation',
+    async (dataArg) => {
+      acceptRealtimeInvalidations(dataArg.serverEpoch, dataArg.invalidations);
+      return {};
+    },
+  ),
+);
+
+const subscribeSocket = async (
+  clientArg: plugins.typedsocket.TypedSocket,
+  generationArg: number,
+): Promise<void> => {
+  const identity = getActionContext().identity;
+  if (!identity || generationArg !== socketGeneration || clientArg !== socketClient) return;
+
+  const request = clientArg.createTypedRequest<interfaces.requests.IReq_SubscribeOpsRealtime>(
+    'subscribeOpsRealtime',
+  );
+  const response = await request.fire({
+    identity,
+    ...opsRealtimeFreshness.getKnownState(),
+  });
+  if (generationArg !== socketGeneration || clientArg !== socketClient) return;
+  acceptRealtimeInvalidations(response.serverEpoch, response.invalidations);
+};
+
 async function connectSocket() {
-  if (socketClient) return;
+  if (socketClient || socketConnectInFlight || document.hidden) return;
+  socketConnectInFlight = true;
+  const generation = ++socketGeneration;
   try {
-    socketClient = await plugins.typedsocket.TypedSocket.createClient(
+    const client = await plugins.typedsocket.TypedSocket.createClient(
       socketRouter,
       plugins.typedsocket.TypedSocket.useWindowLocationOriginUrl(),
+      { autoReconnect: true },
     );
-    await socketClient.setTag('role', 'ops_dashboard');
+    if (generation !== socketGeneration || !loginStatePart.getState()!.isLoggedIn) {
+      await client.stop();
+      return;
+    }
+
+    socketClient = client;
+    socketStatusSubscription = client.statusSubject.subscribe((status) => {
+      if (status === 'connected') {
+        void subscribeSocket(client, generation).catch((error) => {
+          console.error('Realtime subscription failed after reconnect:', error);
+        });
+      }
+    });
+    await subscribeSocket(client, generation);
   } catch (err) {
     console.error('TypedSocket connection failed:', err);
+    socketStatusSubscription?.unsubscribe();
+    socketStatusSubscription = null;
+    if (socketClient) {
+      await socketClient.stop().catch(() => undefined);
+    }
     socketClient = null;
+  } finally {
+    socketConnectInFlight = false;
   }
 }
 
 async function disconnectSocket() {
-  if (socketClient) {
+  socketGeneration++;
+  socketStatusSubscription?.unsubscribe();
+  socketStatusSubscription = null;
+  const client = socketClient;
+  socketClient = null;
+  if (client) {
     try {
-      await socketClient.stop();
+      await client.stop();
     } catch {
       // ignore disconnect errors
     }
-    socketClient = null;
   }
 }
 
@@ -285,6 +452,8 @@ loginStatePart.select((s) => s.isLoggedIn).subscribe((isLoggedIn) => {
     if (isLoggedIn) {
       connectSocket();
     } else {
+      pendingRealtimeRefreshes.clear();
+      opsRealtimeFreshness.reset();
       disconnectSocket();
     }
   }

package/ts_web/appstate.ts

@@ -19,6 +19,7 @@ export * from './appstate/domains.js';
 export * from './appstate/routes.js';
 export * from './appstate/users.js';
 export * from './appstate/email-domains.js';
+export * from './appstate/realtime.js';
 
 // Side-effect module: auto-refresh scheduling and TypedSocket log streaming.
 import './appstate/runtime.js';

package/ts_web/elements/email/email-domain-creation-progress.ts

@@ -0,0 +1,340 @@
+import type * as interfaces from '../../../dist_ts_interfaces/index.js';
+
+export interface IEmailDomainCreationProgress {
+  percentage: number;
+  indeterminate: boolean;
+  showPercentage: boolean;
+  statusText: string;
+  terminalLines: string[];
+}
+
+export interface IEmailDomainCreationProgressInput {
+  domain?: interfaces.data.IEmailDomain;
+  operation?: interfaces.requests.IEmailDomainActionResult | null;
+  requestCompleted: boolean;
+}
+
+const settledIntentStatuses = new Set<interfaces.data.TEmailDnsIntentStatus>([
+  'satisfied',
+  'valid',
+  'conflict',
+  'failed',
+]);
+
+const formatOperationError = (
+  errorArg: interfaces.data.IEmailDomainOperationError | interfaces.requests.IEmailDomainActionError,
+): string => {
+  const location = errorArg.recordKey ? `${errorArg.recordKey}: ` : '';
+  return `${location}${errorArg.message} [${errorArg.code}]`;
+};
+
+const appendDnsStatusLines = (
+  linesArg: string[],
+  dnsStatusArg: interfaces.data.IEmailDomainDnsStatus,
+): void => {
+  for (const [label, status] of [
+    ['MX', dnsStatusArg.mx],
+    ['SPF', dnsStatusArg.spf],
+    ['DKIM', dnsStatusArg.dkim],
+    ['DMARC', dnsStatusArg.dmarc],
+  ] as const) {
+    if (status !== 'unchecked') {
+      linesArg.push(`${label}: ${status}`);
+    }
+  }
+};
+
+export const getEmailDomainCreationProgress = (
+  inputArg: IEmailDomainCreationProgressInput,
+): IEmailDomainCreationProgress => {
+  const { domain, operation, requestCompleted } = inputArg;
+
+  if (!domain) {
+    if (!requestCompleted) {
+      return {
+        percentage: 0,
+        indeterminate: true,
+        showPercentage: false,
+        statusText: 'Generating DKIM material and creating the domain record...',
+        terminalLines: ['Submitting email domain configuration'],
+      };
+    }
+
+    const lines = ['Email domain creation request completed without a persisted domain'];
+    for (const error of operation?.errors || []) {
+      lines.push(formatOperationError(error));
+    }
+    if (operation?.message && !lines.includes(operation.message)) {
+      lines.push(operation.message);
+    }
+    return {
+      percentage: 100,
+      indeterminate: false,
+      showPercentage: false,
+      statusText: operation?.message || 'Email domain creation failed.',
+      terminalLines: lines,
+    };
+  }
+
+  const reconciliation = domain.reconciliation;
+  const lines = [`Domain record persisted: ${domain.domain}`];
+  if (!reconciliation || reconciliation.intents.length === 0) {
+    if (!requestCompleted) {
+      lines.push('Preparing the managed DNS plan');
+      return {
+        percentage: 0,
+        indeterminate: true,
+        showPercentage: false,
+        statusText: 'Preparing the managed DNS plan...',
+        terminalLines: lines,
+      };
+    }
+
+    lines.push('No DNS reconciliation plan is available');
+    const errors = reconciliation?.errors.length
+      ? reconciliation.errors
+      : operation?.errors || [];
+    for (const error of errors) {
+      lines.push(formatOperationError(error));
+    }
+    const retryAt = reconciliation?.retryAt || operation?.retryAt;
+    if (retryAt) {
+      lines.push(`Retry scheduled for ${retryAt}`);
+    }
+    const statusText =
+      reconciliation?.lifecycleStatus === 'failed'
+        ? operation?.message || `DNS setup failed for ${domain.domain}.`
+        : retryAt
+          ? 'DNS reconciliation is pending and will retry automatically.'
+          : operation?.message || 'The domain was created without a DNS reconciliation plan.';
+    return {
+      percentage: 100,
+      indeterminate: false,
+      showPercentage: false,
+      statusText,
+      terminalLines: lines,
+    };
+  }
+
+  const settledCount = reconciliation.intents.filter((intent) =>
+    settledIntentStatuses.has(intent.status)
+  ).length;
+  lines.push(`DNS plan prepared: ${reconciliation.intents.length} managed records`);
+  lines.push(
+    `DNS reconciliation: ${settledCount} settled, ${reconciliation.intents.length - settledCount} pending`,
+  );
+  appendDnsStatusLines(lines, domain.dnsStatus);
+
+  if (reconciliation.lifecycleStatus === 'active') {
+    lines.push('Email domain is active');
+    return {
+      percentage: 100,
+      indeterminate: false,
+      showPercentage: true,
+      statusText: `${domain.domain} is active.`,
+      terminalLines: lines,
+    };
+  }
+
+  if (!requestCompleted) {
+    return {
+      percentage: 0,
+      indeterminate: true,
+      showPercentage: false,
+      statusText: 'Reconciling and validating managed DNS records...',
+      terminalLines: lines,
+    };
+  }
+
+  const errors = reconciliation.errors.length > 0
+    ? reconciliation.errors
+    : operation?.errors || [];
+  for (const error of errors) {
+    lines.push(formatOperationError(error));
+  }
+  const retryAt = reconciliation.retryAt || operation?.retryAt;
+  if (retryAt) {
+    lines.push(`Retry scheduled for ${retryAt}`);
+  }
+
+  if (reconciliation.lifecycleStatus === 'failed') {
+    return {
+      percentage: 100,
+      indeterminate: false,
+      showPercentage: false,
+      statusText: operation?.message || `DNS setup failed for ${domain.domain}.`,
+      terminalLines: lines,
+    };
+  }
+
+  return {
+    percentage: 100,
+    indeterminate: false,
+    showPercentage: false,
+    statusText: retryAt
+      ? `DNS reconciliation is pending and will retry automatically.`
+      : `DNS reconciliation is pending for ${domain.domain}.`,
+    terminalLines: lines,
+  };
+};
+
+export const findNewEmailDomain = (
+  domainsArg: interfaces.data.IEmailDomain[],
+  expectedDomainArg: string,
+  existingIdsArg: ReadonlySet<string>,
+): interfaces.data.IEmailDomain | undefined => {
+  const expectedDomain = expectedDomainArg.trim().toLowerCase();
+  const candidates = domainsArg.filter(
+    (domain) => domain.domain.toLowerCase() === expectedDomain && !existingIdsArg.has(domain.id),
+  );
+  if (candidates.length > 1) {
+    throw new Error(`Multiple new email domains appeared for ${expectedDomain}`);
+  }
+  return candidates[0];
+};
+
+const waitForPollInterval = async (delayMsArg: number, signalArg: AbortSignal): Promise<void> => {
+  if (signalArg.aborted) return;
+  await new Promise<void>((resolve) => {
+    const finish = () => {
+      signalArg.removeEventListener('abort', handleAbort);
+      resolve();
+    };
+    const handleAbort = () => {
+      clearTimeout(timeoutId);
+      finish();
+    };
+    const timeoutId = setTimeout(finish, delayMsArg);
+    signalArg.addEventListener('abort', handleAbort, { once: true });
+  });
+};
+
+export interface IObserveNewEmailDomainOptions {
+  expectedDomain: string;
+  existingIds: ReadonlySet<string>;
+  signal: AbortSignal;
+  listDomains: () => Promise<interfaces.data.IEmailDomain[]>;
+  getDomain: (idArg: string) => Promise<interfaces.data.IEmailDomain | null>;
+  onDomain: (domainArg: interfaces.data.IEmailDomain) => void;
+  subscribeToDomains?: (
+    listenerArg: (domainsArg: interfaces.data.IEmailDomain[]) => void,
+  ) => () => void;
+  pollIntervalMs?: number;
+  timeoutMs?: number;
+}
+
+export const observeNewEmailDomain = async (
+  optionsArg: IObserveNewEmailDomainOptions,
+): Promise<interfaces.data.IEmailDomain | undefined> => {
+  const startedAt = Date.now();
+  const pollIntervalMs = optionsArg.pollIntervalMs ?? (
+    optionsArg.subscribeToDomains ? 15_000 : 600
+  );
+  const timeoutMs = optionsArg.timeoutMs ?? 120_000;
+  let observedId: string | undefined;
+  let latestDomain: interfaces.data.IEmailDomain | undefined;
+  let pushedDomains: interfaces.data.IEmailDomain[] | undefined;
+  let wakeObserver: (() => void) | undefined;
+
+  const unsubscribe = optionsArg.subscribeToDomains?.((domainsArg) => {
+    pushedDomains = domainsArg;
+    wakeObserver?.();
+  });
+
+  try {
+    while (!optionsArg.signal.aborted && Date.now() - startedAt < timeoutMs) {
+      try {
+        let domain: interfaces.data.IEmailDomain | null | undefined;
+        if (!observedId) {
+          const domainSnapshot = pushedDomains || await optionsArg.listDomains();
+          pushedDomains = undefined;
+          const foundDomain = findNewEmailDomain(
+            domainSnapshot,
+            optionsArg.expectedDomain,
+            optionsArg.existingIds,
+          );
+          observedId = foundDomain?.id;
+          domain = foundDomain;
+        } else if (pushedDomains) {
+          domain = pushedDomains.find((candidate) => candidate.id === observedId);
+          pushedDomains = undefined;
+        } else {
+          domain = await optionsArg.getDomain(observedId);
+        }
+
+        if (optionsArg.signal.aborted) break;
+        if (domain) {
+          if (domain !== latestDomain) {
+            latestDomain = domain;
+            optionsArg.onDomain(domain);
+          }
+          const lifecycleStatus = domain.reconciliation?.lifecycleStatus;
+          if (lifecycleStatus === 'active' || lifecycleStatus === 'failed') {
+            return domain;
+          }
+        }
+      } catch (error: unknown) {
+        if (error instanceof Error && error.message.startsWith('Multiple new email domains')) {
+          throw error;
+        }
+        // The realtime subscription or bounded fallback read will retry.
+      }
+
+      const updatePromise = new Promise<void>((resolve) => {
+        wakeObserver = resolve;
+      });
+      if (pushedDomains) {
+        wakeObserver = undefined;
+        continue;
+      }
+      await Promise.race([
+        updatePromise,
+        waitForPollInterval(pollIntervalMs, optionsArg.signal),
+      ]);
+      wakeObserver = undefined;
+    }
+  } finally {
+    unsubscribe?.();
+    wakeObserver?.();
+  }
+
+  return latestDomain;
+};
+
+export interface IAbortableDeadlineOptions {
+  signal?: AbortSignal;
+  timeoutMs: number;
+  timeoutMessage: string;
+}
+
+export const withAbortableDeadline = async <T>(
+  promiseArg: Promise<T>,
+  optionsArg: IAbortableDeadlineOptions,
+): Promise<T> => {
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const finish = (callbackArg: () => void) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      optionsArg.signal?.removeEventListener('abort', handleAbort);
+      callbackArg();
+    };
+    const handleAbort = () => {
+      finish(() => reject(new Error('Email domain creation progress was interrupted')));
+    };
+    const timeoutId = setTimeout(() => {
+      finish(() => reject(new Error(optionsArg.timeoutMessage)));
+    }, optionsArg.timeoutMs);
+
+    if (optionsArg.signal?.aborted) {
+      handleAbort();
+      return;
+    }
+    optionsArg.signal?.addEventListener('abort', handleAbort, { once: true });
+    promiseArg.then(
+      (value) => finish(() => resolve(value)),
+      (error) => finish(() => reject(error)),
+    );
+  });
+};