@inbrx/cli 0.0.1-alpha.2 → 0.0.1-alpha.4

package/README.md

@@ -0,0 +1,78 @@
+# @inbrx/cli
+
+CLI for capturing local SMTP mail with inbrx. Start it, point your application at the local SMTP endpoint, and inspect captured emails in the browser.
+
+## Quick Start
+
+```bash
+npx @inbrx/cli
+```
+
+Defaults:
+
+- SMTP server: `127.0.0.1:2525`
+- Web UI: `http://127.0.0.1:3000`
+- Storage: file-backed, using the standard user data directory for your operating system
+
+Use memory-only storage for throwaway sessions:
+
+```bash
+npx @inbrx/cli --storage memory
+```
+
+## Options
+
+```bash
+inbrx start \
+  --smtp-host 127.0.0.1 \
+  --smtp-port 2525 \
+  --smtp-starttls \
+  --smtp-tls-key ./smtp.key \
+  --smtp-tls-cert ./smtp.crt \
+  --http-host 127.0.0.1 \
+  --http-port 3000 \
+  --max-messages 500 \
+  --storage file
+```
+
+Environment variables:
+
+- `SMTP_TEST_SMTP_HOST`
+- `SMTP_TEST_SMTP_PORT`
+- `INBRX_SMTP_STARTTLS=true|false`
+- `INBRX_SMTP_TLS_KEY`
+- `INBRX_SMTP_TLS_CERT`
+- `SMTP_TEST_HTTP_HOST`
+- `SMTP_TEST_HTTP_PORT`
+- `SMTP_TEST_MAX_MESSAGES`
+- `INBRX_STORAGE=file|memory`
+
+## STARTTLS
+
+Enable STARTTLS with an automatically generated in-memory self-signed certificate:
+
+```bash
+inbrx start --smtp-starttls
+```
+
+Use your own certificate by providing both paths. Providing both paths also enables STARTTLS:
+
+```bash
+inbrx start --smtp-tls-key ./smtp.key --smtp-tls-cert ./smtp.crt
+```
+
+Self-signed certificates usually require test clients to disable certificate verification:
+
+```bash
+swaks --to recipient@example.com \
+  --from sender@example.com \
+  --server 127.0.0.1 \
+  --port 2525 \
+  --tls \
+  --tls-verify false \
+  --auth LOGIN \
+  --auth-user sender@example.com \
+  --auth-password 'your_password' \
+  --header "Subject: test email" \
+  --body "Hello from SMTP"
+```

package/dist/cli.js

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { getDefaultConfig, loadConfig } from './config.js';
 import { startApp } from './index.js';
