mail-viewer 1.0.0

package/bin/mail-viewer.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process')
+const electron = require('electron')
+const path = require('path')
+
+const proc = spawn(String(electron), [path.join(__dirname, '../out/main/index.js')], {
+  stdio: 'inherit',
+  windowsHide: false
+})
+
+proc.on('close', (code) => process.exit(code ?? 0))

package/out/main/index.js

@@ -0,0 +1,552 @@
+"use strict";
+const electron = require("electron");
+const path = require("path");
+const utils = require("@electron-toolkit/utils");
+const Database = require("better-sqlite3");
+const imapflow = require("imapflow");
+const mailparser = require("mailparser");
+const fs = require("fs");
+const XLSX = require("xlsx");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const XLSX__namespace = /* @__PURE__ */ _interopNamespaceDefault(XLSX);
+let db = null;
+function getDb() {
+  if (!db) {
+    const dbPath = process.env.SQLITE_PATH ?? path.join(electron.app.getPath("userData"), "mail-viewer.db");
+    db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+  }
+  return db;
+}
+function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS accounts (
+    id            INTEGER  PRIMARY KEY AUTOINCREMENT,
+    display_name  TEXT     NOT NULL,
+    email_address TEXT     NOT NULL UNIQUE,
+    imap_host     TEXT     NOT NULL,
+    imap_port     INTEGER  NOT NULL DEFAULT 993,
+    imap_secure   INTEGER  NOT NULL DEFAULT 1,
+    username      TEXT     NOT NULL,
+    password_enc  BLOB     NOT NULL,
+    unseen_count  INTEGER  NOT NULL DEFAULT 0,
+    created_at    TEXT     NOT NULL DEFAULT (datetime('now')),
+    updated_at    TEXT     NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_accounts_email  ON accounts(email_address);
+CREATE INDEX IF NOT EXISTS idx_accounts_unseen ON accounts(unseen_count DESC, display_name ASC);
+`;
+async function runMigrations() {
+  const db2 = getDb();
+  db2.exec(SCHEMA_SQL);
+  console.log("[migrations] Schema applied successfully");
+}
+function encryptPassword(plaintext) {
+  if (!electron.safeStorage.isEncryptionAvailable()) {
+    throw new Error("safeStorage encryption is not available on this system");
+  }
+  return electron.safeStorage.encryptString(plaintext);
+}
+function decryptPassword(encrypted) {
+  if (!electron.safeStorage.isEncryptionAvailable()) {
+    throw new Error("safeStorage encryption is not available on this system");
+  }
+  return electron.safeStorage.decryptString(encrypted);
+}
+const connections = /* @__PURE__ */ new Map();
+function getAccountCredentials(accountId) {
+  const row = getDb().prepare("SELECT imap_host, imap_port, imap_secure, username, password_enc FROM accounts WHERE id = ?").get(accountId);
+  if (!row) throw new Error(`Account ${accountId} not found`);
+  return {
+    host: row.imap_host,
+    port: row.imap_port,
+    secure: Boolean(row.imap_secure),
+    auth: {
+      user: row.username,
+      pass: decryptPassword(row.password_enc)
+    },
+    logger: false
+  };
+}
+async function getConnection(accountId) {
+  let client = connections.get(accountId);
+  if (client && client.usable) {
+    return client;
+  }
+  if (client) {
+    try {
+      await client.logout();
+    } catch {
+    }
+    connections.delete(accountId);
+  }
+  const options = getAccountCredentials(accountId);
+  client = new imapflow.ImapFlow(options);
+  client.on("close", () => {
+    connections.delete(accountId);
+  });
+  client.on("error", (err) => {
+    console.error(`[IMAP] Account ${accountId} error:`, err.message);
+    connections.delete(accountId);
+  });
+  await client.connect();
+  connections.set(accountId, client);
+  return client;
+}
+async function closeConnection(accountId) {
+  const client = connections.get(accountId);
+  if (client) {
+    try {
+      await client.logout();
+    } catch {
+    }
+    connections.delete(accountId);
+  }
+}
+async function closeAllConnections() {
+  const ids = Array.from(connections.keys());
+  await Promise.allSettled(ids.map((id) => closeConnection(id)));
+}
+async function testConnection(options) {
+  const client = new imapflow.ImapFlow({ ...options, logger: false });
+  await client.connect();
+  await client.logout();
+}
+const UNSEEN_CONCURRENCY = 20;
+async function runWithConcurrency(ids, concurrency, fn) {
+  let index = 0;
+  async function worker() {
+    while (index < ids.length) {
+      const id = ids[index++];
+      await fn(id);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, ids.length) }, worker));
+}
+function rowToAccount(row) {
+  return {
+    id: row.id,
+    displayName: row.display_name,
+    emailAddress: row.email_address,
+    imapHost: row.imap_host,
+    imapPort: row.imap_port,
+    imapSecure: Boolean(row.imap_secure),
+    username: row.username,
+    unseenCount: row.unseen_count ?? 0,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function registerAccountHandlers() {
+  electron.ipcMain.handle("accounts:list", () => {
+    const db2 = getDb();
+    const rows = db2.prepare(
+      `SELECT id, display_name, email_address, imap_host, imap_port, imap_secure,
+              username, unseen_count, created_at, updated_at
+       FROM accounts ORDER BY unseen_count DESC, display_name ASC`
+    ).all();
+    return rows.map(rowToAccount);
+  });
+  electron.ipcMain.handle("accounts:create", (_event, input) => {
+    const db2 = getDb();
+    const passwordEnc = encryptPassword(input.password);
+    const row = db2.prepare(
+      `INSERT INTO accounts (display_name, email_address, imap_host, imap_port, imap_secure, username, password_enc)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       RETURNING id, display_name, email_address, imap_host, imap_port, imap_secure,
+                 username, unseen_count, created_at, updated_at`
+    ).get(
+      input.displayName,
+      input.emailAddress,
+      input.imapHost,
+      input.imapPort,
+      input.imapSecure ? 1 : 0,
+      input.username,
+      passwordEnc
+    );
+    return rowToAccount(row);
+  });
+  electron.ipcMain.handle(
+    "accounts:update",
+    async (_event, id, input) => {
+      const db2 = getDb();
+      const passwordEnc = encryptPassword(input.password);
+      const row = db2.prepare(
+        `UPDATE accounts
+         SET display_name = ?, email_address = ?, imap_host = ?, imap_port = ?,
+             imap_secure = ?, username = ?, password_enc = ?, updated_at = datetime('now')
+         WHERE id = ?
+         RETURNING id, display_name, email_address, imap_host, imap_port, imap_secure,
+                   username, unseen_count, created_at, updated_at`
+      ).get(
+        input.displayName,
+        input.emailAddress,
+        input.imapHost,
+        input.imapPort,
+        input.imapSecure ? 1 : 0,
+        input.username,
+        passwordEnc,
+        id
+      );
+      if (!row) throw new Error(`Account ${id} not found`);
+      await closeConnection(id);
+      return rowToAccount(row);
+    }
+  );
+  electron.ipcMain.handle("accounts:delete", async (_event, id) => {
+    await closeConnection(id);
+    getDb().prepare("DELETE FROM accounts WHERE id = ?").run(id);
+    return { success: true };
+  });
+  electron.ipcMain.handle("accounts:deleteAll", async () => {
+    await closeAllConnections();
+    const result = getDb().prepare("DELETE FROM accounts").run();
+    return { deleted: result.changes };
+  });
+  electron.ipcMain.handle(
+    "accounts:testConnection",
+    async (_event, input) => {
+      try {
+        await testConnection({
+          host: input.imapHost,
+          port: input.imapPort,
+          secure: input.imapSecure,
+          auth: { user: input.username, pass: input.password }
+        });
+        return { ok: true };
+      } catch (err) {
+        return { ok: false, error: err.message };
+      }
+    }
+  );
+  electron.ipcMain.handle("accounts:fetchUnseenCounts", async () => {
+    const db2 = getDb();
+    const ids = db2.prepare("SELECT id FROM accounts").all().map((r) => r.id);
+    const updateStmt = db2.prepare("UPDATE accounts SET unseen_count = ? WHERE id = ?");
+    let updated = 0;
+    await runWithConcurrency(ids, UNSEEN_CONCURRENCY, async (id) => {
+      try {
+        const client = await getConnection(id);
+        const status = await client.status("INBOX", { unseen: true });
+        updateStmt.run(status.unseen ?? 0, id);
+        updated++;
+      } catch (err) {
+        console.error(`[unseen] account ${id}:`, err.message);
+      }
+    });
+    return { updated };
+  });
+}
+async function listFolders(accountId) {
+  const client = await getConnection(accountId);
+  const lock = await client.getMailboxLock("INBOX");
+  try {
+    const rawList = await client.list();
+    return buildTree(rawList);
+  } finally {
+    lock.release();
+  }
+}
+function buildTree(flat) {
+  const map = /* @__PURE__ */ new Map();
+  const roots = [];
+  const sorted = [...flat].sort((a, b) => a.path.localeCompare(b.path));
+  for (const box of sorted) {
+    const entry = {
+      path: box.path,
+      name: box.name,
+      delimiter: box.delimiter,
+      flags: Array.from(box.flags),
+      specialUse: box.specialUse,
+      listed: box.listed,
+      subscribed: box.subscribed,
+      children: []
+    };
+    map.set(box.path, entry);
+    if (!box.delimiter) {
+      roots.push(entry);
+      continue;
+    }
+    const lastDelim = box.path.lastIndexOf(box.delimiter);
+    if (lastDelim === -1) {
+      roots.push(entry);
+    } else {
+      const parentPath = box.path.substring(0, lastDelim);
+      const parent = map.get(parentPath);
+      if (parent) {
+        parent.children = parent.children ?? [];
+        parent.children.push(entry);
+      } else {
+        roots.push(entry);
+      }
+    }
+  }
+  return roots;
+}
+function registerFolderHandlers() {
+  electron.ipcMain.handle("folders:list", async (_event, accountId) => {
+    return listFolders(accountId);
+  });
+}
+const PAGE_SIZE = 50;
+async function listMessages(accountId, folderPath, page) {
+  const client = await getConnection(accountId);
+  const lock = await client.getMailboxLock(folderPath);
+  try {
+    const mailbox = client.mailbox;
+    if (!mailbox || mailbox.exists === 0) return [];
+    const total = mailbox.exists;
+    const end = total - page * PAGE_SIZE;
+    if (end <= 0) return [];
+    const start = Math.max(1, end - PAGE_SIZE + 1);
+    const range = `${start}:${end}`;
+    const messages = [];
+    for await (const msg of client.fetch(range, {
+      uid: true,
+      flags: true,
+      envelope: true,
+      bodyStructure: true,
+      bodyParts: ["TEXT"]
+    })) {
+      const from = msg.envelope?.from?.[0];
+      const fromStr = from ? from.name ? `${from.name} <${from.address}>` : from.address ?? "" : "";
+      const flags = msg.flags ?? /* @__PURE__ */ new Set();
+      const seen = flags.has("\\Seen");
+      let hasAttachments = false;
+      if (msg.bodyStructure) {
+        hasAttachments = hasAttachmentParts(msg.bodyStructure);
+      }
+      const textPart = msg.bodyParts?.get("TEXT");
+      const preview = textPart ? textPart.toString("utf-8").replace(/\s+/g, " ").slice(0, 120) : "";
+      messages.push({
+        uid: msg.uid,
+        seq: msg.seq,
+        subject: msg.envelope?.subject ?? "(no subject)",
+        from: fromStr,
+        date: msg.envelope?.date?.toISOString() ?? "",
+        seen,
+        hasAttachments,
+        textPreview: preview
+      });
+    }
+    return messages.reverse();
+  } finally {
+    lock.release();
+  }
+}
+function hasAttachmentParts(structure) {
+  if (!structure) return false;
+  if (structure.disposition === "attachment") return true;
+  if (Array.isArray(structure.childNodes)) {
+    return structure.childNodes.some(hasAttachmentParts);
+  }
+  return false;
+}
+async function getMessage(accountId, folderPath, uid) {
+  const client = await getConnection(accountId);
+  const lock = await client.getMailboxLock(folderPath);
+  try {
+    let rawSource = null;
+    for await (const msg of client.fetch(
+      { uid },
+      { uid: true, source: true },
+      { uid: true }
+    )) {
+      rawSource = msg.source ?? null;
+    }
+    if (!rawSource) {
+      throw new Error(`Message UID ${uid} not found in ${folderPath}`);
+    }
+    const parsed = await mailparser.simpleParser(rawSource);
+    const fromAddr = parsed.from?.value?.[0];
+    const fromStr = fromAddr ? fromAddr.name ? `${fromAddr.name} <${fromAddr.address}>` : fromAddr.address ?? "" : "";
+    const toStr = (parsed.to ? Array.isArray(parsed.to) ? parsed.to.flatMap((a) => a.value).map((a) => a.name ? `${a.name} <${a.address}>` : a.address ?? "") : parsed.to.value.map((a) => a.name ? `${a.name} <${a.address}>` : a.address ?? "") : []).join(", ");
+    const ccStr = (parsed.cc ? Array.isArray(parsed.cc) ? parsed.cc.flatMap((a) => a.value).map((a) => a.name ? `${a.name} <${a.address}>` : a.address ?? "") : parsed.cc.value.map((a) => a.name ? `${a.name} <${a.address}>` : a.address ?? "") : []).join(", ");
+    const attachments = (parsed.attachments ?? []).map((att) => ({
+      filename: att.filename ?? "attachment",
+      contentType: att.contentType,
+      size: att.size ?? 0,
+      contentId: att.contentId ?? void 0
+    }));
+    return {
+      uid,
+      subject: parsed.subject ?? "(no subject)",
+      from: fromStr,
+      to: toStr,
+      cc: ccStr || void 0,
+      date: parsed.date?.toISOString() ?? "",
+      html: parsed.html || void 0,
+      text: parsed.text || void 0,
+      attachments
+    };
+  } finally {
+    lock.release();
+  }
+}
+function registerMessageHandlers() {
+  electron.ipcMain.handle(
+    "messages:list",
+    async (_event, accountId, folderPath, page) => {
+      return listMessages(accountId, folderPath, page);
+    }
+  );
+  electron.ipcMain.handle(
+    "messages:get",
+    async (_event, accountId, folderPath, uid) => {
+      return getMessage(accountId, folderPath, uid);
+    }
+  );
+}
+function registerImportHandlers() {
+  electron.ipcMain.handle("accounts:openXlsxFile", async () => {
+    const win = electron.BrowserWindow.getAllWindows()[0] ?? null;
+    const { canceled, filePaths } = await electron.dialog.showOpenDialog(win, {
+      title: "Select spreadsheet",
+      filters: [
+        { name: "Spreadsheets", extensions: ["xlsx", "xls", "csv"] },
+        { name: "All Files", extensions: ["*"] }
+      ],
+      properties: ["openFile"]
+    });
+    if (canceled || filePaths.length === 0) {
+      return { rows: [] };
+    }
+    const buffer = fs.readFileSync(filePaths[0]);
+    const workbook = XLSX__namespace.read(buffer, { type: "buffer" });
+    const sheetName = workbook.SheetNames[0];
+    const sheet = workbook.Sheets[sheetName];
+    const rows = XLSX__namespace.utils.sheet_to_json(sheet, {
+      header: 1,
+      defval: ""
+    });
+    return { rows };
+  });
+  electron.ipcMain.handle(
+    "accounts:importFromXlsx",
+    (_event, config) => {
+      const db2 = getDb();
+      const { rows, hasHeader, columns, imapSettings } = config;
+      const dataRows = hasHeader ? rows.slice(1) : rows;
+      const ready = [];
+      const errors = [];
+      for (let i = 0; i < dataRows.length; i++) {
+        const row = dataRows[i];
+        const rowNumber = hasHeader ? i + 2 : i + 1;
+        const username = (row[columns.username] ?? "").trim();
+        const password = (row[columns.password] ?? "").trim();
+        if (!username || !password) {
+          errors.push({ row: rowNumber, message: "Username or password is blank" });
+          continue;
+        }
+        const displayName = columns.displayName !== void 0 ? (row[columns.displayName] ?? "").trim() || username : username;
+        const emailAddress = columns.emailAddress !== void 0 ? (row[columns.emailAddress] ?? "").trim() || username : username;
+        ready.push({ rowNumber, displayName, emailAddress, username, passwordEnc: encryptPassword(password) });
+      }
+      const stmt = db2.prepare(
+        `INSERT INTO accounts (display_name, email_address, imap_host, imap_port, imap_secure, username, password_enc)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (email_address) DO NOTHING`
+      );
+      const imapSecureInt = imapSettings.imapSecure ? 1 : 0;
+      let imported = 0;
+      const runAll = db2.transaction((readyRows) => {
+        for (const r of readyRows) {
+          try {
+            const result = stmt.run(
+              r.displayName,
+              r.emailAddress,
+              imapSettings.imapHost,
+              imapSettings.imapPort,
+              imapSecureInt,
+              r.username,
+              r.passwordEnc
+            );
+            imported += result.changes;
+          } catch (err) {
+            errors.push({ row: r.rowNumber, message: err.message });
+          }
+        }
+      });
+      runAll(ready);
+      return { imported, errors };
+    }
+  );
+}
+function createWindow() {
+  const mainWindow = new electron.BrowserWindow({
+    width: 1280,
+    height: 800,
+    minWidth: 900,
+    minHeight: 600,
+    show: false,
+    autoHideMenuBar: true,
+    titleBarStyle: process.platform === "darwin" ? "hiddenInset" : "default",
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: false,
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  mainWindow.on("ready-to-show", () => {
+    mainWindow.show();
+  });
+  mainWindow.webContents.setWindowOpenHandler((details) => {
+    electron.shell.openExternal(details.url);
+    return { action: "deny" };
+  });
+  if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
+    mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  return mainWindow;
+}
+electron.app.whenReady().then(async () => {
+  utils.electronApp.setAppUserModelId("com.mailviewer.app");
+  electron.app.on("browser-window-created", (_, window) => {
+    utils.optimizer.watchWindowShortcuts(window);
+  });
+  try {
+    await runMigrations();
+  } catch (err) {
+    console.error("[main] Failed to run migrations:", err);
+  }
+  registerAccountHandlers();
+  registerFolderHandlers();
+  registerMessageHandlers();
+  registerImportHandlers();
+  createWindow();
+  electron.app.on("activate", function() {
+    if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+electron.app.on("window-all-closed", async () => {
+  await closeAllConnections();
+  closeDb();
+  if (process.platform !== "darwin") {
+    electron.app.quit();
+  }
+});

package/out/preload/index.js

@@ -0,0 +1,36 @@
+"use strict";
+const electron = require("electron");
+const preload = require("@electron-toolkit/preload");
+const api = {
+  accounts: {
+    list: () => electron.ipcRenderer.invoke("accounts:list"),
+    create: (input) => electron.ipcRenderer.invoke("accounts:create", input),
+    update: (id, input) => electron.ipcRenderer.invoke("accounts:update", id, input),
+    delete: (id) => electron.ipcRenderer.invoke("accounts:delete", id),
+    testConnection: (input) => electron.ipcRenderer.invoke("accounts:testConnection", input),
+    fetchUnseenCounts: () => electron.ipcRenderer.invoke("accounts:fetchUnseenCounts"),
+    deleteAll: () => electron.ipcRenderer.invoke("accounts:deleteAll")
+  },
+  folders: {
+    list: (accountId) => electron.ipcRenderer.invoke("folders:list", accountId)
+  },
+  messages: {
+    list: (accountId, folderPath, page) => electron.ipcRenderer.invoke("messages:list", accountId, folderPath, page),
+    get: (accountId, folderPath, uid) => electron.ipcRenderer.invoke("messages:get", accountId, folderPath, uid)
+  },
+  import: {
+    openXlsxFile: () => electron.ipcRenderer.invoke("accounts:openXlsxFile"),
+    importFromXlsx: (config) => electron.ipcRenderer.invoke("accounts:importFromXlsx", config)
+  }
+};
+if (process.contextIsolated) {
+  try {
+    electron.contextBridge.exposeInMainWorld("electron", preload.electronAPI);
+    electron.contextBridge.exposeInMainWorld("api", api);
+  } catch (error) {
+    console.error(error);
+  }
+} else {
+  window.electron = preload.electronAPI;
+  window.api = api;
+}