IMAP-Posteingang: Zuordnung nur mit signiertem Antwort-Bezug, Wiederholung, Dubletten (#107)

- Absender (From) und Ticketnummer im Betreff sind fälschbar und ordnen nicht
  mehr automatisch zu. Ausgehende Ticket-Mails tragen eine Message-ID mit
  Ticket-ID + HMAC (KC_SECRET_KEY); nur Antworten mit gültigem Bezug in
  In-Reply-To/References von einem aktiven Mitglied des aktiven Kunden
  werden angehängt. Alles andere: Posteingang mit vorausgefülltem Vorschlag.
- Fehler einer UID: last_uid bleibt davor stehen, bis zu 5 Wiederholungen,
  danach als nicht verarbeitbar im Posteingang abgelegt (Mail geht nicht
  verloren). UIDVALIDITY wird gespeichert; Wechsel = neuer Startpunkt.
- Verarbeitung je Nachricht in einer Transaktion; Dubletten-Schutz per
  UNIQUE(uid_validity, uid); Ticketnummern über dieselbe Verbindung.
- Posteingang zuweisen/anhängen/ignorieren atomar (kein Doppel-Ticket).
- Migration 039.

Hinweis: neue Mails bekannter Kunden ohne Bezug legen kein Ticket mehr
automatisch an, sondern warten im Posteingang (Vorschlag vorausgefüllt).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude (KI) 2026-10-06 11:24:36 +02:00
parent 7a5f0b6d24
commit 914599df50
11 changed files with 236 additions and 103 deletions

View file

@ -130,7 +130,7 @@ export const mailModule: KcModule = {
const params: unknown[] = [b.host, b.port, b.secureMode, b.username, b.folder, b.enabled ? 1 : 0, a.user.id];
if (b.password !== undefined) { sets.push('secrets_enc = ?'); params.push(b.password ? encrypt(JSON.stringify({ password: b.password })) : null); }
// Verbindungsdaten geändert: nächster Abruf beginnt wieder beim aktuellen Postfachstand (kein Bestand wird nachverarbeitet)
if (b.host || b.username || b.password) { sets.push('last_uid = NULL'); }
if (b.host || b.username || b.password) { sets.push('last_uid = NULL', 'uid_validity = NULL', 'failed_uid = NULL', 'failed_attempts = 0'); }
await run(`UPDATE imap_settings SET ${sets.join(', ')} WHERE id = 1`, params);
await audit({ actorType: 'user', actorId: a.user.id, action: 'email.imap.update', resourceType: 'imap_settings', resourceId: '1', correlationId: req.correlationId, ip: clientIp(req), after: { ...b, password: b.password !== undefined ? (b.password ? '***' : null) : undefined } });
return { ok: true };

View file

@ -33,7 +33,7 @@ const TICKET_SQL = `SELECT t.*, g.name AS org_name, g.customer_number, u.name AS
const messageView = (m: any, atts: any[] = []) => ({ id: m.id, authorId: m.author_id, authorName: m.author_name, authorKind: m.author_kind, body: m.body, internalNote: !!m.internal_note, createdAt: m.created_at,
attachments: atts.filter((a) => a.message_id === m.id).map((a) => ({ id: a.id, filename: a.filename, contentType: a.content_type, sizeBytes: a.size_bytes })) });
const notify = (event: string, extra: Record<string, unknown>, key: string, correlationId: string) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key, correlationId });
const mailTo = (to: string, template: string, vars: Record<string, string>, key: string, correlationId: string) => enqueue('mail.template', { to, key: template, vars }, { idempotencyKey: key, correlationId });
const mailTo = (to: string, template: string, vars: Record<string, string>, key: string, correlationId: string, replyTicketId?: string) => enqueue('mail.template', { to, key: template, vars, replyTicketId }, { idempotencyKey: key, correlationId });
/** Meldet neue Nachrichten/Status auf CUSTOMER-sichtbare Zeilen; interne Notizen werden für Kunden ausgefiltert. */
async function loadTicket(id: string, forCustomer: boolean) {
@ -72,7 +72,7 @@ export const ticketsModule: KcModule = {
await audit({ actorType: 'user', actorId: a.user.id, orgId: b.orgId, action: 'ticket.create', resourceType: 'ticket', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { number, subject: b.subject } });
if (!staff) {
await notify('ticket.created', { number, subject: b.subject.slice(0, 100) }, `ticket.created:${id}`, req.correlationId);
await mailTo(a.user.email, 'ticket_created', { name: a.user.name, number, subject: b.subject, ticketLink: ticketLink(id) }, `mail:ticket.created:${id}`, req.correlationId);
await mailTo(a.user.email, 'ticket_created', { name: a.user.name, number, subject: b.subject, ticketLink: ticketLink(id) }, `mail:ticket.created:${id}`, req.correlationId, id);
await enqueue('discord.ticket_sync', { ticketId: id, body: b.body, authorLabel: 'Kunde' }, { idempotencyKey: `discord:ticket.created:${id}`, correlationId: req.correlationId });
}
return { id, number, messageId };
@ -123,7 +123,7 @@ export const ticketsModule: KcModule = {
let emailed = false;
if (!b.internalNote && staff && b.notifyEmail) {
const creator = await one('SELECT email, name FROM users WHERE id = ?', [t.created_by]);
if (creator) { await mailTo(creator.email, 'ticket_message', { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(id) }, `mail:ticket.message:${id}:${Date.now()}`, req.correlationId); emailed = true; }
if (creator) { await mailTo(creator.email, 'ticket_message', { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(id) }, `mail:ticket.message:${id}:${Date.now()}`, req.correlationId, id); emailed = true; }
}
return { ok: true, messageId, emailed };
});
@ -195,29 +195,35 @@ export const ticketsModule: KcModule = {
});
// ---- Posteingang: eingehende Mails, die der IMAP-Abruf keinem Ticket zuordnen konnte -----------
const inboxView = (m: any) => ({ id: m.id, fromEmail: m.from_email, fromName: m.from_name, subject: m.subject, bodyText: m.body_text, receivedAt: m.received_at, status: m.status, ticketId: m.ticket_id, ticketNumber: m.ticket_number ?? null });
// suggested*: nur Hinweise aus Betreff/Absender (fälschbar) – das Personal entscheidet, automatisch wird nichts zugeordnet (#107)
const inboxView = (m: any) => ({ id: m.id, fromEmail: m.from_email, fromName: m.from_name, subject: m.subject, bodyText: m.body_text, receivedAt: m.received_at, status: m.status, ticketId: m.ticket_id, ticketNumber: m.ticket_number ?? null,
suggestedTicketNumber: m.suggested_ticket_number ?? null, suggestedOrgId: m.suggested_org_id ?? null, processingError: m.processing_error ?? null });
app.get('/admin/inbox', async (req) => {
requirePermission(req, 'tickets.read');
const q = z.object({ status: z.enum(['unmatched', 'matched', 'created', 'ignored']).optional() }).parse(req.query);
const rows = await query('SELECT im.*, t.number AS ticket_number FROM inbox_messages im LEFT JOIN tickets t ON t.id = im.ticket_id WHERE (? IS NULL OR im.status = ?) ORDER BY im.received_at DESC LIMIT 200', [q.status ?? null, q.status ?? null]);
const rows = await query(`SELECT im.*, t.number AS ticket_number, st.number AS suggested_ticket_number,
(SELECT m.org_id FROM memberships m WHERE m.user_id = im.suggested_user_id ORDER BY (m.role = 'owner') DESC LIMIT 1) AS suggested_org_id
FROM inbox_messages im LEFT JOIN tickets t ON t.id = im.ticket_id LEFT JOIN tickets st ON st.id = im.suggested_ticket_id
WHERE (? IS NULL OR im.status = ?) ORDER BY im.received_at DESC LIMIT 200`, [q.status ?? null, q.status ?? null]);
return rows.map(inboxView);
});
/** Unbekannter Absender wird einem Kunden zugeordnet: neues Ticket, Autor ist der (erste) Ansprechpartner des Kunden. */
app.post('/admin/inbox/:id/assign', async (req) => {
const a = requirePermission(req, 'tickets.write'); const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const b = z.object({ orgId: z.string().uuid() }).parse(req.body);
const msg = await one('SELECT * FROM inbox_messages WHERE id = ?', [id]); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
const owner = await one("SELECT user_id FROM memberships WHERE org_id = ? ORDER BY (role = 'owner') DESC LIMIT 1", [b.orgId]);
if (!owner) throw badRequest('Für diesen Kunden ist kein Ansprechpartner hinterlegt.', 'NO_MEMBER');
const ticketId = randomUUID();
const number = await tx(async (c) => {
// Status unter Zeilensperre prüfen und im selben Schritt setzen: zwei gleichzeitige Klicks erzeugen kein zweites Ticket
const { number, msg } = await tx(async (c) => {
const msg = await one('SELECT * FROM inbox_messages WHERE id = ? FOR UPDATE', [id], c); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
const n = await nextNumber(c);
await run('INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?,?,?,?)', [ticketId, n, b.orgId, msg.subject || '(kein Betreff)', 'pending_staff', 'normal', owner.user_id], c);
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticketId, owner.user_id, 'customer', msg.body_text || '(kein Text)'], c);
return n;
await run("UPDATE inbox_messages SET status = 'created', ticket_id = ? WHERE id = ?", [ticketId, id], c);
return { number: n, msg };
});
await run("UPDATE inbox_messages SET status = 'created', ticket_id = ? WHERE id = ?", [ticketId, id]);
await audit({ actorType: 'user', actorId: a.user.id, orgId: b.orgId, action: 'inbox.assign', resourceType: 'inbox_message', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { ticketId, number } });
await notify('ticket.created', { number, subject: (msg.subject || '').slice(0, 100) }, `mail-in-assign:${id}`, req.correlationId);
return { ticketId, number };
@ -226,21 +232,22 @@ export const ticketsModule: KcModule = {
app.post('/admin/inbox/:id/link', async (req) => {
const a = requirePermission(req, 'tickets.write'); const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const b = z.object({ ticketNumber: z.string().trim().min(1).max(20) }).parse(req.body);
const msg = await one('SELECT * FROM inbox_messages WHERE id = ?', [id]); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
const t = await one('SELECT * FROM tickets WHERE number = ?', [b.ticketNumber]); if (!t) throw badRequest('Ticket nicht gefunden.', 'TICKET_NOT_FOUND');
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.id, t.created_by, 'customer', msg.body_text || '(kein Text)']);
await run("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.id]);
await run("UPDATE inbox_messages SET status = 'matched', ticket_id = ? WHERE id = ?", [t.id, id]);
await tx(async (c) => {
const msg = await one('SELECT * FROM inbox_messages WHERE id = ? FOR UPDATE', [id], c); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.id, t.created_by, 'customer', msg.body_text || '(kein Text)'], c);
await run("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.id], c);
await run("UPDATE inbox_messages SET status = 'matched', ticket_id = ? WHERE id = ?", [t.id, id], c);
});
await audit({ actorType: 'user', actorId: a.user.id, orgId: t.org_id, action: 'inbox.link', resourceType: 'inbox_message', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { ticketId: t.id } });
await notify('ticket.message', { number: t.number }, `mail-in-link:${id}`, req.correlationId);
return { ok: true };
});
app.post('/admin/inbox/:id/ignore', async (req) => {
const a = requirePermission(req, 'tickets.write'); const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const msg = await one('SELECT status FROM inbox_messages WHERE id = ?', [id]); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
await run("UPDATE inbox_messages SET status = 'ignored' WHERE id = ?", [id]);
const r = await run("UPDATE inbox_messages SET status = 'ignored' WHERE id = ? AND status = 'unmatched'", [id]);
if (r.affectedRows === 0) { if (!(await one('SELECT 1 AS x FROM inbox_messages WHERE id = ?', [id]))) throw notFound(); throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED'); }
await audit({ actorType: 'user', actorId: a.user.id, action: 'inbox.ignore', resourceType: 'inbox_message', resourceId: id, correlationId: req.correlationId, ip: clientIp(req) });
return { ok: true };
});

View file

@ -0,0 +1,50 @@
import { beforeAll, describe, expect, it } from 'vitest';
import { randomUUID } from 'node:crypto';
import { one, query, run } from '../src/core/db.js';
import { processMessage } from '../../worker/src/mailbox.js';
import { ticketReplyMessageId } from '@kc/platform/ticketmail';
import { makeUser } from './helpers.js';
const log = () => undefined;
const mail = (h: Record<string, string>, body = 'Hallo') => Buffer.from(Object.entries({ Date: new Date().toUTCString(), 'Message-ID': `<${randomUUID()}@ext.example>`, ...h }).map(([k, v]) => `${k}: ${v}`).join('\r\n') + '\r\n\r\n' + body);
let org: string; let ticketId: string; let ticketNumber: string;
beforeAll(async () => {
org = randomUUID(); await run("INSERT INTO organizations (id, customer_number, name, customer_type) VALUES (?, 'K-MAIL1', 'Mail AG', 'business')", [org]);
const u = await makeUser({ email: 'kunde@mail.example' }); await run("INSERT INTO memberships (org_id, user_id, role) VALUES (?,?,'owner')", [org, u]);
ticketId = randomUUID(); ticketNumber = 'T-77001';
await run("INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?, 'pending_customer', 'normal', ?)", [ticketId, ticketNumber, org, 'Problem', u]);
});
const msgs = () => query('SELECT body FROM ticket_messages WHERE ticket_id = ?', [ticketId]);
describe('IMAP-Posteingang (#107)', () => {
it('gefälschter Absender + Ticketnummer im Betreff hängt NICHTS an, landet mit Vorschlag im Posteingang', async () => {
await processMessage(1001, 9, mail({ From: 'kunde@mail.example', To: 'support@x', Subject: `Re: ${ticketNumber} Problem` }, 'gefälscht'), log);
expect(await msgs()).toHaveLength(0);
const r = await one('SELECT status, suggested_ticket_id, suggested_user_id FROM inbox_messages WHERE uid = 1001');
expect(r!.status).toBe('unmatched'); expect(r!.suggested_ticket_id).toBe(ticketId); expect(r!.suggested_user_id).toBeTruthy();
});
it('Antwort mit signiertem Bezug vom Kunden wird angehängt; Wiederholung derselben UID erzeugt keine Dublette', async () => {
const ref = ticketReplyMessageId(ticketId, 'support@flexible-domains.de');
const src = mail({ From: 'Kunde <kunde@mail.example>', To: 'support@x', Subject: 'Re: Ihr Ticket', 'In-Reply-To': ref, References: ref }, 'echte Antwort');
await processMessage(1002, 9, src, log);
await processMessage(1002, 9, src, log); // erneuter Lauf (z. B. nach Abbruch) – keine zweite Nachricht
expect((await msgs()).map((m) => m.body)).toEqual(['echte Antwort']);
expect((await one('SELECT status FROM tickets WHERE id = ?', [ticketId]))!.status).toBe('pending_staff');
});
it('gültiger Bezug, aber fremder Absender oder manipulierte Signatur → Posteingang', async () => {
const ref = ticketReplyMessageId(ticketId, 'support@flexible-domains.de');
await processMessage(1003, 9, mail({ From: 'angreifer@evil.example', Subject: 'Re', 'In-Reply-To': ref }), log);
const forged = ref.replace(/\.([A-Za-z0-9_-]{22})\./, '.AAAAAAAAAAAAAAAAAAAAAA.');
await processMessage(1004, 9, mail({ From: 'kunde@mail.example', Subject: 'Re', 'In-Reply-To': forged }), log);
expect((await msgs())).toHaveLength(1);
expect((await query("SELECT uid FROM inbox_messages WHERE uid IN (1003,1004) AND status = 'unmatched'"))).toHaveLength(2);
});
it('gesperrter Kunde: auch mit gültigem Bezug keine automatische Antwort', async () => {
await run("UPDATE organizations SET status = 'suspended' WHERE id = ?", [org]);
const ref = ticketReplyMessageId(ticketId, 'support@flexible-domains.de');
await processMessage(1005, 9, mail({ From: 'kunde@mail.example', Subject: 'Re', 'In-Reply-To': ref }), log);
expect((await msgs())).toHaveLength(1);
await run("UPDATE organizations SET status = 'active' WHERE id = ?", [org]);
});
});

View file

@ -4,13 +4,14 @@ import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { Alert, Empty, fmt } from '@/components/ui';
interface Msg { id: string; fromEmail: string; fromName: string | null; subject: string | null; bodyText: string | null; receivedAt: string; status: 'unmatched' | 'matched' | 'created' | 'ignored'; ticketId: string | null; ticketNumber: string | null }
interface Msg { id: string; fromEmail: string; fromName: string | null; subject: string | null; bodyText: string | null; receivedAt: string; status: 'unmatched' | 'matched' | 'created' | 'ignored'; ticketId: string | null; ticketNumber: string | null; suggestedTicketNumber: string | null; suggestedOrgId: string | null; processingError: string | null }
interface Cust { id: string; name: string; customerNumber: string }
const STATUS_LABEL: Record<Msg['status'], string> = { unmatched: 'Unzugeordnet', matched: 'An Ticket angehängt', created: 'Ticket erstellt', ignored: 'Ignoriert' };
/** Eine unzugeordnete Mail: Kunde zuweisen (legt neues Ticket an), an bestehendes Ticket anhängen, oder ignorieren. */
function UnmatchedRow({ m, custs, onDone, onError }: { m: Msg; custs: Cust[]; onDone: (t: string) => void; onError: (m: string) => void }) {
const [org, setOrg] = useState(''); const [ticketNumber, setTicketNumber] = useState(''); const [busy, setBusy] = useState(false); const [open, setOpen] = useState(false);
// Vorschläge aus Betreff/Absender nur vorausfüllen – bestätigen muss immer das Personal (Absender ist nicht nachgewiesen)
const [org, setOrg] = useState(m.suggestedOrgId ?? ''); const [ticketNumber, setTicketNumber] = useState(m.suggestedTicketNumber ?? ''); const [busy, setBusy] = useState(false); const [open, setOpen] = useState(false);
async function assign() {
if (!org) return; setBusy(true);
try { const r = await api<{ number: string }>('POST', `/admin/inbox/${m.id}/assign`, { orgId: org }); onDone(`Ticket ${r.number} angelegt.`); }
@ -29,6 +30,8 @@ function UnmatchedRow({ m, custs, onDone, onError }: { m: Msg; custs: Cust[]; on
return (<div className="card">
<div className="row between"><div><strong>{m.subject || '(kein Betreff)'}</strong><p className="small muted" style={{ margin: '2px 0 0' }}>Von: {m.fromName ? `${m.fromName} <${m.fromEmail}>` : m.fromEmail} · {fmt(m.receivedAt)}</p></div>
<button className="btn small" aria-expanded={open} onClick={() => setOpen(!open)}>{open ? 'Schließen' : 'Text anzeigen'}</button></div>
{(m.suggestedTicketNumber || m.suggestedOrgId) && <p className="small muted" style={{ margin: '8px 0 0' }}>Vorschlag aus Betreff/Absender vorausgefüllt. Der Absender ist nicht nachgewiesen (keine Antwort auf eine Kundencenter-Mail) – bitte prüfen, bevor Sie zuordnen.</p>}
{m.processingError && <p className="small" style={{ margin: '8px 0 0', color: 'var(--err)' }}>Automatische Verarbeitung fehlgeschlagen: {m.processingError}</p>}
{open && <pre className="small" style={{ whiteSpace: 'pre-wrap', background: 'var(--surface-2)', padding: 12, borderRadius: 'var(--radius-sm)', margin: '12px 0', maxHeight: 300, overflow: 'auto' }}>{m.bodyText || '(kein Text)'}</pre>}
<div className="row" style={{ marginTop: 12, gap: 16, flexWrap: 'wrap' }}>
<div className="row" style={{ gap: 8 }}>

View file

@ -150,7 +150,7 @@ async function handleThreadMessage(msg: Message, log: (m: string) => void): Prom
await pool.query("UPDATE tickets SET status = 'pending_customer', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.ticket_id]);
await audit({ actorType: 'user', actorId: staff.id, orgId: t.org_id, action: 'ticket.message', resourceType: 'ticket', resourceId: t.ticket_id, after: { internalNote: false, via: 'discord' } });
const creator = await pool.query('SELECT email, name FROM users WHERE id = ?', [t.created_by]).then(([r]: any) => r[0]);
if (creator) await enqueue('mail.template', { to: creator.email, key: 'ticket_message', vars: { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(t.ticket_id) } }, { idempotencyKey: `mail:discord-staff:${msg.id}` });
if (creator) await enqueue('mail.template', { to: creator.email, key: 'ticket_message', vars: { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(t.ticket_id) }, replyTicketId: t.ticket_id }, { idempotencyKey: `mail:discord-staff:${msg.id}` });
log(`Discord: Support-Antwort zu Ticket ${t.number} übernommen.`);
return;
}

View file

@ -26,8 +26,8 @@ const handlers: Record<string, Handler> = {
const r = await notifyAdmin(text, String(p.event).startsWith('ticket.') ? 'tickets' : 'admin');
if (r === 'skipped') return 'übersprungen: Discord nicht konfiguriert';
},
'mail.template': async (p: { to: string; key: string; vars: Record<string, string> }) => {
const status = await sendTemplateMail(p.to, p.key, p.vars);
'mail.template': async (p: { to: string; key: string; vars: Record<string, string>; replyTicketId?: string }) => {
const status = await sendTemplateMail(p.to, p.key, p.vars, { replyTicketId: p.replyTicketId });
if (status === 'failed') throw new Error('Mailversand fehlgeschlagen (siehe Protokoll unter Einstellungen > E-Mail)');
if (status === 'no_template') throw new Error(`Unbekannte Mailvorlage: ${p.key}`);
return status === 'not_configured' ? 'übersprungen: SMTP nicht konfiguriert' : status === 'disabled' ? 'übersprungen: Vorlage deaktiviert' : 'gesendet';

View file

@ -1,7 +1,9 @@
import { randomUUID } from 'node:crypto';
import { ImapFlow } from 'imapflow';
import { simpleParser } from 'mailparser';
import { pool } from '@kc/platform/db';
import type { PoolConnection } from 'mysql2/promise';
import { one, pool, run, tx } from '@kc/platform/db';
import { ticketFromReplyHeaders } from '@kc/platform/ticketmail';
import { decrypt } from '@kc/platform/crypto';
import { enqueue } from '@kc/platform/jobs';
import { hasFeature } from '@kc/platform/license';
@ -10,19 +12,20 @@ import { hasFeature } from '@kc/platform/license';
function htmlToText(html: string): string {
return html.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, ' ').replace(/<br\s*\/?>/gi, '\n').replace(/<\/p>/gi, '\n\n').replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
}
async function nextTicketNumber(): Promise<string> {
await pool.query("UPDATE number_sequences SET next_value = LAST_INSERT_ID(next_value + 1) WHERE name = 'ticket'");
const [r] = await pool.query('SELECT LAST_INSERT_ID() AS n') as any;
return `T-${r[0].n}`;
}
const notify = (event: string, extra: Record<string, unknown>, key: string) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key });
const notify = (event: string, extra: Record<string, unknown>, key: string, c?: PoolConnection) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key }, c);
/** Nach so vielen erfolglosen Versuchen wird eine Nachricht nur noch als „nicht verarbeitbar“ im Posteingang abgelegt. */
const MAX_ATTEMPTS = 5;
/**
* Ruft das konfigurierte IMAP-Postfach ab und ordnet neue Mails Tickets zu:
* 1. Betreff enthält eine Ticketnummer (T-123) UND Absender gehört zum Kunden dieses Tickets → als Nachricht angehängt.
* 2. Sonst, wenn der Absender ein bekannter aktiver Kunde ist → neues Ticket unter seinem Kundenkonto.
* 3. Sonst → landet unzugeordnet im Posteingang, Personal weist manuell zu (siehe /admin/inbox).
* Beim ersten Aktivieren (last_uid ist NULL) wird kein Bestand verarbeitet, nur ab dann neu Eingehendes.
* Ruft das konfigurierte IMAP-Postfach ab und ordnet neue Mails Tickets zu (#107):
* 1. Antwort mit gültigem, signiertem Bezug auf eine Ticket-Mail (In-Reply-To/References, siehe ticketmail.ts) UND
* Absender ist aktives Mitglied des (aktiven) Kunden dieses Tickets → als Kundenantwort angehängt.
* 2. Alles andere (auch bekannte Absender, Ticketnummer nur im Betreff) → Posteingang zur manuellen Zuordnung, mit
* Vorschlag (Ticket/Kunde). Absenderadresse und Betreff sind fälschbar und gelten nicht als Identitätsnachweis.
* Erstlauf (last_uid NULL) oder geänderte UIDVALIDITY: kein Bestand wird verarbeitet, nur ab dann neu Eingehendes.
* Schlägt eine Nachricht fehl, bleibt last_uid VOR ihr stehen und sie wird beim nächsten Lauf wiederholt
* (höchstens MAX_ATTEMPTS-mal, danach als nicht verarbeitbar im Posteingang abgelegt). Doppelte Verarbeitung
* verhindert der eindeutige Schlüssel (uid_validity, uid).
*/
export async function checkMailbox(log: (m: string) => void): Promise<void> {
const [rows] = await pool.query('SELECT * FROM imap_settings WHERE id = 1') as any;
@ -35,20 +38,37 @@ export async function checkMailbox(log: (m: string) => void): Promise<void> {
await client.connect();
const lock = await client.getMailboxLock(s.folder || 'INBOX');
try {
const mailbox = client.mailbox as { uidNext: number };
if (s.last_uid == null) {
await pool.query('UPDATE imap_settings SET last_uid = ?, last_checked_at = UTC_TIMESTAMP(3), last_error = NULL WHERE id = 1', [Math.max(0, mailbox.uidNext - 1)]);
log('IMAP: Erstlauf, Bestand wird nicht verarbeitet (nur neu Eingehendes ab jetzt).');
const mailbox = client.mailbox as { uidNext: number; uidValidity: bigint | number };
const uidValidity = Number(mailbox.uidValidity);
if (s.last_uid == null || (s.uid_validity != null && Number(s.uid_validity) !== uidValidity)) {
const reason = s.last_uid == null ? 'Erstlauf' : 'UIDVALIDITY des Postfachs hat sich geändert';
await pool.query('UPDATE imap_settings SET last_uid = ?, uid_validity = ?, failed_uid = NULL, failed_attempts = 0, last_checked_at = UTC_TIMESTAMP(3), last_error = NULL WHERE id = 1', [Math.max(0, mailbox.uidNext - 1), uidValidity]);
log(`IMAP: ${reason}, Bestand wird nicht verarbeitet (nur neu Eingehendes ab jetzt).`);
return;
}
let maxUid = s.last_uid;
for await (const msg of client.fetch(`${s.last_uid + 1}:*`, { source: true }, { uid: true })) {
if (msg.uid <= s.last_uid) continue; // Server liefert bei leerem Bereich mitunter die letzte bekannte Nachricht
maxUid = Math.max(maxUid, msg.uid);
try { await processMessage(msg.uid, msg.source as Buffer, log); }
catch (e) { log(`IMAP: Nachricht UID ${msg.uid} konnte nicht verarbeitet werden: ${(e as Error).message}`); }
if (s.uid_validity == null) await pool.query('UPDATE imap_settings SET uid_validity = ? WHERE id = 1', [uidValidity]);
let lastUid = Number(s.last_uid);
let failedUid: number | null = s.failed_uid == null ? null : Number(s.failed_uid);
let attempts = Number(s.failed_attempts ?? 0);
let error: string | null = null;
for await (const msg of client.fetch(`${lastUid + 1}:*`, { source: true }, { uid: true })) {
if (msg.uid <= lastUid) continue; // Server liefert bei leerem Bereich mitunter die letzte bekannte Nachricht
try {
await processMessage(msg.uid, uidValidity, msg.source as Buffer, log);
} catch (e) {
const m = String((e as Error).message).slice(0, 400);
attempts = failedUid === msg.uid ? attempts + 1 : 1; failedUid = msg.uid;
if (attempts < MAX_ATTEMPTS) {
error = `Nachricht UID ${msg.uid} nicht verarbeitet (Versuch ${attempts}/${MAX_ATTEMPTS}): ${m}`;
log(`IMAP: ${error}`);
break; // last_uid bleibt vor dieser Nachricht stehen → nächster Lauf wiederholt sie
}
await storeUnprocessable(msg.uid, uidValidity, msg.source as Buffer, m).catch((e2) => log(`IMAP: Ablage von UID ${msg.uid} fehlgeschlagen: ${(e2 as Error).message}`));
log(`IMAP: Nachricht UID ${msg.uid} nach ${attempts} Versuchen als nicht verarbeitbar im Posteingang abgelegt: ${m}`);
}
lastUid = msg.uid; failedUid = null; attempts = 0;
}
await pool.query('UPDATE imap_settings SET last_uid = ?, last_checked_at = UTC_TIMESTAMP(3), last_error = NULL WHERE id = 1', [maxUid]);
await pool.query('UPDATE imap_settings SET last_uid = ?, failed_uid = ?, failed_attempts = ?, last_checked_at = UTC_TIMESTAMP(3), last_error = ? WHERE id = 1', [lastUid, failedUid, attempts, error]);
} finally { lock.release(); }
await client.logout();
} catch (e) {
@ -60,63 +80,61 @@ export async function checkMailbox(log: (m: string) => void): Promise<void> {
}
const TICKET_NUMBER = /\bT-(\d+)\b/i;
async function processMessage(uid: number, source: Buffer, log: (m: string) => void): Promise<void> {
const isDuplicate = (e: unknown) => (e as { code?: string }).code === 'ER_DUP_ENTRY';
interface Parsed { fromEmail: string; fromName: string | null; subject: string | null; bodyText: string; receivedAt: Date; messageId: string | null; inReplyTo?: string; references?: string | string[] }
async function parse(source: Buffer): Promise<Parsed> {
const parsed = await simpleParser(source);
const fromAddr = parsed.from?.value?.[0];
const fromEmail = (fromAddr?.address ?? '').toLowerCase().slice(0, 254);
if (!fromEmail) { log(`IMAP: Nachricht UID ${uid} ohne lesbare Absenderadresse, übersprungen.`); return; }
const fromName = (fromAddr?.name ?? '').slice(0, 200) || null;
const subject = (parsed.subject ?? '').slice(0, 500) || null;
const bodyText = (parsed.text ?? (parsed.html ? htmlToText(parsed.html as string) : '')).slice(0, 20000);
const receivedAt = parsed.date ?? new Date();
const messageId = (parsed.messageId ?? '').slice(0, 998) || null;
const id = randomUUID();
return {
fromEmail: (fromAddr?.address ?? '').toLowerCase().slice(0, 254), fromName: (fromAddr?.name ?? '').slice(0, 200) || null,
subject: (parsed.subject ?? '').slice(0, 500) || null, bodyText: (parsed.text ?? (parsed.html ? htmlToText(parsed.html as string) : '')).slice(0, 20000),
receivedAt: parsed.date ?? new Date(), messageId: (parsed.messageId ?? '').slice(0, 998) || null, inReplyTo: parsed.inReplyTo, references: parsed.references,
};
}
// 1) Ticketnummer im Betreff + Absender gehört zum Kunden dieses Tickets
const m = subject ? TICKET_NUMBER.exec(subject) : null;
if (m) {
const [tRows] = await pool.query('SELECT * FROM tickets WHERE number = ?', [`T-${m[1]}`]) as any;
const ticket = tRows[0];
if (ticket) {
const [uRows] = await pool.query("SELECT id FROM users WHERE email = ? AND status = 'active'", [fromEmail]) as any;
const user = uRows[0];
if (user) {
const [memRows] = await pool.query('SELECT 1 AS x FROM memberships WHERE user_id = ? AND org_id = ?', [user.id, ticket.org_id]) as any;
if (memRows[0]) {
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticket.id, user.id, 'customer', bodyText || '(kein Text)']);
await pool.query("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [ticket.id]);
await pool.query('INSERT INTO inbox_messages (id, uid, message_id, from_email, from_name, subject, body_text, received_at, status, ticket_id, matched_user_id) VALUES (?,?,?,?,?,?,?,?,?,?,?)',
[id, uid, messageId, fromEmail, fromName, subject, bodyText, receivedAt, 'matched', ticket.id, user.id]);
await notify('ticket.message', { number: ticket.number }, `mail-in:${id}`);
log(`IMAP: Nachricht von ${fromEmail} zu Ticket ${ticket.number} hinzugefügt.`);
/** Verarbeitet eine Nachricht vollständig in EINER Transaktion (Inbox-Zeile, Ticketnachricht, Status, Benachrichtigung). */
export async function processMessage(uid: number, uidValidity: number, source: Buffer, log: (m: string) => void): Promise<void> {
const p = await parse(source);
const id = randomUUID();
const inboxRow = (c: PoolConnection, status: string, extra: { ticketId?: string | null; userId?: string | null; suggestedTicketId?: string | null; suggestedUserId?: string | null } = {}) =>
run('INSERT INTO inbox_messages (id, uid, uid_validity, message_id, from_email, from_name, subject, body_text, received_at, status, ticket_id, matched_user_id, suggested_ticket_id, suggested_user_id) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)',
[id, uid, uidValidity, p.messageId, p.fromEmail || '(unbekannt)', p.fromName, p.subject, p.bodyText, p.receivedAt, status, extra.ticketId ?? null, extra.userId ?? null, extra.suggestedTicketId ?? null, extra.suggestedUserId ?? null], c);
try {
await tx(async (c) => {
// 1) Signierter Antwort-Bezug + Absender ist aktives Mitglied des aktiven Kunden dieses Tickets
const replyTicketId = ticketFromReplyHeaders(p.inReplyTo, p.references);
if (replyTicketId && p.fromEmail) {
const t = await one("SELECT t.id, t.number, t.org_id FROM tickets t JOIN organizations o ON o.id = t.org_id AND o.status = 'active' WHERE t.id = ? FOR UPDATE", [replyTicketId], c);
const u = t && await one("SELECT u.id FROM users u JOIN memberships m ON m.user_id = u.id AND m.org_id = ? WHERE u.email = ? AND u.status = 'active' AND u.kind = 'customer'", [t.org_id, p.fromEmail], c);
if (t && u) {
await inboxRow(c, 'matched', { ticketId: t.id, userId: u.id }); // zuerst: Dublette bricht hier ab, bevor etwas angehängt wird
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.id, u.id, 'customer', p.bodyText || '(kein Text)'], c);
await run("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.id], c);
await notify('ticket.message', { number: t.number }, `mail-in:${id}`, c);
log(`IMAP: Antwort zu Ticket ${t.number} angehängt (signierter Antwort-Bezug).`);
return;
}
}
}
// 2) Kein Nachweis → Posteingang, mit Vorschlag für das Personal
const m = p.subject ? TICKET_NUMBER.exec(p.subject) : null;
const sugTicket = m ? await one('SELECT id FROM tickets WHERE number = ?', [`T-${m[1]}`], c) : undefined;
const sugUser = p.fromEmail ? await one("SELECT id FROM users WHERE email = ? AND status = 'active' AND kind = 'customer'", [p.fromEmail], c) : undefined;
await inboxRow(c, 'unmatched', { suggestedTicketId: replyTicketId ?? sugTicket?.id ?? null, suggestedUserId: sugUser?.id ?? null });
log(`IMAP: Nachricht UID ${uid} liegt zur Zuordnung im Posteingang${sugTicket || sugUser ? ' (mit Vorschlag)' : ''}.`);
});
} catch (e) {
if (isDuplicate(e)) { log(`IMAP: Nachricht UID ${uid} wurde bereits verarbeitet, übersprungen.`); return; }
throw e;
}
// 2) Bekannter aktiver Kunde ohne (verifizierten) Ticketbezug → neues Ticket
const [uRows2] = await pool.query("SELECT id FROM users WHERE email = ? AND status = 'active' AND kind = 'customer'", [fromEmail]) as any;
const user2 = uRows2[0];
if (user2) {
const [memRows2] = await pool.query("SELECT org_id FROM memberships WHERE user_id = ? ORDER BY (role = 'owner') DESC LIMIT 1", [user2.id]) as any;
const org = memRows2[0];
if (org) {
const ticketId = randomUUID();
const number = await nextTicketNumber();
await pool.query('INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?,?,?,?)',
[ticketId, number, org.org_id, subject || '(kein Betreff)', 'pending_staff', 'normal', user2.id]);
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticketId, user2.id, 'customer', bodyText || '(kein Text)']);
await pool.query('INSERT INTO inbox_messages (id, uid, message_id, from_email, from_name, subject, body_text, received_at, status, ticket_id, matched_user_id) VALUES (?,?,?,?,?,?,?,?,?,?,?)',
[id, uid, messageId, fromEmail, fromName, subject, bodyText, receivedAt, 'created', ticketId, user2.id]);
await notify('ticket.created', { number, subject: (subject || '').slice(0, 100) }, `mail-in:${id}`);
log(`IMAP: Neues Ticket ${number} aus Mail von ${fromEmail} angelegt.`);
return;
}
}
// 3) Unbekannter oder nicht zuordenbarer Absender → Posteingang zur manuellen Zuordnung
await pool.query('INSERT INTO inbox_messages (id, uid, message_id, from_email, from_name, subject, body_text, received_at, status) VALUES (?,?,?,?,?,?,?,?,?)',
[id, uid, messageId, fromEmail, fromName, subject, bodyText, receivedAt, 'unmatched']);
log(`IMAP: Nachricht von ${fromEmail} konnte niemandem zugeordnet werden, liegt im Posteingang.`);
}
/** Letzter Ausweg nach MAX_ATTEMPTS Fehlversuchen: Rohdaten so weit wie möglich als unzugeordnete Nachricht ablegen. */
async function storeUnprocessable(uid: number, uidValidity: number, source: Buffer, error: string): Promise<void> {
const head = source.subarray(0, 20000).toString('utf8');
const from = /^From:\s*(.*)$/im.exec(head)?.[1]?.slice(0, 254) ?? '(unbekannt)';
const subject = /^Subject:\s*(.*)$/im.exec(head)?.[1]?.slice(0, 500) ?? null;
try {
await run("INSERT INTO inbox_messages (id, uid, uid_validity, from_email, subject, body_text, received_at, status, processing_error) VALUES (?,?,?,?,?,?,UTC_TIMESTAMP(3),'unmatched',?)",
[randomUUID(), uid, uidValidity, from, subject, '(Nachricht konnte nicht automatisch gelesen werden – bitte im Postfach ansehen)', error]);
} catch (e) { if (!isDuplicate(e)) throw e; }
}

View file

@ -0,0 +1,13 @@
-- IMAP-Posteingang absichern (#107): UIDVALIDITY, Wiederholung fehlgeschlagener Nachrichten, Dubletten-Schutz,
-- und Zuordnungsvorschläge für Mails, deren Absender nicht nachweisbar ist (nur Hinweis, keine automatische Zuordnung).
ALTER TABLE imap_settings
ADD COLUMN uid_validity BIGINT UNSIGNED NULL AFTER last_uid,
ADD COLUMN failed_uid BIGINT UNSIGNED NULL AFTER uid_validity,
ADD COLUMN failed_attempts INT NOT NULL DEFAULT 0 AFTER failed_uid;
ALTER TABLE inbox_messages
ADD COLUMN uid_validity BIGINT UNSIGNED NULL AFTER uid,
ADD COLUMN suggested_ticket_id CHAR(36) NULL REFERENCES tickets(id),
ADD COLUMN suggested_user_id CHAR(36) NULL REFERENCES users(id),
ADD COLUMN processing_error VARCHAR(500) NULL,
ADD UNIQUE KEY uq_inbox_uid (uid_validity, uid);

View file

@ -2,6 +2,7 @@ import nodemailer from 'nodemailer';
import { one, run } from './db.js';
import { decrypt } from './crypto.js';
import { config } from './config.js';
import { ticketReplyMessageId } from './ticketmail.js';
export interface SmtpConfig { host: string; port: number; secureMode: 'none' | 'starttls' | 'tls'; username: string | null; fromName: string | null; fromEmail: string }
export type MailCategory = 'kundencenter' | 'stoerungsticket' | 'rechnungen';
@ -30,7 +31,7 @@ async function transportFor(cfg: SmtpConfig) {
}
/** Versand mit Protokoll. Ohne SMTP-Konfiguration wird nur "not_configured" protokolliert (Inhalt bewusst nicht gespeichert). */
export async function sendMail(to: string, template: string, subject: string, text: string, opts: { category?: MailCategory; html?: string } = {}): Promise<'sent' | 'failed' | 'not_configured'> {
export async function sendMail(to: string, template: string, subject: string, text: string, opts: { category?: MailCategory; html?: string; replyTicketId?: string } = {}): Promise<'sent' | 'failed' | 'not_configured'> {
const cfg = await loadSmtpConfig();
if (!cfg) {
await run('INSERT INTO mail_log (to_email, template, status) VALUES (?,?,?)', [to, template, 'not_configured']);
@ -39,7 +40,9 @@ export async function sendMail(to: string, template: string, subject: string, te
try {
const transport = await transportFor(cfg);
const from = await fromFor(cfg, opts.category);
await transport.sendMail({ from: from.name ? `"${from.name.replace(/"/g, "'")}" <${from.email}>` : from.email, to, subject, text, html: opts.html });
// Ticket-Mails: signierte Message-ID, damit Antworten per In-Reply-To/References sicher zugeordnet werden (#107)
const messageId = opts.replyTicketId ? ticketReplyMessageId(opts.replyTicketId, from.email) : undefined;
await transport.sendMail({ from: from.name ? `"${from.name.replace(/"/g, "'")}" <${from.email}>` : from.email, to, subject, text, html: opts.html, messageId });
await run('INSERT INTO mail_log (to_email, template, status) VALUES (?,?,?)', [to, template, 'sent']);
return 'sent';
} catch (e) {
@ -92,11 +95,11 @@ export function renderTemplateHtml(tpl: string, vars: Record<string, string>): s
}
/** Sendet anhand einer in der Datenbank hinterlegten Vorlage (Einstellungen > E-Mail > Vorlagen). Der Absender richtet sich nach dem Bereich der Vorlage (Kundencenter/Störungsticket/Rechnungen). */
export async function sendTemplateMail(to: string, key: string, vars: Record<string, string>): Promise<'sent' | 'failed' | 'not_configured' | 'disabled' | 'no_template'> {
export async function sendTemplateMail(to: string, key: string, vars: Record<string, string>, opts: { replyTicketId?: string } = {}): Promise<'sent' | 'failed' | 'not_configured' | 'disabled' | 'no_template'> {
const t = await one('SELECT * FROM mail_templates WHERE `key` = ?', [key]);
if (!t) return 'no_template';
if (!t.enabled) return 'disabled';
return sendMail(to, key, renderTemplateText(t.subject, vars), renderTemplateText(t.body, vars), { category: t.category as MailCategory, html: renderTemplateHtml(t.body, vars) });
return sendMail(to, key, renderTemplateText(t.subject, vars), renderTemplateText(t.body, vars), { category: t.category as MailCategory, html: renderTemplateHtml(t.body, vars), replyTicketId: opts.replyTicketId });
}
export const baseUrl = config.baseUrl;

View file

@ -0,0 +1,10 @@
import type { PoolConnection } from 'mysql2/promise';
import { one, run } from './db.js';
/** Nächster Wert eines Nummernkreises (number_sequences). LAST_INSERT_ID() ist an die Sitzung gebunden – deshalb
* UPDATE und SELECT zwingend auf DERSELBEN Verbindung (über den Pool könnten sie auf verschiedenen landen und eine
* fremde oder veraltete Nummer liefern). Am besten in der Transaktion, die die Nummer auch verwendet. */
export async function nextSequence(c: PoolConnection, name: string): Promise<number> {
await run('UPDATE number_sequences SET next_value = LAST_INSERT_ID(next_value + 1) WHERE name = ?', [name], c);
return Number((await one('SELECT LAST_INSERT_ID() AS n', [], c))!.n);
}

View file

@ -0,0 +1,29 @@
import { createHmac, randomBytes } from 'node:crypto';
import { config } from './config.js';
import { safeEqual } from './crypto.js';
/**
* Fälschungssicherer Antwort-Bezug für Ticket-Mails (#107). Ausgehende Ticket-Mails bekommen eine Message-ID mit
* Ticket-ID und HMAC (Schlüssel = KC_SECRET_KEY). Mailprogramme übernehmen sie in In-Reply-To/References der
* Antwort. Nur so belegt eine eingehende Mail, dass der Absender die Ticket-Mail tatsächlich erhalten hat –
* Absenderadresse und Ticketnummer im Betreff sind frei fälschbar und reichen NICHT für eine automatische Zuordnung.
*/
const tag = (ticketId: string): string => createHmac('sha256', config.secretKey).update(`ticket-reply:${ticketId}`).digest('base64url').slice(0, 22);
export function ticketReplyMessageId(ticketId: string, fromEmail: string): string {
const domain = (fromEmail.split('@')[1] || 'kundencenter.invalid').replace(/[^A-Za-z0-9.-]/g, '');
return `<kc.t.${ticketId}.${tag(ticketId)}.${randomBytes(6).toString('hex')}@${domain}>`;
}
const REF = /kc\.t\.([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.([A-Za-z0-9_-]{22})\./gi;
/** Ticket-ID aus In-Reply-To/References, wenn der HMAC stimmt; sonst null. */
export function ticketFromReplyHeaders(...values: (string | string[] | undefined | null)[]): string | null {
for (const v of values.flat()) {
if (!v) continue;
for (const m of v.matchAll(REF)) {
const id = m[1]!.toLowerCase();
if (safeEqual(tag(id), m[2]!)) return id;
}
}
return null;
}