feat(core): the e-mail server keeps /mailserver/konten.txt up to date at run time, measured against Java

The account file's writer moves from the export (packages/fls) into the
core, so that the export and the running server write the same. The
server writes the file at its start and whenever its accounts change.
EmailRun now records Java's file as it left it and as Java writes the
accounts it ended with; Java leaves the notice to a local sender out until
its next write.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

packages/core/src/runtime/emailAccountsFile.ts

@@ -0,0 +1,66 @@
+// The e-mail server's account file, /mailserver/konten.txt, as Java writes
+// it (EmailServer.listeBenutzerkontenZuString): Java's server reads it at
+// every simulation start and writes it when its accounts change. Written by
+// the server at run time and by the project export (packages/fls), from the
+// accounts the model keeps. Java's errors are not copied: a field is written
+// empty where Java writes "null" (a message's date, which Java never sets),
+// and a character a field cannot carry in the format (a separator, a line
+// break) becomes a space, with a warning.
+
+import type { EmailAddress, EmailServerAccount } from './config.js';
+
+export const EMAIL_SERVER_ACCOUNTS_FILE = '/mailserver/konten.txt';
+
+/** A field's characters the format cannot carry, each a space, with a warning. */
+export function accountFileField(value: string, forbidden: RegExp, what: string, warn: (message: string) => void): string {
+  if (!forbidden.test(value)) return value;
+  warn(`${what} holds a character Java's account file cannot carry, written there with a space`);
+  return value.replace(new RegExp(forbidden.source, 'g'), ' ');
+}
+
+/**
+ * EmailServer.listeBenutzerkontenZuString: per account a line of user,
+ * domain, password, last and first name, then its messages, each "#" and
+ * seven fields joined by "$" — the text with Java's escapes
+ * (replaceSpecialChar, then line breaks as "|"), the others unescaped.
+ */
+export function serverAccountsFileText(domain: string, accounts: readonly EmailServerAccount[], warn: (message: string) => void = () => {}): string {
+  const where = (what: string) => `${EMAIL_SERVER_ACCOUNTS_FILE}: ${what}`;
+  const plain = (value: string, what: string) => accountFileField(value, /[;#$\r\n]/, where(what), warn);
+  const address = (entry: EmailAddress, what: string) => {
+    const name = entry.name === null ? null : accountFileField(entry.name, /[;#$,<>\r\n]/, where(what), warn);
+    const mail = entry.mailAddress === null ? null : accountFileField(entry.mailAddress, /[;#$,<>\r\n]/, where(what), warn);
+    if (name === null) return mail === null ? '' : `<${mail}>`;
+    return mail === null ? name : `${name} <${mail}>`;
+  };
+  const addresses = (entries: readonly EmailAddress[], what: string) => entries.map((entry) => address(entry, what)).join(',');
+  const escapedText = (text: string) =>
+    text.replace(/\$/g, '&&00036&&').replace(/;/g, '&&00059&&').replace(/\|/g, '&&00124&&').replace(/#/g, '&&00035&&').replace(/\n/g, '|');
+  return accounts
+    .map((account) => {
+      const messages = account.mailbox
+        .map(
+          (message) =>
+            '#' +
+            [
+              address(message.from, 'a sender'),
+              addresses(message.to, 'a recipient'),
+              addresses(message.cc, 'a recipient'),
+              addresses(message.bcc, 'a recipient'),
+              message.receivedAtMilliseconds === undefined ? '' : String(message.receivedAtMilliseconds),
+              plain(message.subject, 'a subject'),
+              accountFileField(escapedText(message.body), /\r$/, where('a text'), warn),
+            ].join('$'),
+        )
+        .join('');
+      return [
+        plain(account.username, 'a user name'),
+        domain,
+        plain(account.password, 'a password'),
+        plain(account.lastName, 'a last name'),
+        plain(account.firstName, 'a first name'),
+        messages,
+      ].join(';') + '\n';
+    })
+    .join('');
+}

packages/core/src/runtime/engine.ts

@@ -121,7 +121,8 @@ import { EmailServer } from './apps/emailServer.js';
 import { Terminal } from './apps/terminal.js';
 import { firewallLogPage, forwardingTablePage, ripTablePage, routerIndexPage } from './apps/routerPages.js';
 import { applyFirewallSettings, firewallSettingsPage } from './apps/firewallSettings.js';
-import { VirtualFileSystem } from '../model/virtualFileSystem.js';
+import { parentPath, VirtualFileSystem } from '../model/virtualFileSystem.js';
+import { EMAIL_SERVER_ACCOUNTS_FILE, serverAccountsFileText } from './emailAccountsFile.js';
 import {
   PRODUCTION_TRACE_RETENTION,
   type HeaderField,
@@ -1181,6 +1182,33 @@ export class NetworkRuntimeEngine {
     if (server === undefined) return;
     servers.set(nodeId, { ...server, accounts });
     this.stateValue.topologySnapshot = withSnapshot(this.stateValue.topologySnapshot, { emailServersByNodeId: servers });
+    this.writeEmailServerAccountsFile(nodeId, server.domain, accounts);
+  }
+
+  /**
+   * The server's account file (EmailServer.kontenSpeichern), written from its
+   * accounts at its start and whenever they change. Java makes it empty at
+   * its start when it is missing (and reads it), and writes it when an
+   * account is made or removed, after a POP3 command, after an SMTP mail was
+   * taken and when it stops — but before the notice to a local sender, which
+   * its file shows only at the next write.
+   */
+  private writeEmailServerAccountsFile(nodeId: Id, domain: string, accounts: readonly EmailServerAccount[]): void {
+    const files = this.nodeFiles(nodeId);
+    const directory = parentPath(EMAIL_SERVER_ACCOUNTS_FILE);
+    if (!files.contains(directory)) files.createDirectory(directory, true);
+    files.writeTextFile(EMAIL_SERVER_ACCOUNTS_FILE, serverAccountsFileText(domain, accounts));
+  }
+
+  /** The node's files; a node without any gets an empty file system, kept in the snapshot. */
+  private nodeFiles(nodeId: Id): VirtualFileSystem {
+    const existing = this.stateValue.topologySnapshot.fileSystemsByNodeId.get(nodeId);
+    if (existing !== undefined) return existing;
+    const files = new VirtualFileSystem();
+    this.stateValue.topologySnapshot = withSnapshot(this.stateValue.topologySnapshot, {
+      fileSystemsByNodeId: new Map([...this.stateValue.topologySnapshot.fileSystemsByNodeId, [nodeId, files]]),
+    });
+    return files;
   }
 
   /**
@@ -1220,18 +1248,9 @@ export class NetworkRuntimeEngine {
             this.wallClock,
           ),
         );
+        this.writeEmailServerAccountsFile(nodeId, emailServer.domain, emailServer.accounts);
       }
-      if (snapshot.terminalNodeIds.has(node.id)) {
-        let files = snapshot.fileSystemsByNodeId.get(node.id);
-        if (files === undefined) {
-          // A node without files gets an empty file system, kept in the snapshot.
-          files = new VirtualFileSystem();
-          this.stateValue.topologySnapshot = withSnapshot(this.stateValue.topologySnapshot, {
-            fileSystemsByNodeId: new Map([...this.stateValue.topologySnapshot.fileSystemsByNodeId, [node.id, files]]),
-          });
-        }
-        this.terminalsByNodeId.set(node.id, new Terminal(this, node.id, files));
-      }
+      if (snapshot.terminalNodeIds.has(node.id)) this.terminalsByNodeId.set(node.id, new Terminal(this, node.id, this.nodeFiles(node.id)));
       const emailClient = snapshot.emailClientsByNodeId.get(node.id);
       if (emailClient !== undefined) {
         const nodeId = node.id;