Repository Public
1// Adresses de première classe : modèle, synchronisation idempotente avec Stalwart, et application RÉELLE des états2// (alias désactivé, permissions du compte, liste de diffusion, quota, bloc de politique Sieve, identités d'envoi).3import { config } from "./config.js"4import { sql } from "./db.js"5import { blobText, jmapOk, mailboxById, roleFolder, uploadBlob, folders, type Mbx } from "./mailjmap.js"6import { applyPolicy, emptySieveConfig, generateSieve, parseSieveConfig, SIEVE_SCRIPT_NAME, type MailboxPolicy, type SieveConfig } from "./sieve.js"7import { createList, destroyList, domainIdOf, domainNameById, getAccount, getList, hostedDomains, updateAccount, updateList, type StalwartAlias } from "./stalwart.js"8import { bad } from "./util.js"910export const ADDRESS_KINDS = ["mailbox", "alias", "shared", "notification", "send_only", "receive_only", "temporary"] as const11export type AddressKind = (typeof ADDRESS_KINDS)[number]12export const PHYSICAL_KINDS: readonly AddressKind[] = ["mailbox", "shared"]13export const isPhysical = (kind: string) => kind === "mailbox" || kind === "shared"1415export type AddressRow = {16 id: string; address: string; kind: AddressKind; mailbox_id: string; display_name: string; signature_text: string; signature_html: string17 avatar: string | null; can_send: boolean; can_receive: boolean; status: "active" | "suspended"; suspended_reason: string | null18 expires_at: Date | null; retention_days: number | null; retention_trash_days: number | null; retention_junk_days: number | null19 quota_bytes: number | null; reply_policy: "reject" | "accept" | "discard"; protected: boolean; extra_destinations: string[]20 stalwart_list_id: string | null; created_at: Date; updated_at: Date21}2223export const isExpired = (a: Pick<AddressRow, "expires_at">) => !!a.expires_at && new Date(a.expires_at).getTime() <= Date.now()24export const isActive = (a: AddressRow) => a.status === "active" && !isExpired(a)25export const canSendNow = (a: AddressRow) => isActive(a) && a.can_send && a.kind !== "receive_only"26/** Sort d'un message entrant pour cette adresse : accepté, refusé en SMTP (550), ou accepté puis jeté. */27export function disposition(a: AddressRow): "accept" | "reject" | "discard" {28 if (!isActive(a)) return "reject"29 if (a.can_receive && a.kind !== "send_only") return "accept"30 return a.reply_policy31}3233export async function addressById(id: string): Promise<AddressRow | null> {34 const [r] = await sql`select * from addresses where id = ${id}`35 return (r as AddressRow | undefined) ?? null36}37export async function addressByEmail(address: string): Promise<AddressRow | null> {38 const [r] = await sql`select * from addresses where address = ${address.toLowerCase()}`39 return (r as AddressRow | undefined) ?? null40}41export async function addressesOfMailbox(mailboxId: string): Promise<AddressRow[]> {42 return (await sql`select * from addresses where mailbox_id = ${mailboxId} order by created_at, address`) as unknown as AddressRow[]43}4445export function presentAddress(a: AddressRow, mailboxAddress?: string) {46 return {47 id: a.id, address: a.address, kind: a.kind, mailbox: mailboxAddress ?? null, mailbox_id: a.mailbox_id, display_name: a.display_name,48 signature_text: a.signature_text, signature_html: a.signature_html, avatar: a.avatar, can_send: a.can_send, can_receive: a.can_receive,49 status: a.status, suspended_reason: a.suspended_reason, expired: isExpired(a), expires_at: a.expires_at ? new Date(a.expires_at).toISOString() : null,50 retention_days: a.retention_days, retention_trash_days: a.retention_trash_days, retention_junk_days: a.retention_junk_days,51 quota_bytes: a.quota_bytes === null ? null : Number(a.quota_bytes), reply_policy: a.reply_policy, protected: a.protected,52 extra_destinations: a.extra_destinations, inbound: disposition(a),53 created_at: new Date(a.created_at).toISOString(), updated_at: new Date(a.updated_at).toISOString(),54 }55}5657// ------------------------------------------------------------------ synchronisation (lecture seule côté Stalwart)58/**59 * Idempotent : une adresse « mailbox » par ligne de `mailboxes`, une adresse « alias » par alias Stalwart de ces comptes.60 * N'écrit JAMAIS dans Stalwart et ne supprime jamais rien ; une ligne existante n'est pas modifiée (sauf `protected`, qui ne peut que passer à vrai).61 */62export async function syncAddresses(onlyMailboxId?: string): Promise<{ mailboxes: number; created: string[]; protected: string[] }> {63 const boxes = onlyMailboxId64 ? await sql`select id, address, display_name, stalwart_id from mailboxes where id = ${onlyMailboxId}`65 : await sql`select id, address, display_name, stalwart_id from mailboxes order by position, created_at`66 const created: string[] = []67 const prot: string[] = []68 const insert = async (address: string, kind: AddressKind, mailboxId: string, displayName: string, enabled: boolean) => {69 const isProt = config.protectedAddresses.includes(address)70 const r = await sql`insert into addresses (address, kind, mailbox_id, display_name, status, suspended_reason, protected, reply_policy)71 values (${address}, ${kind}, ${mailboxId}, ${displayName}, ${enabled ? "active" : "suspended"}, ${enabled ? null : "disabled on the mail server"}, ${isProt}, 'reject')72 on conflict (address) do nothing returning id`73 if (r.length) created.push(address)74 if (isProt) {75 const u = await sql`update addresses set protected = true where address = ${address} and not protected returning id`76 if (u.length || r.length) prot.push(address)77 }78 }79 for (const b of boxes) {80 await insert(b.address, "mailbox", b.id, b.display_name, true)81 const acct = await getAccount(b.stalwart_id)82 if (!acct) continue83 for (const al of Object.values(acct.aliases ?? {})) {84 const domain = await domainNameById(al.domainId)85 if (!domain) continue86 await insert(`${al.name}@${domain}`.toLowerCase(), "alias", b.id, "", al.enable !== false)87 }88 }89 // Boîte nouvellement rattachée : l'état de départ du veilleur de réception est pris tout de suite, pour qu'aucun90 // message arrivé dans les premières secondes n'échappe à message.received.91 if (onlyMailboxId) await initMailboxSync(onlyMailboxId).catch(() => {})92 return { mailboxes: boxes.length, created, protected: prot }93}9495/** Fixe l'état JMAP à partir duquel le veilleur suivra cette boîte (sans effet s'il est déjà connu). */96export async function initMailboxSync(mailboxId: string): Promise<void> {97 const mb = await mailboxById(mailboxId)98 if (!mb) return99 const [r] = await jmapOk(mb, [["Email/get", { ids: [] }]])100 await sql`insert into mailbox_sync (mailbox_id, email_state) values (${mailboxId}, ${r.state as string})101 on conflict (mailbox_id) do update set email_state = coalesce(mailbox_sync.email_state, excluded.email_state)`102}103104// ------------------------------------------------------------------ application dans Stalwart105const OUR_PERMS = ["emailReceive", "jmapEmailSubmissionCreate"] as const106107/**108 * Met le compte Stalwart d'une boîte en accord avec ses adresses. Ne touche qu'à ce que SP Mail gère :109 * les alias connus de la table (les alias inconnus sont laissés tels quels), deux permissions, le quota disque, les listes créées par SP Mail.110 * `removed` : adresses supprimées dont l'alias ou la liste doit disparaître.111 */112export async function reconcileMailbox(mailboxId: string, removed: AddressRow[] = []): Promise<void> {113 const mb = await mailboxById(mailboxId)114 if (!mb) return115 const addrs = await addressesOfMailbox(mailboxId)116 const acct = await getAccount(mb.stalwart_id)117 if (!acct) throw bad("mail_server_error", 502, "mail account not found on the mail server")118 const primary = addrs.find((a) => a.address === mb.address)119 const aliases: StalwartAlias[] = Object.values(acct.aliases ?? {}).map((a) => ({ ...a }))120 const before = JSON.stringify(aliases)121 const find = async (address: string) => {122 const [local, domain] = address.split("@")123 const domainId = await domainIdOf(address)124 return { local, domain, domainId, idx: aliases.findIndex((x) => x.name.toLowerCase() === local && x.domainId === domainId) }125 }126 const wantsList = (a: AddressRow) => a.extra_destinations.length > 0 && disposition(a) === "accept"127128 // 1. listes à retirer d'abord (une adresse ne peut pas être à la fois liste et alias)129 for (const a of [...removed, ...addrs.filter((x) => x.address !== mb.address && !wantsList(x))]) {130 if (!a.stalwart_list_id) continue131 await destroyList(a.stalwart_list_id)132 await sql`update addresses set stalwart_list_id = null where id = ${a.id}`133 a.stalwart_list_id = null134 }135 // 2. alias du compte136 for (const a of removed) {137 const f = await find(a.address)138 if (f.idx >= 0) aliases.splice(f.idx, 1)139 }140 for (const a of addrs) {141 if (a.address === mb.address) continue142 const f = await find(a.address)143 if (wantsList(a)) {144 if (f.idx >= 0) aliases.splice(f.idx, 1)145 continue146 }147 const enable = disposition(a) !== "reject"148 if (f.idx < 0) aliases.push({ name: f.local, domainId: f.domainId, enable })149 else if ((aliases[f.idx].enable !== false) !== enable) aliases[f.idx].enable = enable150 }151 const patch: Record<string, unknown> = {}152 if (JSON.stringify(aliases) !== before) patch.aliases = Object.fromEntries(aliases.map((a, i) => [String(i), a]))153154 // 3. permissions (réception / soumission) et quota de la boîte physique155 if (primary) {156 const disabled = { ...(acct.permissions?.disabledPermissions ?? {}) }157 const enabledP = { ...(acct.permissions?.enabledPermissions ?? {}) }158 const want: Record<string, boolean> = { emailReceive: disposition(primary) === "reject", jmapEmailSubmissionCreate: !isActive(primary) }159 let changed = false160 for (const p of OUR_PERMS) {161 if (want[p] && !disabled[p]) { disabled[p] = true; changed = true }162 if (!want[p] && disabled[p]) { delete disabled[p]; changed = true }163 }164 if (changed) {165 const type = acct.permissions?.["@type"] ?? "Inherit"166 if (!Object.keys(disabled).length && !Object.keys(enabledP).length && type !== "Replace") patch.permissions = { "@type": "Inherit" }167 else patch.permissions = { "@type": type === "Replace" ? "Replace" : "Merge", enabledPermissions: enabledP, disabledPermissions: disabled }168 }169 const quota = primary.quota_bytes === null ? undefined : Number(primary.quota_bytes)170 if ((acct.quotas?.maxDiskQuota ?? undefined) !== quota) {171 const q = { ...(acct.quotas ?? {}) }172 if (quota === undefined) delete q.maxDiskQuota173 else q.maxDiskQuota = quota174 patch.quotas = q175 }176 }177 if (Object.keys(patch).length) await updateAccount(mb.stalwart_id, patch)178179 // 4. listes de diffusion (alias à plusieurs destinations)180 for (const a of addrs) {181 if (a.address === mb.address || !wantsList(a)) continue182 const recipients = [...new Set([mb.address, ...a.extra_destinations])]183 const existing = a.stalwart_list_id ? await getList(a.stalwart_list_id) : null184 if (!existing) {185 const id = await createList(a.address, recipients)186 await sql`update addresses set stalwart_list_id = ${id} where id = ${a.id}`187 } else if (JSON.stringify(Object.keys(existing.recipients ?? {}).sort()) !== JSON.stringify([...recipients].sort())) await updateList(existing.id, recipients)188 }189 // 5. bloc de politique Sieve (adresses « discard », réexpédition)190 await reconcileSieve(mb, addrs)191}192193async function mailboxPolicy(mb: Mbx, addrs?: AddressRow[]): Promise<MailboxPolicy> {194 const list = addrs ?? (await addressesOfMailbox(mb.id))195 const [auto] = await sql`select forward_to, forward_keep_copy from mailbox_automation where mailbox_id = ${mb.id}`196 return { discard: list.filter((a) => disposition(a) === "discard").map((a) => a.address), forwardTo: auto?.forward_to ?? null, forwardKeepCopy: auto?.forward_keep_copy ?? true }197}198199type ScriptInfo = { id: string; blobId: string; isActive: boolean } | null200async function readScript(mb: Mbx): Promise<{ info: ScriptInfo; text: string }> {201 const [r] = await jmapOk(mb, [["SieveScript/get", { ids: null }]])202 const s = (r.list as { id: string; name: string; blobId: string; isActive: boolean }[]).find((x) => x.name === SIEVE_SCRIPT_NAME)203 if (!s) return { info: null, text: "" }204 return { info: s, text: await blobText(mb, s.blobId) }205}206async function writeScript(mb: Mbx, info: ScriptInfo, text: string) {207 const blob = await uploadBlob(mb, text, "application/sieve")208 const [r] = info209 ? await jmapOk(mb, [["SieveScript/set", { update: { [info.id]: { blobId: blob.blobId } }, onSuccessActivateScript: info.id }]])210 : await jmapOk(mb, [["SieveScript/set", { create: { s: { name: SIEVE_SCRIPT_NAME, blobId: blob.blobId } }, onSuccessActivateScript: "#s" }]])211 const err = r.notCreated?.s ?? (info ? r.notUpdated?.[info.id] : undefined)212 if (err) throw bad(err.type === "invalidScript" ? "invalid_sieve" : "mail_server_error", err.type === "invalidScript" ? 400 : 502, String(err.description ?? err.type))213}214215/** Réinjecte le bloc de politique du serveur dans le script « spmail » s'il manque ou diffère (appelé après toute sauvegarde de script). */216export async function reconcileSieve(mb: Mbx, addrs?: AddressRow[]): Promise<boolean> {217 const policy = await mailboxPolicy(mb, addrs)218 const { info, text } = await readScript(mb)219 const hasPolicy = policy.discard.length > 0 || !!policy.forwardTo220 if (!info && !hasPolicy) return false221 const base = info ? text : generateSieve(emptySieveConfig())222 const next = applyPolicy(base, policy)223 if (info && next === text && (info.isActive || !hasPolicy)) return false224 await writeScript(mb, info, next)225 return true226}227/** Vrai si la boîte porte une politique que le serveur doit maintenir dans le script (évite toute écriture inutile). */228export async function hasServerPolicy(mailboxId: string): Promise<boolean> {229 const [r] = await sql`select (exists(select 1 from mailbox_automation where mailbox_id = ${mailboxId} and forward_to is not null)230 or exists(select 1 from addresses where mailbox_id = ${mailboxId} and reply_policy = 'discard')) as yes`231 return !!r?.yes232}233234// ------------------------------------------------------------------ automatisation (règles, réponse automatique, réexpédition)235export type Automation = { managed: boolean; active: boolean; rules: SieveConfig["rules"]; vacation: SieveConfig["vacation"]; forward: { to: string; keep_copy: boolean } | null; raw_sieve?: string }236237export async function getAutomation(mb: Mbx, withRaw: boolean): Promise<Automation> {238 const { info, text } = await readScript(mb)239 const cfg = info ? parseSieveConfig(text) : emptySieveConfig()240 const [auto] = await sql`select forward_to, forward_keep_copy from mailbox_automation where mailbox_id = ${mb.id}`241 return {242 managed: !info || !!cfg, active: !!info?.isActive, rules: (cfg ?? emptySieveConfig()).rules, vacation: (cfg ?? emptySieveConfig()).vacation,243 forward: auto?.forward_to ? { to: auto.forward_to, keep_copy: auto.forward_keep_copy } : null, ...(withRaw ? { raw_sieve: text } : {}),244 }245}246247export async function putAutomation(mb: Mbx, input: { rules?: SieveConfig["rules"]; vacation?: SieveConfig["vacation"]; forward?: { to: string; keep_copy: boolean } | null; raw_sieve?: string }) {248 // Un script Sieve écrit à la main n'est jamais écrasé par une mise à jour partielle (règles, réponse automatique OU transfert).249 if (input.raw_sieve === undefined) {250 const existing = await readScript(mb)251 if (existing.info && !parseSieveConfig(existing.text)) throw bad("custom_script", 409, "This mailbox runs a hand-written Sieve script; replace it with raw_sieve (admin) first")252 }253 if (input.forward !== undefined) {254 if (input.forward) {255 const to = input.forward.to.toLowerCase()256 const domain = to.split("@")[1]257 if (!(await hostedDomains()).some((d) => d.name === domain)) throw bad("forward_not_local", 400, "Forwarding is limited to addresses on hosted domains")258 if (to === mb.address) throw bad("forward_loop", 400, "A mailbox cannot forward to itself")259 await sql`insert into mailbox_automation (mailbox_id, forward_to, forward_keep_copy) values (${mb.id}, ${to}, ${input.forward.keep_copy})260 on conflict (mailbox_id) do update set forward_to = excluded.forward_to, forward_keep_copy = excluded.forward_keep_copy, updated_at = now()`261 } else await sql`update mailbox_automation set forward_to = null, updated_at = now() where mailbox_id = ${mb.id}`262 }263 const { info, text } = await readScript(mb)264 let base: string265 if (input.raw_sieve !== undefined) base = input.raw_sieve266 else {267 const current = (info ? parseSieveConfig(text) : null) ?? emptySieveConfig()268 if (info && !parseSieveConfig(text) && (input.rules || input.vacation)) throw bad("custom_script", 409, "This mailbox runs a hand-written Sieve script; replace it with raw_sieve (admin) first")269 const cfg: SieveConfig = { rules: input.rules ?? current.rules, vacation: input.vacation ?? current.vacation }270 const trashId = await roleFolder(mb, "trash")271 const trashName = (await folders(mb)).find((f) => f.id === trashId)?.name ?? "Deleted Items"272 base = generateSieve(cfg, trashName)273 }274 await writeScript(mb, info, applyPolicy(base, await mailboxPolicy(mb)))275}276277// ------------------------------------------------------------------ identités d'envoi278/**279 * Identité JMAP à utiliser pour envoyer depuis cette adresse : celle de l'adresse quand Stalwart la reconnaît (boîte ou alias actif),280 * sinon celle de la boîte (adresse désactivée en réception, liste de diffusion). Une identité absente est créée avec le nom et les281 * signatures de la table. Une identité EXISTANTE (souvent réglée depuis le webmail) n'est jamais réécrite à l'envoi : elle n'est282 * alignée sur la table (`sync`) que lorsque le nom ou les signatures de l'adresse sont modifiés explicitement par l'API.283 */284export async function ensureIdentity(mb: Mbx, a: AddressRow, sync = false): Promise<string> {285 const [r] = await jmapOk(mb, [["Identity/get", { ids: null }]])286 const list = r.list as { id: string; email: string; name: string; textSignature: string; htmlSignature: string }[]287 const name = a.display_name || mb.display_name || ""288 const mine = list.find((i) => i.email.toLowerCase() === a.address)289 if (mine) {290 if (sync && (mine.name !== name || (mine.textSignature ?? "") !== a.signature_text || (mine.htmlSignature ?? "") !== a.signature_html))291 await jmapOk(mb, [["Identity/set", { update: { [mine.id]: { name, textSignature: a.signature_text, htmlSignature: a.signature_html } } }]])292 return mine.id293 }294 const [c] = await jmapOk(mb, [["Identity/set", { create: { n: { name, email: a.address, textSignature: a.signature_text, htmlSignature: a.signature_html } } }]])295 if (c.created?.n?.id) return c.created.n.id as string296 const primary = list.find((i) => i.email.toLowerCase() === mb.address)297 if (primary) return primary.id298 const [p] = await jmapOk(mb, [["Identity/set", { create: { n: { name: mb.display_name || "", email: mb.address } } }]])299 if (!p.created?.n?.id) throw bad("mail_server_error", 502, "no sending identity available")300 return p.created.n.id as string301}302303/** Garde commune : une adresse protégée n'est jamais supprimée, suspendue, expirée ni changée de nature. */304export function assertNotProtected(a: AddressRow, what = "This address") {305 if (a.protected) throw bad("protected_address", 403, `${what} is protected and cannot be deleted or destructively modified`)306}307