@yujinapp/yuemail 0.4.0

package/server-dist/routes/inbox.js

@@ -0,0 +1,81 @@
+import { ImapFlow } from 'imapflow';
+import { getCategoryStatus, getKey } from '../vault.js';
+export function registerInboxRoutes(app) {
+    app.get('/api/inbox/list', async (req, res) => {
+        const status = await getCategoryStatus();
+        if (!status.imap.configured) {
+            res.status(400).json({
+                ok: false,
+                error: 'IMAP not configured. Run `yuemail vault setup` to configure your IMAP server.',
+                missing: status.imap.missing,
+            });
+            return;
+        }
+        const host = await getKey('imap.host');
+        const portStr = await getKey('imap.port');
+        const user = await getKey('imap.user');
+        const pass = await getKey('imap.pass');
+        const secStr = await getKey('imap.secure');
+        if (!host || !portStr || !user || !pass) {
+            res.status(400).json({ ok: false, error: 'IMAP not configured (missing decrypted credential)' });
+            return;
+        }
+        const port = Number(portStr);
+        if (!Number.isFinite(port) || port <= 0) {
+            res.status(400).json({ ok: false, error: 'imap.port is not a positive integer' });
+            return;
+        }
+        const secure = (secStr ?? 'true').toLowerCase() !== 'false';
+        const limitRaw = Number(req.query['limit'] ?? 20);
+        const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(Math.floor(limitRaw), 1), 100) : 20;
+        const client = new ImapFlow({
+            host,
+            port,
+            secure,
+            auth: { user, pass },
+            logger: false,
+        });
+        const envelopes = [];
+        try {
+            await client.connect();
+            const lock = await client.getMailboxLock('INBOX');
+            try {
+                const mbox = client.mailbox;
+                const total = (mbox && typeof mbox.exists === 'number') ? mbox.exists : 0;
+                if (total === 0) {
+                    res.json({ ok: true, envelopes: [] });
+                    return;
+                }
+                const start = Math.max(1, total - limit + 1);
+                const range = start + ':' + total;
+                for await (const msg of client.fetch(range, { uid: true, envelope: true })) {
+                    const env = msg.envelope;
+                    const fromList = (env?.from ?? []);
+                    const first = fromList[0] ?? {};
+                    const fromStr = (first.name ?? '') + (first.address ? ' <' + first.address + '>' : '');
+                    envelopes.push({
+                        uid: Number(msg.uid ?? 0),
+                        from: fromStr.trim(),
+                        subject: env?.subject ?? '(sin asunto)',
+                        date: env?.date ? new Date(env.date).toISOString() : '',
+                    });
+                }
+                envelopes.sort((a, b) => b.uid - a.uid);
+                res.json({ ok: true, envelopes });
+            }
+            finally {
+                lock.release();
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json({ ok: false, error: 'IMAP fetch failed: ' + message });
+        }
+        finally {
+            try {
+                await client.logout();
+            }
+            catch { /* ignore */ }
+        }
+    });
+}

package/server-dist/routes/settings.js

