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

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' });
@@ -21,6 +22,7 @@ export function createCliProgram() {
         .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:
@@ -28,7 +30,8 @@ Environment:
   SMTP_TEST_SMTP_PORT
   SMTP_TEST_HTTP_HOST
   SMTP_TEST_HTTP_PORT
-  SMTP_TEST_MAX_MESSAGES`)
+  SMTP_TEST_MAX_MESSAGES
+  INBRX_STORAGE`)
         .action(async (options) => {
         await startServer(options);
     });
@@ -40,6 +43,7 @@ async function startServer(options) {
     console.log('SMTP test server ready');
     console.log(`SMTP: smtp://${config.smtpHost}:${config.smtpPort}`);
     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

@@ -3,7 +3,8 @@ const DEFAULTS = {
     smtpPort: 2525,
     httpHost: '127.0.0.1',
     httpPort: 3000,
-    maxMessages: 500
+    maxMessages: 500,
+    storage: 'file'
 };
 export function loadConfig(overrides = {}) {
     const config = {
@@ -11,7 +12,8 @@ export function loadConfig(overrides = {}) {
         smtpPort: readNumber(overrides.smtpPort, process.env.SMTP_TEST_SMTP_PORT, DEFAULTS.smtpPort),
         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');
@@ -48,3 +50,10 @@ function assertPort(value, label) {
         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/http/server.js

@@ -7,8 +7,8 @@ import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
 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 }) {
+    const app = createHttpApp({ store, attachmentStore });
     let server = null;
     return {
         listen(port, host) {
@@ -43,29 +43,48 @@ export function createHttpServer({ store }) {
         }
     };
 }
-export function createHttpApp({ store }) {
+export function createHttpApp({ store, attachmentStore }) {
     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/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();
         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 deleted = await store.delete(c.req.param('id'));
         return c.json({ deleted }, deleted ? 200 : 404);
     });
     app.all('*', (c) => serveStatic(new URL(c.req.url).pathname));
@@ -135,3 +154,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,13 @@
 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 { store, attachmentStore } = createStores(config);
+    const smtpServer = createSmtpServer({ store, attachmentStore });
+    const httpServer = createHttpServer({ store, attachmentStore });
     await Promise.all([
         smtpServer.listen(config.smtpPort, config.smtpHost),
         httpServer.listen(config.httpPort, config.httpHost)
@@ -16,3 +19,25 @@ export async function startApp(config) {
         }
     };
 }
+function createStores(config) {
+    if (config.storage === 'memory') {
+        const attachmentStore = createMemoryAttachmentStore();
+        return {
+            attachmentStore,
+            store: createMemoryStore({
+                maxMessages: config.maxMessages,
+                onDelete: (messageId) => attachmentStore.deleteForMessage(messageId)
+            })
+        };
+    }
+    const dataDir = getDefaultDataDir();
+    const attachmentStore = createFileAttachmentStore({ rootDir: dataDir });
+    return {
+        attachmentStore,
+        store: createFileMessageStore({
+            rootDir: dataDir,
+            maxMessages: config.maxMessages,
+            onDelete: (messageId) => attachmentStore.deleteForMessage(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,6 +1,6 @@
 import { SMTPServer } from 'smtp-server';
 import { parseMessage } from '../mail/parser.js';
-export function createSmtpServer({ store }) {
+export function createSmtpServer({ store, attachmentStore }) {
     const server = new SMTPServer({
         name: 'inbrx',
         banner: 'inbrx ready',
@@ -15,7 +15,7 @@ export function createSmtpServer({ store }) {
             callback();
         },
         onData(stream, session, callback) {
-            void handleData(stream, session, store)
+            void handleData(stream, session, store, attachmentStore)
                 .then((messageId) => callback(null, `OK captured as ${messageId}`))
                 .catch((error) => callback(error instanceof Error ? error : new Error(String(error))));
         }
@@ -37,12 +37,18 @@ export function createSmtpServer({ store }) {
         }
     };
 }
-async function handleData(stream, session, store) {
+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);
+    const message = await parseMessage({ raw, envelope, smtp, attachmentStore });
+    try {
+        await store.add(message);
+    }
+    catch (error) {
+        await attachmentStore.deleteForMessage(message.id);
+        throw error;
+    }
     return message.id;
 }
 function readStream(stream) {

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);
+            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)));
+            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);
+    }));
+}
+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);
                 }
             }
             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);
+            }
             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)));
             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.3",
+  "description": "CLI for capturing local SMTP mail with inbrx.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuaixr/inbrx.git"
@@ -23,11 +23,12 @@
     "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.3",
     "commander": "^15.0.0",
     "hono": "^4.12.27",
     "mailparser": "^3.9.14",
@@ -37,6 +38,7 @@
     "@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"