+import { getDefaultDataDir } from './store/data-dir.js';
 export async function runCli(argv) {
     const program = createCliProgram();
     await program.parseAsync(normalizeArgv(argv), { from: 'node' });
@@ -18,17 +19,25 @@ export function createCliProgram() {
         .description('Start the SMTP server and HTTP API/UI.')
         .option('--smtp-host <host>', `SMTP bind host. Default: ${defaults.smtpHost}`)
         .option('--smtp-port <port>', `SMTP port. Default: ${defaults.smtpPort}`)
+        .option('--smtp-starttls', 'Advertise and support STARTTLS. Generates a temporary self-signed certificate unless TLS paths are provided.')
+        .option('--smtp-tls-key <path>', 'TLS private key path for STARTTLS. Enables STARTTLS when paired with --smtp-tls-cert.')
+        .option('--smtp-tls-cert <path>', 'TLS certificate path for STARTTLS. Enables STARTTLS when paired with --smtp-tls-key.')
         .option('--http-host <host>', `HTTP bind host. Default: ${defaults.httpHost}`)
         .option('--http-port <port>', `HTTP port. Default: ${defaults.httpPort}`)
         .option('--max-messages <count>', `Maximum retained messages. Default: ${defaults.maxMessages}`)
+        .option('--storage <mode>', `Storage mode: file or memory. Default: ${defaults.storage}`)
         .addHelpText('after', `
 
 Environment:
   SMTP_TEST_SMTP_HOST
   SMTP_TEST_SMTP_PORT
+  INBRX_SMTP_STARTTLS
+  INBRX_SMTP_TLS_KEY
+  INBRX_SMTP_TLS_CERT
   SMTP_TEST_HTTP_HOST
   SMTP_TEST_HTTP_PORT
-  SMTP_TEST_MAX_MESSAGES`)
+  SMTP_TEST_MAX_MESSAGES
+  INBRX_STORAGE`)
         .action(async (options) => {
         await startServer(options);
     });
@@ -39,7 +48,9 @@ async function startServer(options) {
     const app = await startApp(config);
     console.log('SMTP test server ready');
     console.log(`SMTP: smtp://${config.smtpHost}:${config.smtpPort}`);
+    console.log(`SMTP STARTTLS: ${config.smtpStartTls ? 'enabled' : 'disabled'}`);
     console.log(`Web UI: http://${config.httpHost}:${config.httpPort}`);
+    console.log(`Storage: ${config.storage}${config.storage === 'file' ? ` (${getDefaultDataDir()})` : ''}`);
     console.log('Press Ctrl+C to stop.');
     const shutdown = async () => {
         console.log('\nShutting down...');

package/dist/config.js

@@ -1,20 +1,35 @@
 const DEFAULTS = {
     smtpHost: '127.0.0.1',
     smtpPort: 2525,
+    smtpStartTls: false,
+    smtpTlsKeyPath: null,
+    smtpTlsCertPath: null,
     httpHost: '127.0.0.1',
     httpPort: 3000,
-    maxMessages: 500
+    maxMessages: 500,
+    storage: 'file'
 };
 export function loadConfig(overrides = {}) {
+    const smtpTlsKeyPath = readOptionalString(overrides.smtpTlsKeyPath, process.env.INBRX_SMTP_TLS_KEY, DEFAULTS.smtpTlsKeyPath);
+    const smtpTlsCertPath = readOptionalString(overrides.smtpTlsCertPath, process.env.INBRX_SMTP_TLS_CERT, DEFAULTS.smtpTlsCertPath);
     const config = {
         smtpHost: readString(overrides.smtpHost, process.env.SMTP_TEST_SMTP_HOST, DEFAULTS.smtpHost),
         smtpPort: readNumber(overrides.smtpPort, process.env.SMTP_TEST_SMTP_PORT, DEFAULTS.smtpPort),
+        smtpStartTls: readBoolean(overrides.smtpStartTls ?? overrides.smtpStarttls, process.env.INBRX_SMTP_STARTTLS, DEFAULTS.smtpStartTls) ||
+            Boolean(smtpTlsKeyPath) ||
+            Boolean(smtpTlsCertPath),
+        smtpTlsKeyPath,
+        smtpTlsCertPath,
         httpHost: readString(overrides.httpHost, process.env.SMTP_TEST_HTTP_HOST, DEFAULTS.httpHost),
         httpPort: readNumber(overrides.httpPort, process.env.SMTP_TEST_HTTP_PORT, DEFAULTS.httpPort),
-        maxMessages: readNumber(overrides.maxMessages, process.env.SMTP_TEST_MAX_MESSAGES, DEFAULTS.maxMessages)
+        maxMessages: readNumber(overrides.maxMessages, process.env.SMTP_TEST_MAX_MESSAGES, DEFAULTS.maxMessages),
+        storage: readStorageMode(overrides.storage, process.env.INBRX_STORAGE, DEFAULTS.storage)
     };
     assertPort(config.smtpPort, 'SMTP port');
     assertPort(config.httpPort, 'HTTP port');
+    if (Boolean(config.smtpTlsKeyPath) !== Boolean(config.smtpTlsCertPath)) {
+        throw new Error('SMTP TLS key and certificate paths must be provided together.');
+    }
     if (!Number.isInteger(config.maxMessages) || config.maxMessages < 1) {
         throw new Error('Max messages must be a positive integer.');
     }
@@ -32,6 +47,15 @@ function readString(override, envValue, fallback) {
     }
     return fallback;
 }
+function readOptionalString(override, envValue, fallback) {
+    if (override !== undefined && override !== null && override !== '') {
+        return String(override);
+    }
+    if (envValue !== undefined && envValue !== '') {
+        return envValue;
+    }
+    return fallback;
+}
 function readNumber(override, envValue, fallback) {
     const value = override ?? envValue;
     if (value === undefined || value === '') {
@@ -43,8 +67,32 @@ function readNumber(override, envValue, fallback) {
     }
     return parsed;
 }
+function readBoolean(override, envValue, fallback) {
+    const value = override ?? envValue;
+    if (value === undefined || value === null || value === '') {
+        return fallback;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    const normalized = String(value).toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['0', 'false', 'no', 'off'].includes(normalized)) {
+        return false;
+    }
+    throw new Error(`Expected a boolean, received "${value}".`);
+}
 function assertPort(value, label) {
     if (!Number.isInteger(value) || value < 1 || value > 65535) {
         throw new Error(`${label} must be an integer between 1 and 65535.`);
     }
 }
+function readStorageMode(override, envValue, fallback) {
+    const value = readString(override, envValue, fallback);
+    if (value === 'file' || value === 'memory') {
+        return value;
+    }
+    throw new Error('Storage must be either "file" or "memory".');
+}

package/dist/events/mailbox-events.js

@@ -0,0 +1,16 @@
+export function createMailboxEvents() {
+    const listeners = new Set();
+    return {
+        emit(event) {
+            for (const listener of listeners) {
+                listener(event);
+            }
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        }
+    };
+}

package/dist/http/server.js

@@ -5,10 +5,11 @@ import { Readable } from 'node:stream';
 import { fileURLToPath } from 'node:url';
 import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
+import { createMailboxEvents } from '../events/mailbox-events.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WEB_ROOT = path.resolve(__dirname, '../../..', 'web/dist');
-export function createHttpServer({ store }) {
-    const app = createHttpApp({ store });
+export function createHttpServer({ store, attachmentStore, events = createMailboxEvents() }) {
+    const app = createHttpApp({ store, attachmentStore, events });
     let server = null;
     return {
         listen(port, host) {
@@ -43,34 +44,123 @@ export function createHttpServer({ store }) {
         }
     };
 }
-export function createHttpApp({ store }) {
+export function createHttpApp({ store, attachmentStore, events = createMailboxEvents() }) {
     const app = new Hono();
     app.onError((error, c) => {
         console.error(error);
         return c.json({ error: 'Internal server error' }, 500);
     });
     app.get('/api/health', (c) => c.json({ status: 'ok' }));
-    app.get('/api/messages', (c) => c.json({
-        messages: store.list().map(toMessageSummary)
+    app.get('/api/events', (c) => sseResponse(events, c.req.raw.signal));
+    app.get('/api/messages', async (c) => c.json({
+        messages: (await store.list()).map(toMessageSummary)
     }));
-    app.delete('/api/messages', (c) => {
-        const deleted = store.clear();
+    app.delete('/api/messages', async (c) => {
+        const deleted = await store.clear();
+        events.emit({ type: 'messages.cleared', deleted });
         return c.json({ deleted });
     });
-    app.get('/api/messages/:id', (c) => {
-        const message = store.get(c.req.param('id'));
+    app.get('/api/messages/:id', async (c) => {
+        const message = await store.get(c.req.param('id'));
         if (!message) {
             return c.json({ error: 'Message not found' }, 404);
         }
         return c.json({ message: toMessageDetail(message) });
     });
-    app.delete('/api/messages/:id', (c) => {
-        const deleted = store.delete(c.req.param('id'));
+    app.get('/api/messages/:id/attachments/:attachmentId', async (c) => {
+        const messageId = c.req.param('id');
+        const attachmentId = c.req.param('attachmentId');
+        const message = await store.get(messageId);
+        if (!message) {
+            return c.json({ error: 'Message not found' }, 404);
+        }
+        const attachment = message.attachments.find((item) => item.id === attachmentId);
+        if (!attachment) {
+            return c.json({ error: 'Attachment not found' }, 404);
+        }
+        const storedAttachment = await attachmentStore.get(messageId, attachmentId);
+        if (!storedAttachment) {
+            return c.json({ error: 'Attachment not found' }, 404);
+        }
+        return new Response(storedAttachment.content, {
+            headers: attachmentHeaders(attachment)
+        });
+    });
+    app.delete('/api/messages/:id', async (c) => {
+        const messageId = c.req.param('id');
+        const deleted = await store.delete(messageId);
+        if (deleted) {
+            events.emit({ type: 'message.deleted', id: messageId });
+        }
         return c.json({ deleted }, deleted ? 200 : 404);
     });
     app.all('*', (c) => serveStatic(new URL(c.req.url).pathname));
     return app;
 }
+function sseResponse(events, signal) {
+    const encoder = new TextEncoder();
+    let unsubscribe = null;
+    let keepalive = null;
+    let closed = false;
+    const stream = new ReadableStream({
+        start(controller) {
+            const send = (event, data) => {
+                if (closed) {
+                    return;
+                }
+                controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+            };
+            const cleanup = () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                unsubscribe?.();
+                unsubscribe = null;
+                if (keepalive) {
+                    clearInterval(keepalive);
+                    keepalive = null;
+                }
+            };
+            send('ready', { version: 1 });
+            unsubscribe = events.subscribe((event) => {
+                send(event.type, eventData(event));
+            });
+            keepalive = setInterval(() => {
+                if (!closed) {
+                    controller.enqueue(encoder.encode(': keepalive\n\n'));
+                }
+            }, 30000);
+            signal.addEventListener('abort', cleanup, { once: true });
+        },
+        cancel() {
+            closed = true;
+            unsubscribe?.();
+            unsubscribe = null;
+            if (keepalive) {
+                clearInterval(keepalive);
+                keepalive = null;
+            }
+        }
+    });
+    return new Response(stream, {
+        headers: {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-cache, no-transform',
+            connection: 'keep-alive'
+        }
+    });
+}
+function eventData(event) {
+    switch (event.type) {
+        case 'message.created':
+            return { id: event.id, receivedAt: event.receivedAt };
+        case 'message.deleted':
+            return { id: event.id };
+        case 'messages.cleared':
+            return { deleted: event.deleted };
+    }
+}
 function toMessageSummary(message) {
     return {
         id: message.id,
@@ -135,3 +225,14 @@ function contentTypeFor(filePath) {
     }
     return 'application/octet-stream';
 }
+function attachmentHeaders(attachment) {
+    const headers = new Headers();
+    headers.set('content-type', attachment.contentType);
+    headers.set('content-length', String(attachment.sizeBytes));
+    headers.set('content-disposition', contentDispositionFor(attachment.filename));
+    return headers;
+}
+function contentDispositionFor(filename) {
+    const safeFilename = (filename || 'attachment').replace(/[^\w.!#$&+^`{}~-]+/g, '_');
+    return `attachment; filename="${safeFilename}"`;
+}

package/dist/index.js

@@ -1,10 +1,22 @@
+import { createMailboxEvents } from './events/mailbox-events.js';
 import { createHttpServer } from './http/server.js';
+import { createFileAttachmentStore, createMemoryAttachmentStore } from './store/attachment-store.js';
+import { getDefaultDataDir } from './store/data-dir.js';
+import { createFileMessageStore } from './store/file-store.js';
 import { createMemoryStore } from './store/memory-store.js';
 import { createSmtpServer } from './smtp/server.js';
 export async function startApp(config) {
-    const store = createMemoryStore({ maxMessages: config.maxMessages });
-    const smtpServer = createSmtpServer({ store });
-    const httpServer = createHttpServer({ store });
+    const events = createMailboxEvents();
+    const { store, attachmentStore } = createStores(config, events);
+    const smtpServer = await createSmtpServer({
+        store,
+        attachmentStore,
+        events,
+        startTls: config.smtpStartTls,
+        tlsKeyPath: config.smtpTlsKeyPath,
+        tlsCertPath: config.smtpTlsCertPath
+    });
+    const httpServer = createHttpServer({ store, attachmentStore, events });
     await Promise.all([
         smtpServer.listen(config.smtpPort, config.smtpHost),
         httpServer.listen(config.httpPort, config.httpHost)
@@ -16,3 +28,33 @@ export async function startApp(config) {
         }
     };
 }
+function createStores(config, events) {
+    if (config.storage === 'memory') {
+        const attachmentStore = createMemoryAttachmentStore();
+        return {
+            attachmentStore,
+            store: createMemoryStore({
+                maxMessages: config.maxMessages,
+                onDelete: createDeleteHandler(attachmentStore, events)
+            })
+        };
+    }
+    const dataDir = getDefaultDataDir();
+    const attachmentStore = createFileAttachmentStore({ rootDir: dataDir });
+    return {
+        attachmentStore,
+        store: createFileMessageStore({
+            rootDir: dataDir,
+            maxMessages: config.maxMessages,
+            onDelete: createDeleteHandler(attachmentStore, events)
+        })
+    };
+}
+function createDeleteHandler(attachmentStore, events) {
+    return async (messageId, reason) => {
+        await attachmentStore.deleteForMessage(messageId);
+        if (reason === 'evicted') {
+            events.emit({ type: 'message.deleted', id: messageId });
+        }
+    };
+}

package/dist/mail/parser.js

@@ -1,9 +1,20 @@
 import { randomUUID } from 'node:crypto';
 import { simpleParser } from 'mailparser';
-export async function parseMessage({ raw, envelope, smtp }) {
+export async function parseMessage({ raw, envelope, smtp, attachmentStore }) {
     const parsed = await simpleParser(Buffer.from(raw));
+    const id = randomUUID();
+    const attachments = [];
+    for (const attachment of parsed.attachments) {
+        attachments.push(await attachmentStore.save({
+            messageId: id,
+            filename: attachment.filename || null,
+            contentType: attachment.contentType,
+            contentId: attachment.contentId,
+            content: attachment.content
+        }));
+    }
     return {
-        id: randomUUID(),
+        id,
         receivedAt: new Date().toISOString(),
         from: envelope.from || firstAddress(parsed.from),
         to: envelope.to.length > 0 ? envelope.to : addressList(parsed.to),
@@ -13,12 +24,7 @@ export async function parseMessage({ raw, envelope, smtp }) {
         headers: headersToRecord(parsed.headers),
         text: parsed.text || null,
         html: typeof parsed.html === 'string' ? parsed.html : null,
-        attachments: parsed.attachments.map((attachment) => ({
-            filename: attachment.filename || null,
-            contentType: attachment.contentType,
-            sizeBytes: attachment.size,
-            contentId: attachment.contentId
-        })),
+        attachments,
         rawSizeBytes: Buffer.byteLength(raw),
         raw,
         smtp

package/dist/smtp/server.js

@@ -1,13 +1,21 @@
+import { readFile } from 'node:fs/promises';
 import { SMTPServer } from 'smtp-server';
+import { generate } from 'selfsigned';
 import { parseMessage } from '../mail/parser.js';
-export function createSmtpServer({ store }) {
+export async function createSmtpServer({ store, attachmentStore, events, startTls = false, tlsKeyPath = null, tlsCertPath = null }) {
+    const tlsConfig = startTls ? await createTlsConfig({ keyPath: tlsKeyPath, certPath: tlsCertPath }) : null;
     const server = new SMTPServer({
         name: 'inbrx',
         banner: 'inbrx ready',
+        ...(tlsConfig ?? {}),
         authOptional: true,
-        disabledCommands: ['AUTH', 'STARTTLS'],
+        allowInsecureAuth: true,
+        disabledCommands: startTls ? [] : ['STARTTLS'],
         hidePIPELINING: true,
         logger: false,
+        onAuth(auth, _session, callback) {
+            callback(null, { user: auth.username || 'anonymous' });
+        },
         onMailFrom(_address, _session, callback) {
             callback();
         },
@@ -15,8 +23,11 @@ export function createSmtpServer({ store }) {
             callback();
         },
         onData(stream, session, callback) {
-            void handleData(stream, session, store)
-                .then((messageId) => callback(null, `OK captured as ${messageId}`))
+            void handleData(stream, session, store, attachmentStore)
+                .then((message) => {
+                events?.emit({ type: 'message.created', id: message.id, receivedAt: message.receivedAt });
+                callback(null, `OK captured as ${message.id}`);
+            })
                 .catch((error) => callback(error instanceof Error ? error : new Error(String(error))));
         }
     });
@@ -37,13 +48,55 @@ export function createSmtpServer({ store }) {
         }
     };
 }
-async function handleData(stream, session, store) {
+async function createTlsConfig({ keyPath, certPath }) {
+    if (keyPath || certPath) {
+        if (!keyPath || !certPath) {
+            throw new Error('SMTP TLS key and certificate paths must be provided together.');
+        }
+        const [key, cert] = await Promise.all([readFile(keyPath), readFile(certPath)]);
+        return { key, cert };
+    }
+    const pems = await generate([{ name: 'commonName', value: 'localhost' }], {
+        keySize: 2048,
+        algorithm: 'sha256',
+        extensions: [
+            {
+                name: 'basicConstraints',
+                cA: false
+            },
+            {
+                name: 'keyUsage',
+                digitalSignature: true,
+                keyEncipherment: true
+            },
+            {
+                name: 'subjectAltName',
+                altNames: [
+                    { type: 2, value: 'localhost' },
+                    { type: 7, ip: '127.0.0.1' },
+                    { type: 7, ip: '::1' }
+                ]
+            }
+        ]
+    });
+    return {
+        key: pems.private,
+        cert: pems.cert
+    };
+}
+async function handleData(stream, session, store, attachmentStore) {
     const raw = await readStream(stream);
     const smtp = toCapturedSmtpSession(session);
     const envelope = toMailEnvelope(smtp);
-    const message = await parseMessage({ raw, envelope, smtp });
-    store.add(message);
-    return message.id;
+    const message = await parseMessage({ raw, envelope, smtp, attachmentStore });
+    try {
+        await store.add(message);
+    }
+    catch (error) {
+        await attachmentStore.deleteForMessage(message.id);
+        throw error;
+    }
+    return message;
 }
 function readStream(stream) {
     return new Promise((resolve, reject) => {

package/dist/store/attachment-store.js

@@ -0,0 +1,84 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export function createMemoryAttachmentStore() {
+    const attachments = new Map();
+    return {
+        async save(input) {
+            const attachment = toCapturedAttachment(input);
+            attachments.set(toMapKey(input.messageId, attachment.id), {
+                ...attachment,
+                content: input.content
+            });
+            return attachment;
+        },
+        async get(messageId, attachmentId) {
+            return attachments.get(toMapKey(messageId, attachmentId)) || null;
+        },
+        async deleteForMessage(messageId) {
+            for (const key of attachments.keys()) {
+                if (key.startsWith(`${messageId}/`)) {
+                    attachments.delete(key);
+                }
+            }
+        },
+        async clear() {
+            attachments.clear();
+        }
+    };
+}
+export function createFileAttachmentStore({ rootDir }) {
+    const attachmentsDir = path.join(rootDir, 'attachments');
+    return {
+        async save(input) {
+            const attachment = toCapturedAttachment(input);
+            const filePath = attachmentPath(attachmentsDir, input.messageId, attachment.id);
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, input.content);
+            return attachment;
+        },
+        async get(messageId, attachmentId) {
+            const filePath = attachmentPath(attachmentsDir, messageId, attachmentId);
+            try {
+                const content = await readFile(filePath);
+                return {
+                    id: attachmentId,
+                    filename: null,
+                    contentType: 'application/octet-stream',
+                    sizeBytes: content.byteLength,
+                    storageKey: storageKeyFor(messageId, attachmentId),
+                    content
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+        async deleteForMessage(messageId) {
+            await rm(path.join(attachmentsDir, messageId), { recursive: true, force: true });
+        },
+        async clear() {
+            await rm(attachmentsDir, { recursive: true, force: true });
+        }
+    };
+}
+function toCapturedAttachment(input) {
+    const id = randomUUID();
+    return {
+        id,
+        filename: input.filename,
+        contentType: input.contentType,
+        sizeBytes: input.content.byteLength,
+        storageKey: storageKeyFor(input.messageId, id),
+        ...(input.contentId ? { contentId: input.contentId } : {})
+    };
+}
+function toMapKey(messageId, attachmentId) {
+    return `${messageId}/${attachmentId}`;
+}
+function storageKeyFor(messageId, attachmentId) {
+    return toMapKey(messageId, attachmentId);
+}
+function attachmentPath(attachmentsDir, messageId, attachmentId) {
+    return path.join(attachmentsDir, messageId, attachmentId);
+}

package/dist/store/data-dir.js

@@ -0,0 +1,12 @@
+import os from 'node:os';
+import path from 'node:path';
+const APP_DIR_NAME = 'inbrx';
+export function getDefaultDataDir(platform = process.platform, env = process.env) {
+    if (platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Application Support', APP_DIR_NAME);
+    }
+    if (platform === 'win32') {
+        return path.join(env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), APP_DIR_NAME);
+    }
+    return path.join(env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), APP_DIR_NAME);
+}

package/dist/store/file-store.js

@@ -0,0 +1,71 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export function createFileMessageStore({ rootDir, maxMessages, onDelete }) {
+    const messagesDir = path.join(rootDir, 'messages');
+    return {
+        async add(message) {
+            await mkdir(messagesDir, { recursive: true });
+            await writeFile(messagePath(messagesDir, message.id), JSON.stringify(message, null, 2));
+            await trimMessages({ messagesDir, maxMessages, onDelete });
+            return message;
+        },
+        async list() {
+            return listMessages(messagesDir);
+        },
+        async get(id) {
+            return readMessage(messagesDir, id);
+        },
+        async delete(id) {
+            const message = await readMessage(messagesDir, id);
+            if (!message) {
+                return false;
+            }
+            await rm(messagePath(messagesDir, id), { force: true });
+            await onDelete?.(id, 'deleted');
+            return true;
+        },
+        async clear() {
+            const messages = await listMessages(messagesDir);
+            await rm(messagesDir, { recursive: true, force: true });
+            await Promise.all(messages.map((message) => onDelete?.(message.id, 'cleared')));
+            return messages.length;
+        }
+    };
+}
+async function trimMessages({ messagesDir, maxMessages, onDelete }) {
+    const messages = await listMessages(messagesDir);
+    const removed = messages.slice(maxMessages);
+    await Promise.all(removed.map(async (message) => {
+        await rm(messagePath(messagesDir, message.id), { force: true });
+        await onDelete?.(message.id, 'evicted');
+    }));
+}
+async function listMessages(messagesDir) {
+    let entries;
+    try {
+        entries = await readdir(messagesDir);
+    }
+    catch {
+        return [];
+    }
+    const messages = await Promise.all(entries
+        .filter((entry) => entry.endsWith('.json'))
+        .map((entry) => readMessageFile(path.join(messagesDir, entry))));
+    return messages
+        .filter((message) => Boolean(message))
+        .sort((a, b) => b.receivedAt.localeCompare(a.receivedAt));
+}
+async function readMessage(messagesDir, id) {
+    return readMessageFile(messagePath(messagesDir, id));
+}
+async function readMessageFile(filePath) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function messagePath(messagesDir, id) {
+    return path.join(messagesDir, `${id}.json`);
+}

package/dist/store/memory-store.js

@@ -1,36 +1,42 @@
-export function createMemoryStore({ maxMessages }) {
+export function createMemoryStore({ maxMessages, onDelete }) {
     const messages = new Map();
     const order = [];
     return {
-        add(message) {
+        async add(message) {
             messages.set(message.id, message);
             order.unshift(message.id);
             while (order.length > maxMessages) {
                 const removedId = order.pop();
                 if (removedId) {
                     messages.delete(removedId);
+                    await onDelete?.(removedId, 'evicted');
                 }
             }
             return message;
         },
-        list() {
+        async list() {
             return order.map((id) => messages.get(id)).filter((message) => Boolean(message));
         },
-        get(id) {
+        async get(id) {
             return messages.get(id) || null;
         },
-        delete(id) {
+        async delete(id) {
             const existed = messages.delete(id);
             const index = order.indexOf(id);
             if (index !== -1) {
                 order.splice(index, 1);
             }
+            if (existed) {
+                await onDelete?.(id, 'deleted');
+            }
             return existed;
         },
-        clear() {
+        async clear() {
             const count = messages.size;
+            const ids = [...messages.keys()];
             messages.clear();
             order.length = 0;
+            await Promise.all(ids.map((id) => onDelete?.(id, 'cleared')));
             return count;
         }
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inbrx/cli",
-  "version": "0.0.1-alpha.2",
-  "description": "SMTP capture server and CLI for inbrx.",
+  "version": "0.0.1-alpha.4",
+  "description": "CLI for capturing local SMTP mail with inbrx.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuaixr/inbrx.git"
@@ -9,7 +9,8 @@
   "type": "module",
   "files": [
     "bin",
-    "dist"
+    "dist",
+    "README.md"
   ],
   "bin": {
     "inbrx": "./bin/inbrx.js"
@@ -23,20 +24,23 @@
     "dev": "tsx watch ./src/cli.ts start",
     "test": "vitest run --exclude \"dist/**\"",
     "test:watch": "vitest",
+    "coverage": "vitest run --coverage --coverage.reporter=lcov --exclude \"dist/**\"",
     "check": "tsc --noEmit -p tsconfig.json && node --check ./bin/inbrx.js && npm run test"
   },
   "dependencies": {
     "@hono/node-server": "^2.0.8",
-    "@inbrx/web": "0.0.1-alpha.2",
+    "@inbrx/web": "0.0.1-alpha.4",
     "commander": "^15.0.0",
     "hono": "^4.12.27",
     "mailparser": "^3.9.14",
+    "selfsigned": "^5.5.0",
     "smtp-server": "^3.19.2"
   },
   "devDependencies": {
     "@types/mailparser": "^3.4.6",
     "@types/nodemailer": "^8.0.1",
     "@types/smtp-server": "^3.5.13",
+    "@vitest/coverage-v8": "^4.1.9",
     "nodemailer": "^9.0.3",
     "tsx": "^4.19.0",
     "vitest": "^4.1.9"