@novacraft-engineering/mailbox 0.1.0

package/scripts/offload-bodies.mjs

@@ -0,0 +1,152 @@
+/**
+ * Moves message bodies out of the database and into the bucket, leaving the key
+ * behind in the message headers. The reader already falls back to the bucket when a
+ * row has no html of its own, so nothing needs to change for this to take effect.
+ *
+ * Bytes are written first and the column is cleared only once the bucket has them,
+ * so an interrupted run loses nothing. Resumable — a row is picked up only while it
+ * still holds html.
+ *
+ *   node --experimental-strip-types scripts/offload-bodies.mjs [--batch 40]
+ */
+
+import { createClient } from '@libsql/client'
+import { readFileSync } from 'node:fs'
+import { presign } from '../lib/r2.ts'
+
+for (const line of readFileSync(new URL('../.env.local', import.meta.url), 'utf8').split('\n')) {
+  const match = line.match(/^([A-Z0-9_]+)=(.*)$/)
+  if (match && !process.env[match[1]]) process.env[match[1]] = match[2].replace(/^"|"$/g, '')
+}
+
+const args = process.argv.slice(2)
+const at = args.indexOf('--batch')
+const BATCH = at === -1 ? 40 : Number(args[at + 1])
+
+const db = createClient({
+  url: process.env.TURSO_DATABASE_URL,
+  authToken: process.env.TURSO_AUTH_TOKEN,
+})
+
+/** Ids are ours, but these go into string-interpolated SQL: anything unexpected is left alone. */
+const safeId = value => /^[A-Za-z0-9._:+@-]{1,200}$/.test(value)
+
+const readable = bytes => {
+  const units = ['B', 'KB', 'MB', 'GB']
+  let value = bytes
+  let unit = 0
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024
+    unit += 1
+  }
+  return `${value.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`
+}
+
+async function retry(work) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await work()
+    } catch (err) {
+      if (attempt >= 5) throw err
+      await new Promise(resolve => setTimeout(resolve, 3000 * attempt))
+    }
+  }
+}
+
+const remaining = Number(
+  Object.values(
+    (await retry(() => db.execute("SELECT COUNT(*) FROM mail_inbox WHERE html IS NOT NULL AND html != ''"))).rows[0],
+  )[0],
+)
+console.log(`${new Date().toISOString()}  ${remaining.toLocaleString()} bodies to move, ${BATCH} at a time`)
+
+const started = Date.now()
+let moved = 0
+let deduped = 0
+let failed = 0
+let bytes = 0
+
+for (let round = 1; round <= 10000; round += 1) {
+  const rows = (
+    await retry(() =>
+      db.execute(`SELECT id, html, headers FROM mail_inbox WHERE html IS NOT NULL AND html != '' LIMIT ${BATCH}`),
+    )
+  ).rows
+
+  if (rows.length === 0) break
+
+  const statements = []
+  await Promise.all(
+    rows.map(async row => {
+      const id = String(row.id)
+      const html = String(row.html ?? '')
+      if (!safeId(id)) return
+
+      let headers = {}
+      try {
+        headers = JSON.parse(String(row.headers ?? '{}')) ?? {}
+      } catch {
+        headers = {}
+      }
+
+      // A shared copy points at the original, which already holds the body.
+      if (typeof headers['shared-copy-of'] === 'string' && headers['shared-copy-of']) {
+        statements.push(`UPDATE mail_inbox SET html = NULL WHERE id = '${id}'`)
+        deduped += 1
+        bytes += html.length
+        return
+      }
+
+      const key = `bodies/${id}.html`
+      try {
+        const response = await fetch(presign(key, 'PUT', 300), {
+          method: 'PUT',
+          headers: { 'content-type': 'text/html; charset=utf-8' },
+          body: html,
+        })
+        if (!response.ok) {
+          failed += 1
+          return
+        }
+      } catch {
+        failed += 1
+        return
+      }
+
+      statements.push(
+        `UPDATE mail_inbox SET html = NULL, headers = json_set(COALESCE(headers, '{}'), '$."html-key"', '${key}') WHERE id = '${id}'`,
+      )
+      moved += 1
+      bytes += html.length
+    }),
+  )
+
+  if (statements.length) await retry(() => db.batch(statements, 'write'))
+
+  // Every row failed to upload: the bucket is unreachable, and looping would spin forever.
+  if (statements.length === 0) {
+    console.log(`\n${new Date().toISOString()}  stopping: nothing in this batch could be written to the bucket`)
+    break
+  }
+
+  if (round % 10 === 0) {
+    const elapsed = (Date.now() - started) / 1000
+    const rate = (moved + deduped) / Math.max(elapsed, 1)
+    const left = Math.max(remaining - moved - deduped, 0)
+    const eta = rate > 0 ? Math.round(left / rate) : 0
+    console.log(
+      `${new Date().toISOString()}  ${(moved + deduped).toLocaleString()}/${remaining.toLocaleString()} · ` +
+        `${readable(bytes)} freed · ${rate.toFixed(1)}/s · ~${Math.floor(eta / 60)}m left`,
+    )
+  }
+}
+
+const total = Math.round((Date.now() - started) / 1000)
+const left = Number(
+  Object.values(
+    (await retry(() => db.execute("SELECT COUNT(*) FROM mail_inbox WHERE html IS NOT NULL AND html != ''"))).rows[0],
+  )[0],
+)
+console.log(`\n${new Date().toISOString()}  finished in ${Math.floor(total / 60)}m ${total % 60}s`)
+console.log(`  moved ${moved.toLocaleString()}, deduped ${deduped.toLocaleString()}, failed ${failed.toLocaleString()}`)
+console.log(`  ${readable(bytes)} taken out of the database, ${left.toLocaleString()} bodies still inline`)

