@promptbook/cli 0.113.0-9 → 0.114.0-0

package/apps/agents-server/src/utils/resourceMonitor/resourceMonitorTypes.ts

@@ -1,3 +1,6 @@
+import type { AgentProjectInfo, AgentProjectsOwner } from '../agentProjects/AgentProjectInfo';
+import type { AgentProjectRuntimeInfo } from '../agentProjects/AgentProjectRuntimeInfo';
+
 /**
  * Resource key tracked by the server resource monitor.
  */
@@ -143,7 +146,87 @@ export type NetworkResourceUsage = {
 };
 
 /**
- * Full resource monitor snapshot rendered by `/admin/resource-monitor`.
+ * Project storage usage of one agent.
+ */
+export type AgentProjectsResourceAgentUsage = AgentProjectsOwner & {
+    /**
+     * Count of projects of the agent.
+     */
+    readonly projectCount: number;
+
+    /**
+     * Projects of the agent ordered by project name.
+     */
+    readonly projects: ReadonlyArray<AgentProjectInfo>;
+
+    /**
+     * Total size of all projects of the agent in bytes.
+     */
+    readonly sizeBytes: number;
+};
+
+/**
+ * Storage usage of all agent projects on the VPS.
+ */
+export type AgentProjectsResourceUsage = {
+    /**
+     * Absolute path of the scanned local agent root.
+     */
+    readonly rootPath: string;
+
+    /**
+     * Total size of all projects of all agents in bytes.
+     */
+    readonly totalSizeBytes: number;
+
+    /**
+     * Total count of projects across all agents.
+     */
+    readonly totalProjectCount: number;
+
+    /**
+     * Public domain of the server handling the resource-monitor request.
+     */
+    readonly currentServerDomain: string | null;
+
+    /**
+     * Per-agent project usage ordered by size descending. Only agents with at least one project are listed.
+     */
+    readonly agents: ReadonlyArray<AgentProjectsResourceAgentUsage>;
+
+    /**
+     * Error message when the projects usage could not be measured.
+     */
+    readonly errorMessage: string | null;
+};
+
+/**
+ * Runtime ports assigned to agent projects.
+ */
+export type AgentProjectRuntimesResourceUsage = {
+    /**
+     * Assigned or running project runtime ports.
+     */
+    readonly runtimes: ReadonlyArray<AgentProjectRuntimeInfo>;
+
+    /**
+     * Total assigned project ports.
+     */
+    readonly totalRuntimeCount: number;
+
+    /**
+     * Count of project ports with an active TCP listener.
+     */
+    readonly runningRuntimeCount: number;
+
+    /**
+     * Error message when runtime usage could not be read.
+     */
+    readonly errorMessage: string | null;
+};
+
+/**
+ * Full resource monitor snapshot rendered by `/superadmin/resource-monitor`.
  */
 export type ServerResourceMonitorSnapshot = {
     readonly measuredAt: string;
@@ -151,5 +234,7 @@ export type ServerResourceMonitorSnapshot = {
     readonly memory: MemoryResourceUsage;
     readonly disk: DiskResourceUsage;
     readonly network: NetworkResourceUsage;
+    readonly projects: AgentProjectsResourceUsage;
+    readonly projectRuntimes: AgentProjectRuntimesResourceUsage;
     readonly warningStatus: ServerResourceWarningStatus;
 };

package/apps/agents-server/src/utils/serverManagement/createManagedServer.ts

@@ -3,6 +3,7 @@ import type { ServerEnvironment, ServerRecord } from '../serverRegistry';
 import { bootstrapManagedServer } from './createManagedServer/bootstrapManagedServer';
 import { createFailedServerResult } from './createManagedServer/createFailedServerResult';
 import { normalizeCreateServerInput } from './createManagedServer/normalizeCreateServerInput';
+import { runWithVpsServerSetupTask } from '../vpsTask/runWithVpsServerSetupTask';
 
 /**
  * User row requested by the create-server wizard.
@@ -177,9 +178,28 @@ export type CreateServerResult =
  * @returns Success result or a failure payload containing the attempted SQL dump.
  */
 export async function createManagedServer(input: CreateServerInput): Promise<CreateServerResult> {
+    let normalizedInput: ReturnType<typeof normalizeCreateServerInput>;
     try {
-        return await bootstrapManagedServer(normalizeCreateServerInput(input));
+        normalizedInput = normalizeCreateServerInput(input);
     } catch (error) {
         return createFailedServerResult(error, null, null);
     }
+
+    return runWithVpsServerSetupTask(
+        {
+            taskName: `Server setup: ${normalizedInput.name}`,
+            chatId: normalizedInput.domain,
+            serverName: normalizedInput.name,
+            serverDomain: normalizedInput.domain,
+        },
+        () => bootstrapManagedServer(normalizedInput),
+        (result) =>
+            result.ok
+                ? true
+                : {
+                      isSuccessful: false,
+                      errorSummary: result.message,
+                      errorDetails: result.sqlDump,
+                  },
+    );
 }

package/apps/agents-server/src/utils/serverManagement/resolveServersDnsWarningStatus.ts

@@ -0,0 +1,64 @@
+import { isAgentsServerSqliteMode } from '../../database/agentsServerDatabaseMode';
+import {
+    isAgentProjectDnsDiagnosticIssue,
+    listAgentProjectDnsDiagnostics,
+} from '../agentProjects/listAgentProjectDnsDiagnostics';
+import { listAgentProjectDomainRecords } from '../agentProjects/agentProjectRuntimeDomains';
+import { isManagedServerDnsDiagnosticIssue } from '../../app/superadmin/servers/ServersRegistryDnsTypes';
+import { listManagedServers } from './listManagedServers';
+import { createStandaloneVpsDomainDnsDiagnostic } from '../standaloneVpsDnsDiagnostics';
+
+/**
+ * Resolves whether the Super Admin Servers page contains DNS diagnostics requiring attention.
+ *
+ * The Servers page exposes both registered server domains and their generated project domains, so
+ * its menu warning intentionally covers either type of DNS problem. Managed multi-server
+ * deployments do not expose these standalone VPS diagnostics and therefore have no warning here.
+ *
+ * @param isGlobalAdmin - Whether the current viewer is the environment-backed super-admin.
+ * @returns `true` when the Servers menu item should display a warning indicator.
+ *
+ * @private shared by the root layout and Super Admin server diagnostics
+ */
+export async function resolveServersDnsWarningStatus(isGlobalAdmin: boolean): Promise<boolean> {
+    if (!isGlobalAdmin || !isAgentsServerSqliteMode()) {
+        return false;
+    }
+
+    try {
+        const [servers, projectDomainRecords] = await Promise.all([
+            listManagedServers(),
+            listAgentProjectDomainRecords(),
+        ]);
+        const primaryDomain = servers[0]?.domain ?? null;
+        const [serverDnsDiagnostics, projectDnsDiagnostics] = await Promise.all([
+            Promise.all(
+                servers.map((server) =>
+                    createStandaloneVpsDomainDnsDiagnostic({
+                        domain: server.domain,
+                        publicIpAddress: process.env.PTBK_PUBLIC_IP_ADDRESS,
+                        fallbackCnameTargetDomain:
+                            primaryDomain && primaryDomain !== server.domain ? primaryDomain : null,
+                    }),
+                ),
+            ),
+            Promise.all(
+                servers.map((server) =>
+                    listAgentProjectDnsDiagnostics({
+                        projectDomainRecords,
+                        publicIpAddress: process.env.PTBK_PUBLIC_IP_ADDRESS,
+                        serverDomain: server.domain,
+                    }),
+                ),
+            ),
+        ]);
+
+        return (
+            serverDnsDiagnostics.some(isManagedServerDnsDiagnosticIssue) ||
+            projectDnsDiagnostics.flat().some(isAgentProjectDnsDiagnosticIssue)
+        );
+    } catch (error) {
+        console.error('Failed to resolve registered-server DNS warning status:', error);
+        return false;
+    }
+}

package/apps/agents-server/src/utils/serverManagement/standaloneVpsServerMetadata.ts

@@ -1,8 +1,12 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
 import { spaceTrim } from 'spacetrim';
 import { DatabaseError } from '../../../../../src/errors/DatabaseError';
+import { $getTableName } from '../../database/$getTableName';
 import { $provideSupabaseForServer } from '../../database/$provideSupabaseForServer';
-import type { ServerRecord } from '../serverRegistry';
+import { invalidateMetadataCache } from '../../database/getMetadata';
+import type { ProvidedServer } from '../../tools/$provideServer';
+import { runWithServerContextOverride } from '../../tools/serverContextOverride';
+import { createServerPublicUrl, type ServerRecord } from '../serverRegistry';
 
 /**
  * Metadata key storing the human-facing server name.
@@ -19,11 +23,11 @@ const SERVER_NAME_METADATA_KEY = 'SERVER_NAME';
 const SERVER_ICON_METADATA_KEYS = ['SERVER_LOGO_URL', 'SERVER_FAVICON_URL'] as const;
 
 /**
- * Minimal metadata row used by standalone VPS server setup.
+ * Minimal metadata row used by server setup and renaming.
  *
- * @private type of standalone VPS server management.
+ * @private type of server management.
  */
-type StandaloneVpsMetadataRow = {
+type ServerMetadataRow = {
     /**
      * Metadata key.
      */
@@ -46,37 +50,37 @@ type StandaloneVpsMetadataRow = {
 };
 
 /**
- * Applies visible standalone VPS setup values into the prefixed metadata table.
+ * Applies visible setup values into the metadata table of one explicitly selected server.
  *
- * @param input - Server prefix and optional metadata values.
+ * The caller supplies the server instead of relying on the request host because the
+ * Super Admin can update a different server on the same VPS.
  *
- * @private internal standalone VPS server management helper.
+ * @param input - Target server and optional metadata values.
+ *
+ * @private internal server management helper.
  */
-export async function applyStandaloneVpsServerMetadata(input: {
-    readonly tablePrefix: string;
+export async function applyServerMetadata(input: {
+    readonly server: ServerRecord;
     readonly name?: string | null;
     readonly iconUrl?: string | null;
 }): Promise<void> {
-    const metadataRows = createStandaloneVpsMetadataRows(input);
+    const metadataRows = createServerMetadataRows(input);
     if (metadataRows.length === 0) {
         return;
     }
 
-    const metadataTableName = `${input.tablePrefix}Metadata`;
-    const supabase = $provideSupabaseForServer() as SupabaseClient;
-    const { error } = await supabase.from(metadataTableName).upsert([...metadataRows], {
-        onConflict: 'key',
-    });
-
-    if (error) {
-        throw new DatabaseError(
-            spaceTrim(`
-                Failed to update standalone VPS server metadata.
+    await runWithServerContextOverride(createProvidedServer(input.server), async () => {
+        const metadataTableName = await $getTableName('Metadata');
+        const supabase = $provideSupabaseForServer() as SupabaseClient;
+        await writeServerMetadataRows({
+            metadataRows,
+            metadataTableName,
+            serverName: input.server.name,
+            supabase,
+        });
 
-                ${error.message}
-            `),
-        );
-    }
+        invalidateMetadataCache();
+    });
 }
 
 /**
@@ -88,36 +92,113 @@ export async function applyStandaloneVpsServerMetadata(input: {
  * @private internal standalone VPS server management helper.
  */
 export async function resolveStandaloneVpsServerDisplayName(server: ServerRecord): Promise<string> {
-    const metadataTableName = `${server.tablePrefix}Metadata`;
-    const supabase = $provideSupabaseForServer() as SupabaseClient;
-    const { data, error } = await supabase
-        .from(metadataTableName)
-        .select('value')
-        .eq('key', SERVER_NAME_METADATA_KEY)
-        .maybeSingle<{ readonly value: string | null }>();
-
-    if (error) {
-        return server.name;
+    return runWithServerContextOverride(createProvidedServer(server), async () => {
+        const metadataTableName = await $getTableName('Metadata');
+        const supabase = $provideSupabaseForServer() as SupabaseClient;
+        const { data, error } = await supabase
+            .from(metadataTableName)
+            .select('value')
+            .eq('key', SERVER_NAME_METADATA_KEY)
+            .maybeSingle<{ readonly value: string | null }>();
+
+        if (error) {
+            return server.name;
+        }
+
+        const metadataName = typeof data?.value === 'string' ? data.value.trim() : '';
+        return metadataName || server.name;
+    });
+}
+
+/**
+ * Creates the routing context required to access one server's isolated metadata.
+ *
+ * @param server - Server whose metadata should be accessed.
+ * @returns Explicit routing context for the server.
+ *
+ * @private function of standalone VPS server management.
+ */
+function createProvidedServer(server: ServerRecord): ProvidedServer {
+    return {
+        id: server.id,
+        publicUrl: createServerPublicUrl(server.domain),
+        tablePrefix: server.tablePrefix,
+    };
+}
+
+/**
+ * Updates metadata rows when they exist and creates them when they do not.
+ *
+ * This deliberately does not use the Supabase `upsert` convenience method because
+ * the standalone SQLite adapter cannot overwrite an existing metadata row through it.
+ *
+ * @param input - Target table, rows, and client for the selected server.
+ * @private function of standalone VPS server management.
+ */
+async function writeServerMetadataRows(input: {
+    readonly metadataRows: ReadonlyArray<ServerMetadataRow>;
+    readonly metadataTableName: string;
+    readonly serverName: string;
+    readonly supabase: SupabaseClient;
+}): Promise<void> {
+    for (const metadataRow of input.metadataRows) {
+        const { data: updatedRows, error: updateError } = await input.supabase
+            .from(input.metadataTableName)
+            .update({
+                value: metadataRow.value,
+                updatedAt: metadataRow.updatedAt,
+            })
+            .eq('key', metadataRow.key)
+            .select('key');
+
+        if (updateError) {
+            throw createServerMetadataWriteError(input.serverName, metadataRow.key, updateError.message);
+        }
+
+        if ((updatedRows ?? []).length > 0) {
+            continue;
+        }
+
+        const { error: insertError } = await input.supabase.from(input.metadataTableName).insert(metadataRow);
+        if (insertError) {
+            throw createServerMetadataWriteError(input.serverName, metadataRow.key, insertError.message);
+        }
     }
+}
 
-    const metadataName = typeof data?.value === 'string' ? data.value.trim() : '';
-    return metadataName || server.name;
+/**
+ * Creates a branded error for a failed server-specific metadata write.
+ *
+ * @param serverName - Name of the server whose metadata could not be persisted.
+ * @param metadataKey - Metadata key that could not be persisted.
+ * @param details - Database error details.
+ * @returns Branded metadata persistence error.
+ * @private function of standalone VPS server management.
+ */
+function createServerMetadataWriteError(serverName: string, metadataKey: string, details: string): DatabaseError {
+    return new DatabaseError(
+        spaceTrim(`
+            Failed to update metadata \`${metadataKey}\` for server \`${serverName}\`.
+
+            ${details}
+        `),
+    );
 }
 
 /**
  * Creates metadata rows from visible setup fields.
  *
  * @param input - Raw setup values.
- * @returns Metadata rows ready for upsert.
+ * @returns Metadata rows ready for persistence.
  *
  * @private function of standalone VPS server management.
  */
-function createStandaloneVpsMetadataRows(input: {
+function createServerMetadataRows(input: {
     readonly name?: string | null;
     readonly iconUrl?: string | null;
-}): ReadonlyArray<StandaloneVpsMetadataRow> {
+}): ReadonlyArray<ServerMetadataRow> {
     const updatedAt = new Date().toISOString();
-    const rows: Array<StandaloneVpsMetadataRow> = [];
+    const rows: Array<ServerMetadataRow> = [];
     const name = typeof input.name === 'string' ? input.name.trim() : '';
     const iconUrl = typeof input.iconUrl === 'string' ? input.iconUrl.trim() : '';
 

package/apps/agents-server/src/utils/serverRegistry.ts

@@ -2,6 +2,7 @@ import { createClient, type SupabaseClient } from '@supabase/supabase-js';
 import { spaceTrim } from 'spacetrim';
 import { DatabaseError } from '../../../../src/errors/DatabaseError';
 import { isAgentsServerSqliteMode } from '../database/agentsServerDatabaseMode';
+import { buildDomainTablePrefix } from './buildDomainTablePrefix';
 
 /**
  * Supported `_Server.environment` values.
@@ -140,7 +141,18 @@ export async function listRegisteredServersUsingServiceRole(options?: {
     const environmentServers = listEnvironmentRegisteredServers();
 
     if (isAgentsServerSqliteMode()) {
-        return environmentServers;
+        if (isEdgeRuntime()) {
+            // Note: The Edge middleware cannot open SQLite files. It only needs the domain list
+            //       for host matching and never queries server tables in SQLite mode, so the
+            //       environment-derived rows are sufficient there.
+            return environmentServers;
+        }
+
+        // Note: In standalone SQLite mode the VPS registry database is the source of truth.
+        //       Every server row carries its own unique table prefix selecting the isolated
+        //       per-server database file, so servers cannot leak data into each other.
+        const { listStandaloneRegisteredServers } = await import('../database/sqlite/standaloneServerRegistryStore');
+        return listStandaloneRegisteredServers();
     }
 
     const shouldReuseCache =
@@ -171,7 +183,11 @@ export async function listRegisteredServersUsingServiceRole(options?: {
 /**
  * Loads virtual server records from the comma-separated `SERVERS` environment variable.
  *
- * @returns Server records with deterministic table prefixes from the configured server prefix or normalized domains.
+ * Every domain gets its own deterministic domain-derived table prefix so servers can
+ * never share one namespace. The configured `SUPABASE_TABLE_PREFIX` is honored only
+ * for a single-domain setup where no ambiguity exists.
+ *
+ * @returns Server records with per-domain deterministic table prefixes.
  */
 export function listEnvironmentRegisteredServers(): Array<ServerRecord> {
     const rawServers = process.env[SERVERS_ENV_NAME];
@@ -192,12 +208,24 @@ export function listEnvironmentRegisteredServers(): Array<ServerRecord> {
         name: domain,
         environment: SERVER_ENVIRONMENT.PRODUCTION,
         domain,
-        tablePrefix: configuredTablePrefix || buildEnvironmentServerTablePrefix(domain),
+        tablePrefix:
+            normalizedDomains.length === 1 && configuredTablePrefix
+                ? configuredTablePrefix
+                : buildDomainTablePrefix(domain),
         createdAt: ENVIRONMENT_SERVER_TIMESTAMP,
         updatedAt: ENVIRONMENT_SERVER_TIMESTAMP,
     }));
 }
 
+/**
+ * Checks whether the current code runs inside the Next.js Edge runtime.
+ *
+ * @returns `true` when running in the Edge runtime (for example in middleware).
+ */
+function isEdgeRuntime(): boolean {
+    return process.env.NEXT_RUNTIME === 'edge';
+}
+
 /**
  * Finds one registered server by incoming host header.
  *
@@ -500,25 +528,6 @@ function mergeRegisteredServers(
     return mergedServers;
 }
 
-/**
- * Builds a deterministic table prefix from a normalized domain.
- *
- * @param domain - Normalized server domain.
- * @returns Prefix such as `server_www_example_com_`.
- */
-function buildEnvironmentServerTablePrefix(domain: string): string {
-    const prefixSuffix = domain
-        .toLowerCase()
-        .replace(/-/gu, '_dash_')
-        .replace(/\./gu, '_')
-        .replace(/:/gu, '_port_')
-        .replace(/[^a-z0-9_]/gu, '_')
-        .replace(/_+/gu, '_')
-        .replace(/^_+|_+$/gu, '');
-
-    return `server_${prefixSuffix}_`;
-}
-
 /**
  * Deduplicates non-empty strings while preserving input order.
  *

package/apps/agents-server/src/utils/stalwart/StalwartConfiguration.ts

@@ -0,0 +1,36 @@
+import { resolveStalwartApiUrl } from './resolveStalwartApiUrl';
+
+/**
+ * Environment-backed connection settings for the bundled Stalwart instance.
+ */
+export type StalwartConfiguration = {
+    readonly apiUrl: string;
+    readonly authorization: string | null;
+    readonly hookToken: string | null;
+    readonly smtpPassword: string | null;
+    readonly isConfigured: boolean;
+};
+
+/**
+ * Reads Stalwart API and transport configuration without exposing secret values to UI callers.
+ */
+export function readStalwartConfiguration(): StalwartConfiguration {
+    const apiToken = process.env.PTBK_STALWART_API_TOKEN?.trim();
+    const apiUsername = process.env.PTBK_STALWART_API_USERNAME?.trim();
+    const apiPassword = process.env.PTBK_STALWART_API_PASSWORD;
+    const authorization = apiToken
+        ? `Bearer ${apiToken}`
+        : apiUsername && apiPassword
+          ? `Basic ${Buffer.from(`${apiUsername}:${apiPassword}`).toString('base64')}`
+          : null;
+    const hookToken = process.env.PTBK_STALWART_MTA_HOOK_TOKEN?.trim() || null;
+    const smtpPassword = process.env.PTBK_STALWART_SMTP_PASSWORD || null;
+
+    return {
+        apiUrl: resolveStalwartApiUrl(process.env.PTBK_STALWART_API_URL),
+        authorization,
+        hookToken,
+        smtpPassword,
+        isConfigured: Boolean(authorization && hookToken && smtpPassword),
+    };
+}

package/apps/agents-server/src/utils/stalwart/captureStalwartSynchronizationResult.ts

@@ -0,0 +1,30 @@
+/**
+ * Outcome of one administrator-triggered Stalwart synchronization.
+ */
+export type StalwartSynchronizationResult = {
+    readonly isSuccessful: boolean;
+    readonly errorMessage: string | null;
+};
+
+/**
+ * Runs one Stalwart synchronization and turns an unavailable or misconfigured mail service into a
+ * reportable result.
+ *
+ * Stalwart being unreachable, still in bootstrap mode, or rejecting a management method is an operational
+ * state which administrators have to see and act on, not a server crash.
+ */
+export async function captureStalwartSynchronizationResult(
+    synchronize: () => Promise<void>,
+): Promise<StalwartSynchronizationResult> {
+    try {
+        await synchronize();
+        return { isSuccessful: true, errorMessage: null };
+    } catch (error) {
+        console.error('[stalwart-email]', 'administrator_synchronization_failed', { error });
+
+        return {
+            isSuccessful: false,
+            errorMessage: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/apps/agents-server/src/utils/stalwart/createEmailDnsInstructions.ts

@@ -0,0 +1,69 @@
+import type { DnsRecordInstruction } from '../dnsRecords/DnsRecordInstruction';
+
+/**
+ * One DNS record required or recommended for reliable mail delivery.
+ */
+export type EmailDnsInstruction = DnsRecordInstruction & {
+    /**
+     * DNS record type required or recommended for Stalwart email delivery.
+     */
+    readonly type: 'A' | 'CAA' | 'MX' | 'TXT';
+};
+
+/**
+ * Creates the domain-specific baseline DNS records for Stalwart email.
+ *
+ * DKIM records are intentionally read from Stalwart's generated zone because their public keys must never be guessed.
+ */
+export function createEmailDnsInstructions(domain: string): EmailDnsInstruction[] {
+    return [
+        {
+            type: 'A',
+            name: `mail.${domain}`,
+            value: '<VPS_PUBLIC_IP>',
+            note: 'Mail server host. Use the same public IPv4 address as this VPS.',
+        },
+        {
+            type: 'MX',
+            name: domain,
+            value: `10 mail.${domain}.`,
+            note: 'Routes inbound mail for the Agents Server domain to Stalwart.',
+        },
+        {
+            type: 'TXT',
+            name: domain,
+            value: 'v=spf1 mx -all',
+            note: 'SPF permits only this domain’s MX host to send mail.',
+        },
+        {
+            type: 'TXT',
+            name: `_dmarc.${domain}`,
+            value: `v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@${domain}; adkim=s; aspf=s`,
+            note: 'DMARC requests strict alignment and aggregate reports.',
+        },
+        {
+            type: 'TXT',
+            name: `_smtp._tls.${domain}`,
+            value: `v=TLSRPTv1; rua=mailto:tls-reports@${domain}`,
+            note: 'Receives reports about TLS delivery failures.',
+        },
+        {
+            type: 'A',
+            name: `mta-sts.${domain}`,
+            value: '<VPS_PUBLIC_IP>',
+            note: 'Hosts the HTTPS MTA-STS policy for this mail domain.',
+        },
+        {
+            type: 'TXT',
+            name: `_mta-sts.${domain}`,
+            value: 'v=STSv1; id=20260725',
+            note: 'Advertises the current MTA-STS policy version. Change the id whenever the policy changes.',
+        },
+        {
+            type: 'CAA',
+            name: domain,
+            value: '0 issue "letsencrypt.org"',
+            note: 'Authorizes Let’s Encrypt to issue the public SMTP and MTA-STS TLS certificates.',
+        },
+    ];
+}