@serve.zone/dcrouter 18.0.1 → 18.1.0

package/ts/email/classes.workapp-mail-manager.ts

@@ -93,6 +93,26 @@ interface IStoredWorkAppMailState {
   identities: IStoredWorkAppMailIdentity[];
 }
 
+/**
+ * WorkApp-generated routes and SMTP users contributed to the composed email
+ * runtime config. Consumed by SmtpAccountManager, the single owner of the
+ * final `auth` block and route-list composition.
+ */
+export interface IWorkAppMailRuntimeContribution {
+  routes: IEmailRoute[];
+  users: Array<{ username: string; password: string }>;
+}
+
+/** Route names generated (and owned wholesale) by WorkAppMailManager. */
+export function isWorkAppManagedMailRouteName(routeName: string): boolean {
+  return routeName.startsWith('workapp-mail-');
+}
+
+/** SMTP usernames generated (and owned wholesale) by WorkAppMailManager. */
+export function isWorkAppManagedSmtpUsername(username: string): boolean {
+  return username.startsWith('workapp-');
+}
+
 export class WorkAppMailManager {
   private readonly storageKey = '/workhosters/mail-identities.json';
   private identityMutationPromise: Promise<unknown> = Promise.resolve();
@@ -659,12 +679,36 @@ export class WorkAppMailManager {
     };
   }
 