package/scripts/sample-files.mjs

@@ -0,0 +1,119 @@
+/**
+ * Real files for the seeded mailbox: a message that says it carries a photo should carry
+ * a photo you can open. Everything here is generated, so the repository ships no media.
+ *
+ * ffmpeg draws the picture and the video when it is installed; the PDF, the spreadsheet
+ * and the document are written by hand, and the rest is skipped rather than faked.
+ */
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+function has(command) {
+  try {
+    execFileSync('which', [command], { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** A one-page PDF, with the byte offsets its cross-reference table has to name. */
+function pdf(title, line) {
+  const objects = [
+    '<</Type/Catalog/Pages 2 0 R>>',
+    '<</Type/Pages/Kids[3 0 R]/Count 1>>',
+    '<</Type/Page/Parent 2 0 R/MediaBox[0 0 595 842]/Resources<</Font<</F1 5 0 R>>>>/Contents 4 0 R>>',
+    null,
+    '<</Type/Font/Subtype/Type1/BaseFont/Helvetica>>',
+  ]
+  const stream = `BT /F1 20 Tf 64 760 Td (${title}) Tj ET\nBT /F1 12 Tf 64 730 Td (${line}) Tj ET`
+  objects[3] = `<</Length ${stream.length}>>\nstream\n${stream}\nendstream`
+
+  let body = '%PDF-1.4\n'
+  const offsets = []
+  objects.forEach((object, index) => {
+    offsets.push(body.length)
+    body += `${index + 1} 0 obj\n${object}\nendobj\n`
+  })
+  const startxref = body.length
+  body += `xref\n0 ${objects.length + 1}\n0000000000 65535 f \n`
+  for (const offset of offsets) body += `${String(offset).padStart(10, '0')} 00000 n \n`
+  body += `trailer\n<</Size ${objects.length + 1}/Root 1 0 R>>\nstartxref\n${startxref}\n%%EOF\n`
+  return Buffer.from(body, 'latin1')
+}
+
+/** A .docx is a zip of three small XML parts; the zip tool does the rest. */
+function docx(text, directory) {
+  if (!has('zip')) return null
+  const root = join(directory, 'docx')
+  mkdirSync(join(root, '_rels'), { recursive: true })
+  mkdirSync(join(root, 'word'), { recursive: true })
+  writeFileSync(
+    join(root, '[Content_Types].xml'),
+    '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/></Types>',
+  )
+  writeFileSync(
+    join(root, '_rels/.rels'),
+    '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>',
+  )
+  writeFileSync(
+    join(root, 'word/document.xml'),
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p><w:r><w:t>${text}</w:t></w:r></w:p></w:body></w:document>`,
+  )
+  const out = join(directory, 'endorsement.docx')
+  execFileSync('zip', ['-q', '-r', '-X', out, '[Content_Types].xml', '_rels', 'word'], { cwd: root })
+  return readFileSync(out)
+}
+
+function ffmpeg(directory, name, args) {
+  if (!has('ffmpeg')) return null
+  const out = join(directory, name)
+  try {
+    execFileSync('ffmpeg', ['-y', '-loglevel', 'error', ...args, out], { stdio: 'ignore' })
+    return readFileSync(out)
+  } catch {
+    return null
+  }
+}
+
+export function buildSamples() {
+  const directory = mkdtempSync(join(tmpdir(), 'mailbox-samples-'))
+  try {
+    const files = [
+      { filename: 'schedule.pdf', contentType: 'application/pdf', bytes: pdf('Premium schedule', 'Cover from 1 January, renewable annually.') },
+      { filename: 'certificate.pdf', contentType: 'application/pdf', bytes: pdf('Certificate of insurance', 'Issued to the named insured for the period shown.') },
+      { filename: 'claim-form.pdf', contentType: 'application/pdf', bytes: pdf('Claim form', 'Complete every section and return it signed.') },
+      {
+        filename: 'vehicle-list.csv',
+        contentType: 'text/csv',
+        bytes: Buffer.from(
+          'registration,make,model,year,value\nLAG-114-KJA,Toyota,Hilux,2021,18500000\nABJ-882-XA,Ford,Ranger,2019,14200000\nLAG-props-77,Mercedes,Sprinter,2022,31000000\n',
+          'utf8',
+        ),
+      },
+      {
+        filename: 'site-photo.jpg',
+        contentType: 'image/jpeg',
+        bytes: ffmpeg(directory, 'site-photo.jpg', ['-f', 'lavfi', '-i', 'testsrc=size=1280x720:duration=1', '-frames:v', '1']),
+      },
+      {
+        filename: 'warehouse.png',
+        contentType: 'image/png',
+        bytes: ffmpeg(directory, 'warehouse.png', ['-f', 'lavfi', '-i', 'smptebars=size=900x600:duration=1', '-frames:v', '1']),
+      },
+      {
+        filename: 'survey-clip.mp4',
+        contentType: 'video/mp4',
+        bytes: ffmpeg(directory, 'survey-clip.mp4', [
+          '-f', 'lavfi', '-i', 'testsrc=size=480x270:rate=15', '-t', '3', '-pix_fmt', 'yuv420p', '-c:v', 'libx264',
+        ]),
+      },
+      { filename: 'endorsement.docx', contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', bytes: docx('Endorsement: the schedule is amended as set out above.', directory) },
+    ]
+    return files.filter(file => file.bytes && file.bytes.length)
+  } finally {
+    rmSync(directory, { recursive: true, force: true })
+  }
+}

package/scripts/seed-dev.mjs

@@ -0,0 +1,240 @@
+/**
+ * Fills the dev mailbox with enough traffic to exercise the list, search, paging
+ * and the large-file path. Idempotent: every row it writes is prefixed `dev-`,
+ * so re-running replaces rather than accumulates.
+ *
+ *   node scripts/seed-dev.mjs
+ */
+
+import { createClient } from '@libsql/client'
+import { randomBytes, scrypt } from 'node:crypto'
+import { promisify } from 'node:util'
+import { readFileSync } from 'node:fs'
+
+const scryptAsync = promisify(scrypt)
+
+// Read .env.local the same way Next does, so this needs no extra wiring.
+for (const line of readFileSync(new URL('../.env.local', import.meta.url), 'utf8').split('\n')) {
+  const match = line.match(/^([A-Z0-9_]+)=(.*)$/)
+  if (match && !process.env[match[1]]) process.env[match[1]] = match[2].replace(/^"|"$/g, '')
+}
+
+const db = createClient({
+  url: process.env.TURSO_DATABASE_URL,
+  authToken: process.env.TURSO_AUTH_TOKEN,
+})
+
+const DEV_ADDRESS = 'test@example.com'
+/** Written into the body of every message whose link is locked, the way a sender would. */
+const SHARE_PASSWORD = 'open-sesame'
+const TOTAL = 500
+const WITH_ATTACHMENTS = 10
+const WITH_HEAVY = 10
+
+const SUBJECTS = [
+  'Marine cargo cover for a Shenzhen shipment', 'Motor fleet renewal, twelve vehicles',
+  'Group life for forty staff', 'Builders liability on the Ikoyi site',
+  'Goods in transit, weekly runs to Aba', 'Professional indemnity renewal',
+  'Fire and perils survey report', 'Fidelity guarantee bond wording',
+  'Travel policy for the directors', 'Container insurance question',
+  'Claim notification, warehouse flood', 'Certificate needed for Form M',
+  'Premium schedule for review', 'Query on the excess clause',
+  'Renewal terms, please confirm', 'Adding a driver to the fleet policy',
+  'Endorsement request', 'Cover note for tomorrow',
+  'Broker appointment letter', 'Annual review meeting',
+]
+
+const COMPANIES = [
+  'Lagos Freight', 'Zenith Logistics', 'Tabernacle Group', 'BuildRight', 'Harbour Traders',
+  'Ikeja Motors', 'Delta Shipping', 'Crown Estates', 'Nova Foods', 'Apex Manufacturing',
+  'Sable Energy', 'Riverside Farms', 'Onyx Retail', 'Pioneer Textiles', 'Summit Health',
+]
+
+const BODIES = [
+  'Please find the details below. Let me know if you need anything further before we proceed.',
+  'Following up on our call this morning. The figures we discussed are attached for your records.',
+  'We would like to confirm the terms before the renewal date. Could you send the schedule?',
+  'There has been a change to the risk since the last renewal. Details follow.',
+  'Our bank is asking for the certificate before they will release the shipment.',
+  'Could you clarify what the excess would be on a claim of this size?',
+  'We are adding two vehicles to the fleet from the first of next month.',
+  'The survey has been completed. The report raises two points we should discuss.',
+]
+
+const pick = (list, index) => list[index % list.length]
+
+/** A deterministic sequence, so a re-run produces the same mailbox. */
+function seededRandom(seed) {
+  let value = seed
+  return () => {
+    value = (value * 1664525 + 1013904223) % 4294967296
+    return value / 4294967296
+  }
+}
+
+/** The shape lib/password.ts verifies. A bare digest is not it, and never matched. */
+async function hashPassword(plain) {
+  const salt = randomBytes(16)
+  const key = await scryptAsync(plain, salt, 64, { N: 16384 })
+  return `scrypt$16384$${salt.toString('hex')}$${key.toString('hex')}`
+}
+
+async function ensureDevAccount() {
+  const hash = await hashPassword(DEV_ADDRESS)
+  await db.execute({
+    sql: `INSERT INTO mail_accounts (email, role, name, address, status, created_at, password_hash, password_is_default)
+          VALUES (?, 'member', 'Dev Test', ?, 'active', ?, ?, 1)
+          ON CONFLICT (email) DO UPDATE SET status = 'active', address = excluded.address`,
+    args: [DEV_ADDRESS, DEV_ADDRESS, new Date().toISOString(), hash],
+  })
+  return hash
+}
+
+async function main() {
+  await ensureDevAccount()
+  console.log(`  account ready: ${DEV_ADDRESS}`)
+
+  await db.execute("DELETE FROM mail_inbox WHERE id LIKE 'dev-%'")
+  await db.execute("DELETE FROM mail_shares WHERE id LIKE 'devshare%'")
+
+  const random = seededRandom(20260904)
+  const now = Date.now()
+
+  // The heavy ones get a share record each, so the download page has something
+  // real to render — the object itself is not uploaded, only the record.
+  const heavyFiles = [
+    ['site-survey-photos.zip', 1_850_000_000, 'application/zip'],
+    ['warehouse-walkthrough.mp4', 1_240_000_000, 'video/mp4'],
+    ['fleet-inspection-4k.mov', 980_000_000, 'video/quicktime'],
+    ['claims-archive-2019-2025.zip', 740_000_000, 'application/zip'],
+    ['policy-scans-full.pdf', 512_000_000, 'application/pdf'],
+    ['drone-footage-ikoyi.mp4', 430_000_000, 'video/mp4'],
+    ['premium-model.xlsx', 96_000_000, 'application/vnd.ms-excel'],
+    ['risk-register.csv', 62_000_000, 'text/csv'],
+    ['broker-pack.pdf', 48_000_000, 'application/pdf'],
+    ['loss-runs.zip', 31_000_000, 'application/zip'],
+  ]
+
+  // Real files, uploaded once and then shared by every message that claims to carry one,
+  // so opening an attachment in the seeded mailbox opens something. Without a bucket
+  // configured the records are written on their own, as they always were.
+  const { buildSamples } = await import('./sample-files.mjs')
+  const bucketReady = Boolean(process.env.R2_BUCKET && process.env.R2_ACCESS_KEY_ID && process.env.R2_S3_ENDPOINT)
+  let smallFiles = []
+  if (bucketReady) {
+    const { putObject } = await import('../lib/r2.ts')
+    for (const sample of buildSamples()) {
+      const key = `dev/samples/${sample.filename}`
+      const stored = await putObject(key, sample.bytes, sample.contentType)
+      if (stored) smallFiles.push([sample.filename, sample.bytes.length, sample.contentType, key])
+    }
+    console.log(`  ${smallFiles.length} sample files uploaded, and shared by the messages that carry one`)
+  }
+  if (!smallFiles.length) {
+    console.log('  no bucket configured: attachments are recorded but hold no bytes')
+    smallFiles = [
+      ['schedule.pdf', 240_000, 'application/pdf'],
+      ['certificate.pdf', 180_000, 'application/pdf'],
+      ['invoice.pdf', 96_000, 'application/pdf'],
+      ['endorsement.docx', 54_000, 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
+      ['vehicle-list.csv', 128_000, 'text/csv'],
+      ['photo-front.jpg', 320_000, 'image/jpeg'],
+      ['photo-rear.jpg', 298_000, 'image/jpeg'],
+      ['claim-form.pdf', 145_000, 'application/pdf'],
+      ['valuation.pdf', 210_000, 'application/pdf'],
+      ['cover-note.pdf', 88_000, 'application/pdf'],
+    ]
+  }
+
+  const rows = []
+  const shares = []
+
+  for (let index = 0; index < TOTAL; index += 1) {
+    const id = `dev-${String(index).padStart(4, '0')}`
+    const company = pick(COMPANIES, index)
+    const slug = company.toLowerCase().replace(/[^a-z]+/g, '')
+    // Every message comes from a different yopmail address.
+    const from = `${slug}${index}@yopmail.com`
+    const subject = pick(SUBJECTS, index)
+    const body = pick(BODIES, index)
+    const receivedAt = new Date(now - index * (1000 * 60 * 37)).toISOString()
+
+    let attachments = []
+    // Every other heavy file is locked, so both the open and the protected path can be
+    // walked. A real sender tells the recipient the password, so these do too.
+    let passwordNote = ''
+    if (index < WITH_HEAVY) {
+      const [filename, size, contentType] = heavyFiles[index]
+      const shareId = `devshare${String(index).padStart(2, '0')}`
+      const locked = index % 4 === 0
+      shares.push([shareId, `shares/dev/${filename}`, filename, contentType, size, locked])
+      attachments = [{ filename, contentType, size, shareId }]
+      passwordNote = locked
+        ? `\n\nThe file is too large to attach, so it is behind a link. The password is "${SHARE_PASSWORD}".`
+        : '\n\nThe file is too large to attach, so it is behind a link. No password is needed.'
+    } else if (index < WITH_HEAVY + WITH_ATTACHMENTS) {
+      const [filename, size, contentType, key] = smallFiles[(index - WITH_HEAVY) % smallFiles.length]
+      attachments = [key ? { filename, contentType, size, key } : { filename, contentType, size }]
+    }
+
+    rows.push([
+      id, from, JSON.stringify([DEV_ADDRESS]), '[]', '[]', '[]',
+      `${subject} — ${company}`, '',
+      `${body}${passwordNote}\n\nRegards,\n${company}`,
+      '{}', receivedAt, random() > 0.55 ? 1 : 0,
+      JSON.stringify(attachments),
+      random() > 0.9 ? 1 : 0, 0, 0, '[]', DEV_ADDRESS,
+    ])
+  }
+
+  for (const [id, key, filename, contentType, size, locked] of shares) {
+    await db.execute({
+      sql: `INSERT OR REPLACE INTO mail_shares
+            (id, object_key, filename, content_type, size, password_hash, owner, created_at, expires_at, max_downloads)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id, key, filename, contentType, size,
+        locked ? await hashPassword(SHARE_PASSWORD) : null,
+        DEV_ADDRESS, new Date().toISOString(),
+        new Date(now + 30 * 86400_000).toISOString(), null,
+      ],
+    })
+  }
+  const locked = shares.filter(share => share[5]).length
+  console.log(`  ${shares.length} share records, ${locked} of them locked with "${SHARE_PASSWORD}", which their messages say`)
+
+  // Batched: 500 individual round trips to Turso would take minutes.
+  const CHUNK = 50
+  for (let start = 0; start < rows.length; start += CHUNK) {
+    await db.batch(
+      rows.slice(start, start + CHUNK).map(args => ({
+        sql: `INSERT OR REPLACE INTO mail_inbox
+              (id, from_addr, to_addrs, cc, bcc, reply_to, subject, html, body_text, headers,
+               received_at, read, attachments, starred, archived, trashed, labels, owner)
+              VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+        args,
+      })),
+      'write',
+    )
+    process.stdout.write(`\r  seeding ${Math.min(start + CHUNK, rows.length)}/${rows.length}`)
+  }
+
+  const total = await db.execute({
+    sql: 'SELECT COUNT(*) AS n FROM mail_inbox WHERE owner = ?',
+    args: [DEV_ADDRESS],
+  })
+  const withAttachments = await db.execute({
+    sql: `SELECT COUNT(*) AS n FROM mail_inbox WHERE owner = ? AND attachments != '[]'`,
+    args: [DEV_ADDRESS],
+  })
+  const indexed = await db.execute('SELECT COUNT(*) AS n FROM mail_inbox_fts')
+
+  console.log(`\n  ${total.rows[0].n} messages for ${DEV_ADDRESS}`)
+  console.log(`  ${withAttachments.rows[0].n} carry attachments (${WITH_HEAVY} heavy, ${WITH_ATTACHMENTS} ordinary)`)
+  console.log(`  search index rows: ${indexed.rows[0].n}`)
+}
+
+main().catch(err => {
+  console.error('  seed failed:', err.message)
+  process.exit(1)
+})

package/tools/README.md

@@ -0,0 +1,18 @@
+# Tools
+
+> **Never deploy or `git push` unless asked for it in that request.** Pushing
+> `master` auto-deploys both live mailboxes. See the deploying section in the
+> root [README](../README.md).
+
+| File | What it does |
+|---|---|
+| `import-mbox.py` | Import an mbox into a mailbox. Bodies and metadata first, attachments second. |
+| `import-takeout.sh` | Wrapper: import one Google Takeout zip for one seat, streaming the mbox out of the zip. Set `IMPORT_LOG_DIR`. |
+| `db-backup.py` | Consistent snapshot of the mailbox database. |
+| `doh.py` | DNS-over-HTTPS lookups, for checking mail records without a local resolver. |
+
+Three scripts that used to live here — `night-plan.sh`, `uplink-lane.sh` and
+`takeout-queue.sh` — were a run-book for one tenant's migration: named seats,
+specific archive filenames, and an external drive. They also depended on a
+`mbox-scan.py` that was never in this repo. They stay in the mailbox they were
+written for rather than shipping here as something to copy.