@@ -0,0 +1,119 @@
+import nodemailer from 'nodemailer';
+import { ImapFlow } from 'imapflow';
+import { autoconfigure } from '../autoconfig.js';
+import { getKey } from '../vault.js';
+const VERIFY_TIMEOUT_MS = 10000;
+function str(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+/** Merge form overrides with vault values, field by field. */
+async function effectiveConfig(cat, over) {
+    const host = str(over?.host) ?? await getKey(cat + '.host');
+    const portRaw = str(String(over?.port ?? '')) ?? await getKey(cat + '.port');
+    const user = str(over?.user) ?? await getKey(cat + '.user');
+    const pass = str(over?.pass) ?? await getKey(cat + '.pass');
+    if (!host || !portRaw || !user || !pass)
+        return undefined;
+    const port = Number(portRaw);
+    if (!Number.isFinite(port) || port <= 0)
+        return undefined;
+    let secure;
+    if (typeof over?.secure === 'boolean') {
+        secure = over.secure;
+    }
+    else {
+        const secStr = await getKey(cat + '.secure');
+        /* Same defaults the send/inbox routes apply. */
+        secure = cat === 'imap'
+            ? (secStr ?? 'true').toLowerCase() !== 'false'
+            : (secStr ?? '').toLowerCase() === 'true' || port === 465;
+    }
+    return { host, port, user, pass, secure };
+}
+function shortError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.split('\n')[0]?.slice(0, 200) ?? 'error desconocido';
+}
+async function verifySmtp(cfg) {
+    const transporter = nodemailer.createTransport({
+        host: cfg.host,
+        port: cfg.port,
+        secure: cfg.secure,
+        auth: { user: cfg.user, pass: cfg.pass },
+        connectionTimeout: VERIFY_TIMEOUT_MS,
+        greetingTimeout: VERIFY_TIMEOUT_MS,
+        socketTimeout: VERIFY_TIMEOUT_MS,
+    });
+    try {
+        await transporter.verify();
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: shortError(err) };
+    }
+    finally {
+        transporter.close();
+    }
+}
+async function verifyImap(cfg) {
+    const client = new ImapFlow({
+        host: cfg.host,
+        port: cfg.port,
+        secure: cfg.secure,
+        auth: { user: cfg.user, pass: cfg.pass },
+        logger: false,
+    });
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('timeout de conexion (' + VERIFY_TIMEOUT_MS / 1000 + 's)')), VERIFY_TIMEOUT_MS);
+    });
+    try {
+        await Promise.race([client.connect(), timeout]);
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: shortError(err) };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        /* logout() can hang on a half-open connection (e.g. after the race
+         * timed out while connect() was still pending), so bound it and then
+         * destroy the socket unconditionally -- same hard cap SMTP gets via
+         * its socketTimeout. */
+        try {
+            await Promise.race([
+                client.logout(),
+                new Promise((resolve) => setTimeout(resolve, 2000)),
+            ]);
+        }
+        catch { /* ignore */ }
+        try {
+            client.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+export function registerSettingsRoutes(app) {
+    app.get('/api/email/autoconfig', async (req, res) => {
+        const email = typeof req.query['email'] === 'string' ? req.query['email'] : '';
+        const result = await autoconfigure(email);
+        if (!result.ok) {
+            res.status(422).json(result);
+            return;
+        }
+        res.json(result);
+    });
+    app.post('/api/email/verify', async (req, res) => {
+        const body = req.body;
+        const [imapCfg, smtpCfg] = await Promise.all([
+            effectiveConfig('imap', body?.imap),
+            effectiveConfig('smtp', body?.smtp),
+        ]);
+        const [imap, smtp] = await Promise.all([
+            imapCfg ? verifyImap(imapCfg) : Promise.resolve({ ok: false, error: 'IMAP sin configurar' }),
+            smtpCfg ? verifySmtp(smtpCfg) : Promise.resolve({ ok: false, error: 'SMTP sin configurar' }),
+        ]);
+        res.json({ ok: imap.ok && smtp.ok, imap, smtp });
+    });
+}

package/server-dist/routes/signature.js

@@ -0,0 +1,31 @@
+import { hasSignature, saveSignature, readSignaturePngBase64, deleteSignature } from '../signature.js';
+export function registerSignatureRoutes(app) {
+    app.get('/api/signature', async (_req, res) => {
+        if (!hasSignature()) {
+            res.json({ ok: true, exists: false });
+            return;
+        }
+        const png = await readSignaturePngBase64();
+        res.json({ ok: true, exists: true, png_b64: png });
+    });
+    app.put('/api/signature', async (req, res) => {
+        const body = req.body;
+        const pngB64 = typeof body?.png_b64 === 'string' ? body.png_b64 : '';
+        if (pngB64.length === 0) {
+            res.status(400).json({ ok: false, error: 'png_b64 required' });
+            return;
+        }
+        try {
+            await saveSignature(pngB64);
+        }
+        catch (err) {
+            res.status(400).json({ ok: false, error: err instanceof Error ? err.message : String(err) });
+            return;
+        }
+        res.status(204).end();
+    });
+    app.delete('/api/signature', async (_req, res) => {
+        const ok = await deleteSignature();
+        res.status(ok ? 204 : 404).end();
+    });
+}

package/server-dist/routes/vault.js

@@ -0,0 +1,35 @@
+import { getAllKeys, getCategoryStatus, setKey, deleteKey, isValidVaultKey, passphraseSource } from '../vault.js';
+export function registerVaultRoutes(app) {
+    app.get('/api/vault/keys', async (_req, res) => {
+        const keys = await getAllKeys();
+        res.json({ ok: true, keys });
+    });
+    app.get('/api/vault/status', async (_req, res) => {
+        const status = await getCategoryStatus();
+        res.json({ ok: true, status, key_source: passphraseSource() });
+    });
+    app.put('/api/vault/key', async (req, res) => {
+        const body = req.body;
+        const name = typeof body?.name === 'string' ? body.name : '';
+        const value = typeof body?.value === 'string' ? body.value : '';
+        if (!isValidVaultKey(name)) {
+            res.status(400).json({ ok: false, error: 'unknown vault key: ' + name });
+            return;
+        }
+        if (value.length === 0) {
+            res.status(400).json({ ok: false, error: 'value cannot be empty' });
+            return;
+        }
+        await setKey(name, value);
+        res.status(204).end();
+    });
+    app.delete('/api/vault/key/:name', async (req, res) => {
+        const name = req.params['name'] ?? '';
+        if (!isValidVaultKey(name)) {
+            res.status(400).json({ ok: false, error: 'unknown vault key: ' + name });
+            return;
+        }
+        const ok = await deleteKey(name);
+        res.status(ok ? 204 : 404).end();
+    });
+}

package/server-dist/signature.js

@@ -0,0 +1,54 @@
+/**
+ * Yuemail signature store (F4).
+ *
+ * Single saved signature PNG at ~/.yuemail/signatures/default.png.
+ * The frontend POSTs a base64 PNG; we decode and write. GET returns
+ * the bytes; HEAD returns 200 / 404 for existence checks.
+ *
+ * ASCII-only.
+ */
+import { promises as fs, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+function homeDir() {
+    const env = process.env['YUEMAIL_HOME'];
+    return env ? path.resolve(env) : path.join(os.homedir(), '.yuemail');
+}
+function sigDir() { return path.join(homeDir(), 'signatures'); }
+function sigFile() { return path.join(sigDir(), 'default.png'); }
+function ensureSigDir() {
+    const d = sigDir();
+    if (!existsSync(d)) {
+        mkdirSync(d, { recursive: true, mode: 0o700 });
+    }
+}
+export function signaturePath() {
+    return sigFile();
+}
+export function hasSignature() {
+    return existsSync(sigFile());
+}
+export async function saveSignature(pngBase64) {
+    ensureSigDir();
+    const png = Buffer.from(pngBase64, 'base64');
+    if (png.length < 8) {
+        throw new Error('signature PNG too small');
+    }
+    /* PNG magic: 89 50 4E 47 0D 0A 1A 0A. */
+    if (png[0] !== 0x89 || png[1] !== 0x50 || png[2] !== 0x4e || png[3] !== 0x47) {
+        throw new Error('not a PNG');
+    }
+    await fs.writeFile(sigFile(), png, { mode: 0o600 });
+}
+export async function readSignaturePngBase64() {
+    if (!existsSync(sigFile()))
+        return undefined;
+    const buf = await fs.readFile(sigFile());
+    return buf.toString('base64');
+}
+export async function deleteSignature() {
+    if (!existsSync(sigFile()))
+        return false;
+    await fs.unlink(sigFile());
+    return true;
+}

package/server-dist/vault.js

@@ -0,0 +1,202 @@
+/**
+ * Yuemail BYOK vault (F8 / acceptance #8).
+ *
+ * AES-256-GCM, scrypt-derived key from (passphrase, per-machine salt).
+ *
+ * Storage layout:
+ *   ~/.yuemail/vault.salt     -- 32 random bytes, written once at first launch.
+ *   ~/.yuemail/vault.json     -- map of key-name to {iv, ciphertext, tag}.
+ *
+ * The vault JSON file never contains plaintext values of any secret.
+ * Each stored value is encrypted independently with a fresh IV.
+ *
+ * Passphrase resolution order:
+ *   1. env YUEMAIL_VAULT_PASS
+ *   2. fallback: 'yuemail/' + os.hostname() + '/' + username
+ *
+ * Threat-model honesty: the fallback passphrase is PREDICTABLE. It
+ * protects against exfiltration of the vault files alone (backup leak,
+ * synced folder), but a local attacker who can read the files can also
+ * read hostname + username and re-derive the key. Real at-rest secrecy
+ * against local readers requires YUEMAIL_VAULT_PASS. The UI surfaces
+ * this via key_source ('env' | 'derived') in /api/vault/status.
+ *
+ * Public surface:
+ *   - getAllKeys(): list configured key names (no values).
+ *   - getCategoryStatus(): per-category configured-booleans for the UI.
+ *   - setKey(name, value): encrypt + persist.
+ *   - getKey(name): decrypt + return (server-internal use only).
+ *   - deleteKey(name): remove the row.
+ *   - clearAll(): reset (test helpers).
+ *
+ * The `/api/vault/...` HTTP routes expose getAllKeys + getCategoryStatus +
+ * setKey + deleteKey. They never expose getKey -- decrypted values stay
+ * inside the server process.
+ *
+ * ASCII-only.
+ */
+import { randomBytes, scryptSync, createCipheriv, createDecipheriv, } from 'node:crypto';
+import { promises as fs, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+/* Paths are resolved lazily so tests can swap YUEMAIL_HOME per test
+ * without bumping a module-level constant frozen at import time. */
+function homeDir() {
+    const env = process.env['YUEMAIL_HOME'];
+    return env ? path.resolve(env) : path.join(os.homedir(), '.yuemail');
+}
+function saltFile() { return path.join(homeDir(), 'vault.salt'); }
+function vaultFile() { return path.join(homeDir(), 'vault.json'); }
+const SCRYPT_N = 16384;
+const SCRYPT_R = 8;
+const SCRYPT_P = 1;
+const SCRYPT_KEYLEN = 32;
+const IV_BYTES = 12;
+export const VAULT_KEYS = [
+    'imap.host',
+    'imap.port',
+    'imap.user',
+    'imap.pass',
+    'imap.secure',
+    'smtp.host',
+    'smtp.port',
+    'smtp.user',
+    'smtp.pass',
+    'smtp.secure',
+    'identity.from',
+    'identity.name',
+];
+export function isValidVaultKey(name) {
+    return VAULT_KEYS.includes(name);
+}
+function ensureHomeDir() {
+    if (!existsSync(homeDir())) {
+        mkdirSync(homeDir(), { recursive: true, mode: 0o700 });
+    }
+}
+async function getOrCreateSalt() {
+    ensureHomeDir();
+    if (existsSync(saltFile())) {
+        return fs.readFile(saltFile());
+    }
+    const salt = randomBytes(32);
+    await fs.writeFile(saltFile(), salt, { mode: 0o600 });
+    return salt;
+}
+/** Where the vault key comes from: a user-provided secret or the
+ * predictable machine-derived fallback. Exposed so the UI can warn. */
+export function passphraseSource() {
+    const envPass = process.env['YUEMAIL_VAULT_PASS'];
+    return envPass && envPass.length > 0 ? 'env' : 'derived';
+}
+function resolvePassphrase() {
+    const envPass = process.env['YUEMAIL_VAULT_PASS'];
+    if (envPass && envPass.length > 0)
+        return envPass;
+    let userName = 'user';
+    try {
+        userName = os.userInfo().username;
+    }
+    catch { /* keep fallback */ }
+    return 'yuemail/' + os.hostname() + '/' + userName;
+}
+async function deriveKey() {
+    const salt = await getOrCreateSalt();
+    const pass = resolvePassphrase();
+    return scryptSync(pass, salt, SCRYPT_KEYLEN, {
+        N: SCRYPT_N,
+        r: SCRYPT_R,
+        p: SCRYPT_P,
+    });
+}
+async function readVaultFile() {
+    if (!existsSync(vaultFile()))
+        return {};
+    try {
+        const raw = await fs.readFile(vaultFile(), 'utf-8');
+        if (raw.trim().length === 0)
+            return {};
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function writeVaultFile(data) {
+    ensureHomeDir();
+    const payload = JSON.stringify(data, null, 2);
+    await fs.writeFile(vaultFile(), payload, { mode: 0o600 });
+}
+export async function setKey(name, value) {
+    if (!isValidVaultKey(name)) {
+        throw new Error('unknown vault key: ' + name);
+    }
+    const key = await deriveKey();
+    const iv = randomBytes(IV_BYTES);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const ct = Buffer.concat([cipher.update(value, 'utf-8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const data = await readVaultFile();
+    data[name] = {
+        iv: iv.toString('base64'),
+        ct: ct.toString('base64'),
+        tag: tag.toString('base64'),
+    };
+    await writeVaultFile(data);
+}
+export async function getKey(name) {
+    const data = await readVaultFile();
+    const row = data[name];
+    if (!row)
+        return undefined;
+    const key = await deriveKey();
+    const iv = Buffer.from(row.iv, 'base64');
+    const ct = Buffer.from(row.ct, 'base64');
+    const tag = Buffer.from(row.tag, 'base64');
+    const decipher = createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+    return pt.toString('utf-8');
+}
+export async function deleteKey(name) {
+    const data = await readVaultFile();
+    if (!(name in data))
+        return false;
+    delete data[name];
+    await writeVaultFile(data);
+    return true;
+}
+export async function getAllKeys() {
+    const data = await readVaultFile();
+    return Object.keys(data).sort();
+}
+const IMAP_KEYS = ['imap.host', 'imap.port', 'imap.user', 'imap.pass'];
+const SMTP_KEYS = ['smtp.host', 'smtp.port', 'smtp.user', 'smtp.pass'];
+const IDENTITY_KEYS = ['identity.from', 'identity.name'];
+export async function getCategoryStatus() {
+    const data = await readVaultFile();
+    const has = (k) => k in data;
+    const missing = (set) => set.filter((k) => !has(k));
+    return {
+        imap: { configured: IMAP_KEYS.every(has), missing: missing(IMAP_KEYS) },
+        smtp: { configured: SMTP_KEYS.every(has), missing: missing(SMTP_KEYS) },
+        identity: { configured: IDENTITY_KEYS.every(has), missing: missing(IDENTITY_KEYS) },
+    };
+}
+export async function smtpReady() {
+    const data = await readVaultFile();
+    return SMTP_KEYS.every((k) => k in data);
+}
+export async function clearAll() {
+    if (existsSync(vaultFile())) {
+        await fs.unlink(vaultFile());
+    }
+}
+export async function readRawVaultFile() {
+    if (!existsSync(vaultFile()))
+        return '';
+    return fs.readFile(vaultFile(), 'utf-8');
+}
+export function vaultPaths() {
+    return { home: homeDir(), salt: saltFile(), vault: vaultFile() };
+}