-  public async applyStoredIdentitiesToEmailConfig<TConfig extends IUnifiedEmailServerOptions>(
-    emailConfig: TConfig,
-  ): Promise<TConfig> {
-    const identities = await this.readStoredIdentities();
-    const readyDomains = await this.getReadyOutboundDomains(identities);
-    return this.mergeIdentitiesIntoEmailConfig(emailConfig, identities, readyDomains);
+  /**
+   * Compute the workapp-generated routes and SMTP users for the given
+   * candidate email config. Pure contribution — the final composition of
+   * routes and the `auth` block is owned exclusively by SmtpAccountManager.
+   */
+  public async getStoredIdentityContribution(
+    emailConfig: IUnifiedEmailServerOptions,
+    identities = undefined as IStoredWorkAppMailIdentity[] | undefined,
+  ): Promise<IWorkAppMailRuntimeContribution> {
+    const nextIdentities = identities || await this.readStoredIdentities();
+    const readyDomains = await this.getReadyOutboundDomains(nextIdentities);
+    const generatedRoutes = nextIdentities
+      .filter((identity) => {
+        const inboundTarget = this.getCanonicalInboundTarget(identity);
+        return identity.enabled && ['smtpForward', 'typedEndpoint'].includes(inboundTarget?.type || '');
+      })
+      .map((identity) => this.buildInboundRoute(identity));
+    const generatedOutboundRoutes = nextIdentities
+      .filter((identity) => identity.enabled && identity.smtp.enabled && readyDomains.has(identity.domain))
+      .map((identity) => this.buildOutboundRoute(identity, emailConfig));
+    const generatedUsers = nextIdentities
+      .filter((identity) => identity.enabled && identity.smtp.enabled && readyDomains.has(identity.domain))
+      .map((identity) => ({
+        username: identity.smtp.username,
+        password: identity.smtpPassword,
+      }));
+    return {
+      routes: [...generatedRoutes, ...generatedOutboundRoutes],
+      users: generatedUsers,
+    };
   }
 
   public async applyStoredIdentitiesToRuntime(
@@ -673,15 +717,8 @@ export class WorkAppMailManager {
     const emailConfig = this.dcRouterRef.options.emailConfig as IUnifiedEmailServerOptions | undefined;
     if (!emailConfig) return;
 
-    const nextIdentities = identities || await this.readStoredIdentities();
-    const readyDomains = await this.getReadyOutboundDomains(nextIdentities);
-    const nextConfig = this.mergeIdentitiesIntoEmailConfig(emailConfig, nextIdentities, readyDomains);
-
-    this.dcRouterRef.options.emailConfig = nextConfig;
-    if (this.dcRouterRef.emailServer) {
-      this.dcRouterRef.emailServer.updateOptions({ auth: nextConfig.auth });
-      await this.dcRouterRef.updateEmailRoutes(nextConfig.routes);
-    }
+    const contribution = await this.getStoredIdentityContribution(emailConfig, identities);
+    await this.dcRouterRef.smtpAccountManager.applyToRuntime(contribution);
   }
 
   private async readStoredIdentities(): Promise<IStoredWorkAppMailIdentity[]> {
@@ -717,41 +754,6 @@ export class WorkAppMailManager {
     >;
   }
 
-  private mergeIdentitiesIntoEmailConfig<TConfig extends IUnifiedEmailServerOptions>(
-    emailConfig: TConfig,
-    identities: IStoredWorkAppMailIdentity[],
-    readyDomains: Set<string>,
-  ): TConfig {
-    const generatedRoutes = identities
-      .filter((identity) => {
-        const inboundTarget = this.getCanonicalInboundTarget(identity);
-        return identity.enabled && ['smtpForward', 'typedEndpoint'].includes(inboundTarget?.type || '');
-      })
-      .map((identity) => this.buildInboundRoute(identity));
-    const generatedOutboundRoutes = identities
-      .filter((identity) => identity.enabled && identity.smtp.enabled && readyDomains.has(identity.domain))
-      .map((identity) => this.buildOutboundRoute(identity, emailConfig));
-    const configuredRoutes = (emailConfig.routes || [])
-      .filter((route) => !this.isManagedMailRouteName(route.name));
-    const generatedUsers = identities
-      .filter((identity) => identity.enabled && identity.smtp.enabled && readyDomains.has(identity.domain))
-      .map((identity) => ({
-        username: identity.smtp.username,
-        password: identity.smtpPassword,
-      }));
-    const configuredUsers = (emailConfig.auth?.users || [])
-      .filter((user) => !this.isManagedSmtpUsername(user.username));
-
-    return {
-      ...emailConfig,
-      routes: [...configuredRoutes, ...generatedRoutes, ...generatedOutboundRoutes],
-      auth: {
-        ...(emailConfig.auth || {}),
-        users: [...configuredUsers, ...generatedUsers],
-      },
-    };
-  }
-
   private buildInboundRoute(identity: IStoredWorkAppMailIdentity): IEmailRoute {
     const inboundTarget = this.getCanonicalInboundTarget(identity);
     if (inboundTarget?.type === 'typedEndpoint') {
@@ -1594,12 +1596,8 @@ export class WorkAppMailManager {
     return plugins.crypto.randomBytes(24).toString('base64url');
   }
 
-  private isManagedMailRouteName(routeName: string): boolean {
-    return routeName.startsWith('workapp-mail-');
-  }
-
   private isManagedSmtpUsername(username: string): boolean {
-    return username.startsWith('workapp-');
+    return isWorkAppManagedSmtpUsername(username);
   }
 
   private buildSmtpCredentials(

package/ts/email/index.ts

@@ -11,5 +11,7 @@ export * from './classes.email-settings.manager.js';
 export * from './classes.smartmta-blob-storage-manager.js';
 export * from './classes.smartmta-storage-manager.js';
 export * from './smartmta-storage-policy.js';
+export * from './classes.smtp-account.manager.js';
+export * from './smtp-scram.js';
 export * from './classes.workapp-mail-manager.js';
 export * from './email-dns-records.js';

package/ts/email/smtp-scram.ts

@@ -0,0 +1,24 @@
+import * as plugins from '../plugins.js';
+import { deriveScramVerifier } from '@push.rocks/smartmta';
+import type { ISmtpScramVerifier } from '@push.rocks/smartmta';
+
+/**
+ * Derive an RFC 5802 SCRAM-SHA-256 verifier from a plaintext password using
+ * smartmta's canonical exported derivation (fresh random salt, OWASP-aligned
+ * default iteration count) — the exact algorithm the server verifies at AUTH
+ * time. Only the verifier is ever persisted; the plaintext is shown once at
+ * create/rotate time and then discarded.
+ */
+export function deriveSmtpScramVerifier(
+  password: string,
+  iterations?: number,
+): ISmtpScramVerifier {
+  return deriveScramVerifier(password, iterations);
+}
+
+/**
+ * Machine-generated SMTP account password (~192 bits of entropy). Shown once.
+ */
+export function generateSmtpAccountPassword(): string {
+  return plugins.crypto.randomBytes(24).toString('base64url');
+}

package/ts/opsserver/classes.opsserver.ts

@@ -41,6 +41,7 @@ export class OpsServer {
   private dnsRecordHandler!: handlers.DnsRecordHandler;
   private acmeConfigHandler!: handlers.AcmeConfigHandler;
   private emailDomainHandler!: handlers.EmailDomainHandler;
+  private smtpAccountHandler!: handlers.SmtpAccountHandler;
   private gatewayClientHandler!: handlers.GatewayClientHandler;
   private webPushControlHandler!: handlers.WebPushControlHandler;
   private webPushAppHandler!: handlers.WebPushAppHandler;
@@ -109,6 +110,7 @@ export class OpsServer {
     this.dnsRecordHandler = new handlers.DnsRecordHandler(this);
     this.acmeConfigHandler = new handlers.AcmeConfigHandler(this);
     this.emailDomainHandler = new handlers.EmailDomainHandler(this);
+    this.smtpAccountHandler = new handlers.SmtpAccountHandler(this);
     this.gatewayClientHandler = new handlers.GatewayClientHandler(this);
     this.webPushControlHandler = new handlers.WebPushControlHandler(this);
     this.webPushAppHandler = new handlers.WebPushAppHandler(this);

package/ts/opsserver/handlers/email-settings.handler.ts

@@ -54,9 +54,19 @@ export class EmailSettingsHandler {
     const mailerBridgeState = dcRouter.emailServer?.getBridgeState() as
       | interfaces.data.TEmailBridgeState
       | undefined;
+    const smtpAccountCount = dcRouter.smtpAccountManager?.getAccountCount() ?? 0;
+    const smtpListenerActive = dcRouter.emailServer
+      ? dcRouter.emailServer.isSmtpListenerActive()
+      : undefined;
     const manager = dcRouter.emailSettingsManager;
     if (manager) {
-      return { ...manager.getPublicSettings(), outboundEgress, mailerBridgeState };
+      return {
+        ...manager.getPublicSettings(),
+        outboundEgress,
+        mailerBridgeState,
+        smtpAccountCount,
+        ...(smtpListenerActive !== undefined ? { smtpListenerActive } : {}),
+      };
     }
     const emailConfig = dcRouter.options.emailConfig;
     const emailPortConfig = dcRouter.options.emailPortConfig;
@@ -75,6 +85,8 @@ export class EmailSettingsHandler {
       domainCount: emailConfig?.domains?.length || 0,
       routeCount: emailConfig?.routes?.length || 0,
       authUserCount: emailConfig?.auth?.users?.length || 0,
+      smtpAccountCount,
+      ...(smtpListenerActive !== undefined ? { smtpListenerActive } : {}),
       updatedAt: 0,
       updatedBy: 'runtime-options',
     };

package/ts/opsserver/handlers/index.ts

@@ -21,6 +21,7 @@ export * from './dns-authority.handler.js';
 export * from './dns-record.handler.js';
 export * from './acme-config.handler.js';
 export * from './email-domain.handler.js';
+export * from './smtp-account.handler.js';
 export * from './gatewayclient.handler.js';
 export * from './realtime.handler.js';
 export * from './config-event.handler.js';

package/ts/opsserver/handlers/smtp-account.handler.ts

@@ -0,0 +1,199 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+import { requireOpsAuth } from '../helpers/auth.js';
+import { logger } from '../../logger.js';
+
+/**
+ * CRUD handler for operator-managed SMTP submission accounts, plus the
+ * legacy-route retirement lever.
+ *
+ * Auth: admin JWT or API token with `smtp-accounts:read` / `smtp-accounts:write`
+ * scope; every write additionally requires an admin identity when a JWT is
+ * used. Successful admin actions are audit-logged to the ops log.
+ */
+export class SmtpAccountHandler {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(private opsServerRef: OpsServer) {
+    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    this.registerHandlers();
+  }
+
+  private async requireAuth(
+    request: { identity?: interfaces.data.IIdentity; apiToken?: string },
+    requiredScope: interfaces.data.TApiTokenScope,
+  ): Promise<string> {
+    const auth = await requireOpsAuth(this.opsServerRef, request, {
+      scope: requiredScope,
+      requireAdminIdentity: requiredScope.endsWith(':write'),
+    });
+    return auth.userId;
+  }
+
+  private get manager() {
+    return this.opsServerRef.dcRouterRef.smtpAccountManager;
+  }
+
+  private failure(errorArg: unknown, fallbackMessageArg: string): interfaces.requests.ISmtpAccountActionResult {
+    return {
+      success: false,
+      message: errorArg instanceof Error ? errorArg.message : fallbackMessageArg,
+      code: 'SMTP_ACCOUNT_ACTION_FAILED',
+    };
+  }
+
+  private registerHandlers(): void {
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetSmtpAccounts>(
+        'getSmtpAccounts',
+        async (dataArg) => {
+          await this.requireAuth(dataArg, 'smtp-accounts:read');
+          if (!this.manager?.isStarted()) return { accounts: [] };
+          return { accounts: await this.manager.listAccounts() };
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_CreateSmtpAccount>(
+        'createSmtpAccount',
+        async (dataArg) => {
+          const userId = await this.requireAuth(dataArg, 'smtp-accounts:write');
+          if (!this.manager?.isStarted()) {
+            return { success: false, message: 'SmtpAccountManager not initialized', code: 'SMTP_ACCOUNT_MANAGER_UNAVAILABLE' };
+          }
+          try {
+            const result = await this.manager.createAccount({
+              username: dataArg.username,
+              description: dataArg.description,
+              senderScope: dataArg.senderScope,
+              recipientScope: dataArg.recipientScope,
+              mailPolicy: dataArg.mailPolicy,
+              createdBy: userId,
+            });
+            return {
+              success: true,
+              warnings: result.warnings.length > 0 ? result.warnings : undefined,
+              account: result.account,
+              password: result.password,
+            };
+          } catch (err: unknown) {
+            return this.failure(err, 'Failed to create SMTP account');
+          }
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_UpdateSmtpAccount>(
+        'updateSmtpAccount',
+        async (dataArg) => {
+          const userId = await this.requireAuth(dataArg, 'smtp-accounts:write');
+          if (!this.manager?.isStarted()) {
+            return { success: false, message: 'SmtpAccountManager not initialized', code: 'SMTP_ACCOUNT_MANAGER_UNAVAILABLE' };
+          }
+          try {
+            const result = await this.manager.updateAccount(dataArg.id, {
+              description: dataArg.description,
+              senderScope: dataArg.senderScope,
+              recipientScope: dataArg.recipientScope,
+              mailPolicy: dataArg.mailPolicy,
+            }, userId);
+            return {
+              success: true,
+              warnings: result.warnings.length > 0 ? result.warnings : undefined,
+              account: result.account,
+            };
+          } catch (err: unknown) {
+            return this.failure(err, 'Failed to update SMTP account');
+          }
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_ToggleSmtpAccount>(
+        'toggleSmtpAccount',
+        async (dataArg) => {
+          const userId = await this.requireAuth(dataArg, 'smtp-accounts:write');
+          if (!this.manager?.isStarted()) {
+            return { success: false, message: 'SmtpAccountManager not initialized', code: 'SMTP_ACCOUNT_MANAGER_UNAVAILABLE' };
+          }
+          try {
+            const result = await this.manager.toggleAccount(dataArg.id, dataArg.enabled, userId);
+            return { success: true, account: result.account };
+          } catch (err: unknown) {
+            return this.failure(err, 'Failed to toggle SMTP account');
+          }
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_RotateSmtpAccountPassword>(
+        'rotateSmtpAccountPassword',
+        async (dataArg) => {
+          const userId = await this.requireAuth(dataArg, 'smtp-accounts:write');
+          if (!this.manager?.isStarted()) {
+            return { success: false, message: 'SmtpAccountManager not initialized', code: 'SMTP_ACCOUNT_MANAGER_UNAVAILABLE' };
+          }
+          try {
+            const result = await this.manager.rotatePassword(dataArg.id, userId);
+            return { success: true, account: result.account, password: result.password };
+          } catch (err: unknown) {
+            return this.failure(err, 'Failed to rotate SMTP account password');
+          }
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_DeleteSmtpAccount>(
+        'deleteSmtpAccount',
+        async (dataArg) => {
+          const userId = await this.requireAuth(dataArg, 'smtp-accounts:write');
+          if (!this.manager?.isStarted()) {
+            return { success: false, message: 'SmtpAccountManager not initialized', code: 'SMTP_ACCOUNT_MANAGER_UNAVAILABLE' };
+          }
+          try {
+            await this.manager.deleteAccount(dataArg.id, userId);
+            return { success: true };
+          } catch (err: unknown) {
+            return this.failure(err, 'Failed to delete SMTP account');
+          }
+        },
+      ),
+    );
+
+    // Internal-relay retirement lever: removes one persisted legacy route by
+    // exact name through the standard settings restart path. Guarded in
+    // EmailSettingsManager (unknown names and generated managed names fail).
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_RemoveLegacyEmailRoute>(
+        'removeLegacyEmailRoute',
+        async (dataArg) => {
+          const userId = await this.requireAuth(dataArg, 'smtp-accounts:write');
+          const routeName = (dataArg.routeName || '').trim();
+          logger.log('info', `removeLegacyEmailRoute invoked by ${userId} for route '${routeName}'`);
+          if (!routeName) {
+            return { success: false, message: 'routeName is required', code: 'SMTP_ACCOUNT_ACTION_FAILED' };
+          }
+          if (!this.opsServerRef.dcRouterRef.emailSettingsManager) {
+            return { success: false, message: 'EmailSettingsManager not initialized', code: 'EMAIL_SETTINGS_MANAGER_UNAVAILABLE' };
+          }
+          try {
+            await this.opsServerRef.dcRouterRef.updateEmailServerSettings(
+              { removeRouteNames: [routeName] },
+              userId,
+            );
+            logger.log('info', `Legacy email route '${routeName}' removed from persisted settings by ${userId}`);
+            return { success: true, message: `Route '${routeName}' removed` };
+          } catch (err: unknown) {
+            return this.failure(err, 'Failed to remove legacy email route');
+          }
+        },
+      ),
+    );
+  }
+}

package/ts_web/00_commitinfo_data.ts

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

package/ts_web/appstate/smtp-accounts.ts

@@ -0,0 +1,143 @@
+import * as plugins from '../plugins.js';
+import * as interfaces from '../../ts_interfaces/index.js';
+import { appState } from './shared.js';
+import { getActionContext } from './login.js';
+
+// ============================================================================
+// SMTP Accounts State
+// ============================================================================
+
+export interface ISmtpAccountsState {
+  accounts: interfaces.data.ISmtpAccountInfo[];
+  isLoading: boolean;
+  error: string | null;
+  lastUpdated: number;
+}
+
+export const smtpAccountsStatePart = await appState.getStatePart<ISmtpAccountsState>(
+  'smtpAccounts',
+  {
+    accounts: [],
+    isLoading: false,
+    error: null,
+    lastUpdated: 0,
+  },
+  'soft',
+);
+
+export const fetchSmtpAccountsAction = smtpAccountsStatePart.createAction(
+  async (statePartArg): Promise<ISmtpAccountsState> => {
+    const context = getActionContext();
+    const currentState = statePartArg.getState()!;
+    if (!context.identity) return currentState;
+    try {
+      const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+        interfaces.requests.IReq_GetSmtpAccounts
+      >('/typedrequest', 'getSmtpAccounts');
+      const response = await request.fire({ identity: context.identity });
+      return {
+        ...statePartArg.getState()!,
+        accounts: response.accounts,
+        isLoading: false,
+        error: null,
+        lastUpdated: Date.now(),
+      };
+    } catch (error: unknown) {
+      return {
+        ...statePartArg.getState()!,
+        isLoading: false,
+        error: error instanceof Error ? error.message : 'Failed to fetch SMTP accounts',
+      };
+    }
+  },
+);
+
+export const toggleSmtpAccountAction = smtpAccountsStatePart.createAction<{
+  id: string;
+  enabled: boolean;
+}>(async (statePartArg, dataArg, actionContext): Promise<ISmtpAccountsState> => {
+  const context = getActionContext();
+  const currentState = statePartArg.getState()!;
+  try {
+    const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_ToggleSmtpAccount
+    >('/typedrequest', 'toggleSmtpAccount');
+    const response = await request.fire({
+      identity: context.identity!,
+      id: dataArg.id,
+      enabled: dataArg.enabled,
+    });
+    if (!response.success) {
+      return { ...currentState, error: response.message || 'Failed to toggle SMTP account' };
+    }
+    return await actionContext!.dispatch(fetchSmtpAccountsAction, null);
+  } catch (error: unknown) {
+    return {
+      ...currentState,
+      error: error instanceof Error ? error.message : 'Failed to toggle SMTP account',
+    };
+  }
+});
+
+export const deleteSmtpAccountAction = smtpAccountsStatePart.createAction<string>(
+  async (statePartArg, id, actionContext): Promise<ISmtpAccountsState> => {
+    const context = getActionContext();
+    const currentState = statePartArg.getState()!;
+    try {
+      const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+        interfaces.requests.IReq_DeleteSmtpAccount
+      >('/typedrequest', 'deleteSmtpAccount');
+      const response = await request.fire({ identity: context.identity!, id });
+      if (!response.success) {
+        return { ...currentState, error: response.message || 'Failed to delete SMTP account' };
+      }
+      return await actionContext!.dispatch(fetchSmtpAccountsAction, null);
+    } catch (error: unknown) {
+      return {
+        ...currentState,
+        error: error instanceof Error ? error.message : 'Failed to delete SMTP account',
+      };
+    }
+  },
+);
+
+// ============================================================================
+// Secret-returning calls — standalone functions, deliberately NOT actions:
+// the one-time password must never enter (persisted) app state.
+// ============================================================================
+
+export async function createSmtpAccount(options: {
+  username: string;
+  description?: string;
+  senderScope?: interfaces.data.ISmtpAccountSenderScope;
+  recipientScope?: interfaces.data.ISmtpAccountRecipientScope;
+  mailPolicy?: interfaces.data.ISmtpAccountMailPolicy;
+}) {
+  const context = getActionContext();
+  const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+    interfaces.requests.IReq_CreateSmtpAccount
+  >('/typedrequest', 'createSmtpAccount');
+  return request.fire({ identity: context.identity!, ...options });
+}
+
+export async function rotateSmtpAccountPassword(id: string) {
+  const context = getActionContext();
+  const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+    interfaces.requests.IReq_RotateSmtpAccountPassword
+  >('/typedrequest', 'rotateSmtpAccountPassword');
+  return request.fire({ identity: context.identity!, id });
+}
+
+export async function updateSmtpAccount(options: {
+  id: string;
+  description?: string;
+  senderScope?: interfaces.data.ISmtpAccountSenderScope;
+  recipientScope?: interfaces.data.ISmtpAccountRecipientScope;
+  mailPolicy?: interfaces.data.ISmtpAccountMailPolicy;
+}) {
+  const context = getActionContext();
+  const request = new plugins.domtools.plugins.typedrequest.TypedRequest<
+    interfaces.requests.IReq_UpdateSmtpAccount
+  >('/typedrequest', 'updateSmtpAccount');
+  return request.fire({ identity: context.identity!, ...options });
+}

package/ts_web/appstate.ts

@@ -20,6 +20,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/smtp-accounts.js';
 export * from './appstate/realtime.js';
 
 // Side-effect module: auto-refresh scheduling and TypedSocket log streaming.

package/ts_web/elements/email/index.ts

@@ -1,3 +1,4 @@
 export * from './ops-view-emails.js';
 export * from './ops-view-email-security.js';
 export * from './ops-view-email-domains.js';
+export * from './ops-view-smtp-accounts.js';