@lengelhard/imap-email-mcp 1.5.0 → 1.7.0

package/lib/local-index.js

@@ -0,0 +1,484 @@
+/**
+ * Local read-only full-text index for imap-email-mcp.
+ *
+ * Mirrors the text of your mail into a local SQLite FTS5 database so content
+ * searches do not depend on the IMAP server's body search.
+ *
+ * Read-only by design: the indexer only uses EXAMINE and BODY.PEEK, so it never
+ * changes flags, never moves or deletes mail, and never appends. Message
+ * content never changes for a given UID, so sync is a set difference: index
+ * UIDs the server has and we lack, drop UIDs we have and the server lost
+ * (moved or deleted), and wipe a folder when its UIDVALIDITY changes.
+ *
+ * Requires Node's built-in node:sqlite (Node 22.13+ / 23.4+ / 24+).
+ *
+ * @license MIT
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import { SessionManager, openBox, fetchMessages, headerOf, localDate } from './imap-session.js';
+import { planParts, partsToText } from './mime-text.js';
+
+const SCHEMA_VERSION = '1';
+const HEADER_FIELDS = 'HEADER.FIELDS (FROM TO CC SUBJECT DATE MESSAGE-ID)';
+const DEFAULT_EXCLUDE = ['trash', 'junk', 'spam', 'deleted items', 'deleted messages', 'bin'];
+const SPECIAL_EXCLUDE = ['\\trash', '\\junk'];
+
+async function loadSqlite() {
+  const original = process.emitWarning;
+  process.emitWarning = function (warning, ...rest) {
+    if (String(warning && warning.message ? warning.message : warning).includes('SQLite is an experimental')) return;
+    return original.call(process, warning, ...rest);
+  };
+  try {
+    const mod = await import('node:sqlite');
+    return mod.DatabaseSync;
+  } finally {
+    process.emitWarning = original;
+  }
+}
+
+export function defaultDbPath(user, host) {
+  const id = crypto.createHash('sha1').update(`${user}@${host}`).digest('hex').slice(0, 12);
+  const base = process.platform === 'darwin'
+    ? path.join(os.homedir(), 'Library', 'Application Support', 'imap-email-mcp')
+    : path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), 'imap-email-mcp');
+  return path.join(base, `index-${id}.sqlite`);
+}
+
+function flattenBoxes(boxes, prefix = '', out = []) {
+  for (const [name, box] of Object.entries(boxes || {})) {
+    const full = prefix ? `${prefix}${box.delimiter || '/'}${name}` : name;
+    const attribs = (box.attribs || []).map((a) => String(a).toLowerCase());
+    if (box.special_use_attrib) attribs.push(String(box.special_use_attrib).toLowerCase());
+    out.push({ name: full, attribs });
+    if (box.children) flattenBoxes(box.children, full, out);
+  }
+  return out;
+}
+
+function addressText(values) {
+  return (values || []).join(', ');
+}
+
+function ftsQuery(query, { match = 'all', prefix = false, field = 'any' } = {}) {
+  const q = String(query || '').trim();
+  if (!q) throw new Error('query is required');
+  const quote = (s) => `"${s.replace(/"/g, '""')}"`;
+  let expr;
+  if (match === 'phrase') {
+    expr = quote(q) + (prefix ? '*' : '');
+  } else {
+    const tokens = q.split(/\s+/).filter(Boolean).map((t) => quote(t) + (prefix ? '*' : ''));
+    expr = tokens.join(match === 'any' ? ' OR ' : ' AND ');
+  }
+  const columns = { subject: 'subject', from: 'from_addr', to: 'to_addr', attachments: 'attachments', body: 'body' };
+  if (field && field !== 'any') {
+    const col = columns[field];
+    if (!col) throw new Error(`Unknown field: ${field}`);
+    expr = `${col} : (${expr})`;
+  }
+  return expr;
+}
+
+export class LocalIndex {
+  constructor({ imapConfig, dbPath, folders = null, excludeFolders = [], intervalMinutes = 5, batchSize = 100, maxBodyChars = 100000, log = console.error }) {
+    this.imapConfig = imapConfig;
+    this.dbPath = dbPath || defaultDbPath(imapConfig.imap.user, imapConfig.imap.host);
+    this.folders = folders && folders.length ? folders : null;
+    this.excludeFolders = excludeFolders.map((f) => f.toLowerCase());
+    this.intervalMs = Math.max(1, intervalMinutes) * 60 * 1000;
+    this.batchSize = batchSize;
+    this.maxBodyChars = maxBodyChars;
+    this.log = log;
+    this.db = null;
+    this.running = null;
+    this.timer = null;
+    this.debounce = null;
+    this.pendingFolders = new Set();
+    this.lastRun = null;
+    this.session = new SessionManager(imapConfig, { label: 'index', idleCloseMs: 60 * 1000, leaseTimeoutMs: 10 * 60 * 1000, log });
+  }
+
+  async open() {
+    const DatabaseSync = await loadSqlite();
+    fs.mkdirSync(path.dirname(this.dbPath), { recursive: true, mode: 0o700 });
+    this.db = new DatabaseSync(this.dbPath);
+    for (const suffix of ['', '-wal', '-shm']) {
+      try { fs.chmodSync(this.dbPath + suffix, 0o600); } catch { /* may not exist yet */ }
+    }
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+      CREATE TABLE IF NOT EXISTS folders (
+        name TEXT PRIMARY KEY,
+        uidvalidity INTEGER,
+        server_count INTEGER,
+        indexed_count INTEGER,
+        backfill_complete INTEGER DEFAULT 0,
+        last_sync INTEGER,
+        last_error TEXT
+      );
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY,
+        folder TEXT NOT NULL,
+        uid INTEGER NOT NULL,
+        uidvalidity INTEGER NOT NULL,
+        internal_date INTEGER,
+        sent_date TEXT,
+        from_addr TEXT,
+        to_addr TEXT,
+        cc_addr TEXT,
+        subject TEXT,
+        message_id TEXT,
+        size INTEGER,
+        attachments TEXT,
+        body_chars INTEGER,
+        UNIQUE (folder, uid)
+      );
+      CREATE INDEX IF NOT EXISTS messages_date ON messages (internal_date);
+      CREATE INDEX IF NOT EXISTS messages_folder_date ON messages (folder, internal_date);
+      CREATE VIRTUAL TABLE IF NOT EXISTS fts USING fts5 (
+        subject, from_addr, to_addr, attachments, body,
+        tokenize = 'unicode61 remove_diacritics 2'
+      );
+    `);
+    const version = this.db.prepare('SELECT value FROM meta WHERE key = ?').get('schema_version');
+    if (!version) this.db.prepare('INSERT INTO meta (key, value) VALUES (?, ?)').run('schema_version', SCHEMA_VERSION);
+    return this;
+  }
+
+  start() {
+    const kick = () => this.sync().catch((err) => this.log(`[index] sync failed: ${err.message}`));
+    const first = setTimeout(kick, 5000);
+    if (first.unref) first.unref();
+    this.timer = setInterval(kick, this.intervalMs);
+    if (this.timer.unref) this.timer.unref();
+  }
+
+  stop() {
+    clearInterval(this.timer);
+    clearTimeout(this.debounce);
+    this.session.close();
+    try { this.db?.close(); } catch { /* ignore */ }
+  }
+
+  /** Ask for a near-term incremental sync of specific folders (after moves or deletes). */
+  requestSync(folders = []) {
+    for (const f of folders) if (f) this.pendingFolders.add(f);
+    clearTimeout(this.debounce);
+    this.debounce = setTimeout(() => {
+      const list = [...this.pendingFolders];
+      this.pendingFolders.clear();
+      if (this.running) return; // the running sync or the next scheduled one will catch up
+      this.sync({ folders: list, maxPerFolder: 500, passes: 1 }).catch((err) => this.log(`[index] sync failed: ${err.message}`));
+    }, 3000);
+    if (this.debounce.unref) this.debounce.unref();
+  }
+
+  async _targetFolders(connection) {
+    const boxes = flattenBoxes(await connection.getBoxes());
+    const selectable = boxes.filter((b) => !b.attribs.includes('\\noselect') && !b.attribs.includes('\\nonexistent'));
+    if (this.folders) {
+      const wanted = new Set(this.folders.map((f) => f.toLowerCase()));
+      return selectable.filter((b) => wanted.has(b.name.toLowerCase())).map((b) => b.name);
+    }
+    return selectable
+      .filter((b) => !b.attribs.some((a) => SPECIAL_EXCLUDE.includes(a)))
+      .filter((b) => {
+        const leaf = b.name.split(/[/.]/).pop().toLowerCase();
+        return !DEFAULT_EXCLUDE.includes(leaf) && !this.excludeFolders.includes(b.name.toLowerCase());
+      })
+      .map((b) => b.name);
+  }
+
+  /**
+   * Run a sync. Single-flight: concurrent callers share the running sync.
+   * maxPerFolder caps new messages per folder per pass; passes caps the loop.
+   */
+  sync({ folders = null, maxPerFolder = 1000, passes = Infinity } = {}) {
+    if (this.running) return this.running;
+    this.running = this._sync({ folders, maxPerFolder, passes }).finally(() => { this.running = null; });
+    return this.running;
+  }
+
+  async _sync({ folders, maxPerFolder, passes }) {
+    const started = Date.now();
+    const summary = { added: 0, removed: 0, folders: {} };
+    let targets;
+    {
+      const conn = await this.session.acquire();
+      try {
+        const all = await this._targetFolders(conn);
+        targets = folders ? all.filter((f) => folders.includes(f)) : all;
+        if (!folders) this._dropUntracked(all);
+      } finally {
+        conn.end();
+      }
+    }
+
+    let pass = 0;
+    let remaining = new Set(targets);
+    while (remaining.size && pass < passes) {
+      pass++;
+      for (const folder of [...remaining]) {
+        try {
+          const r = await this._syncFolder(folder, maxPerFolder);
+          summary.added += r.added;
+          summary.removed += r.removed;
+          const s = summary.folders[folder] || { added: 0, removed: 0 };
+          s.added += r.added;
+          s.removed += r.removed;
+          s.pending = r.pending;
+          summary.folders[folder] = s;
+          if (r.pending === 0) {
+            remaining.delete(folder);
+          } else if (r.attempted > 0 && r.added === 0) {
+            // The server lists these UIDs but returns nothing for them. Stop
+            // this run instead of looping; the next scheduled sync retries.
+            remaining.delete(folder);
+            this.log(`[index] ${folder}: ${r.attempted} messages could not be fetched, will retry next sync`);
+          }
+        } catch (err) {
+          remaining.delete(folder);
+          this.log(`[index] ${folder}: ${err.message}`);
+          this.db.prepare(`INSERT INTO folders (name, last_error, last_sync) VALUES (?, ?, ?)
+            ON CONFLICT(name) DO UPDATE SET last_error = excluded.last_error, last_sync = excluded.last_sync`)
+            .run(folder, String(err.message).slice(0, 500), Date.now());
+          summary.folders[folder] = { error: err.message };
+        }
+      }
+    }
+    summary.duration_ms = Date.now() - started;
+    this.lastRun = { finished: Date.now(), ...summary };
+    return summary;
+  }
+
+  _dropUntracked(serverFolders) {
+    const keep = new Set(serverFolders);
+    const tracked = this.db.prepare('SELECT DISTINCT folder FROM messages').all().map((r) => r.folder);
+    for (const f of tracked) if (!keep.has(f)) this._wipeFolder(f);
+    for (const r of this.db.prepare('SELECT name FROM folders').all()) {
+      if (!keep.has(r.name)) this.db.prepare('DELETE FROM folders WHERE name = ?').run(r.name);
+    }
+  }
+
+  _wipeFolder(folder) {
+    this.db.exec('BEGIN');
+    try {
+      this.db.prepare('DELETE FROM fts WHERE rowid IN (SELECT id FROM messages WHERE folder = ?)').run(folder);
+      this.db.prepare('DELETE FROM messages WHERE folder = ?').run(folder);
+      this.db.exec('COMMIT');
+    } catch (err) {
+      this.db.exec('ROLLBACK');
+      throw err;
+    }
+  }
+
+  async _syncFolder(folder, maxPerFolder) {
+    const conn = await this.session.acquire();
+    try {
+      const box = await openBox(conn, folder, true);
+      const uidvalidity = Number(box.uidvalidity);
+      const row = this.db.prepare('SELECT uidvalidity FROM folders WHERE name = ?').get(folder);
+      if (row && row.uidvalidity != null && Number(row.uidvalidity) !== uidvalidity) {
+        this.log(`[index] ${folder}: UIDVALIDITY changed, re-indexing`);
+        this._wipeFolder(folder);
+      }
+
+      const serverUids = box.messages.total
+        ? await new Promise((resolve, reject) => {
+          try { conn.imap.search(['ALL'], (e, u) => (e ? reject(e) : resolve((u || []).map(Number)))); } catch (e) { reject(e); }
+        })
+        : [];
+      const serverSet = new Set(serverUids);
+      const local = this.db.prepare('SELECT id, uid FROM messages WHERE folder = ?').all(folder);
+      const localSet = new Set(local.map((r) => Number(r.uid)));
+
+      const vanished = local.filter((r) => !serverSet.has(Number(r.uid)));
+      if (vanished.length) {
+        this.db.exec('BEGIN');
+        try {
+          const delFts = this.db.prepare('DELETE FROM fts WHERE rowid = ?');
+          const delMsg = this.db.prepare('DELETE FROM messages WHERE id = ?');
+          for (const r of vanished) { delFts.run(r.id); delMsg.run(r.id); }
+          this.db.exec('COMMIT');
+        } catch (err) {
+          this.db.exec('ROLLBACK');
+          throw err;
+        }
+      }
+
+      const missing = serverUids.filter((u) => !localSet.has(u)).sort((a, b) => b - a);
+      const todo = missing.slice(0, maxPerFolder);
+      let added = 0;
+      for (let i = 0; i < todo.length; i += this.batchSize) {
+        added += await this._indexBatch(conn, folder, uidvalidity, todo.slice(i, i + this.batchSize));
+      }
+
+      const pending = missing.length - todo.length;
+      const indexed = this.db.prepare('SELECT count(*) AS n FROM messages WHERE folder = ?').get(folder).n;
+      this.db.prepare(`INSERT INTO folders (name, uidvalidity, server_count, indexed_count, backfill_complete, last_sync, last_error)
+        VALUES (?, ?, ?, ?, ?, ?, NULL)
+        ON CONFLICT(name) DO UPDATE SET uidvalidity = excluded.uidvalidity, server_count = excluded.server_count,
+          indexed_count = excluded.indexed_count, backfill_complete = excluded.backfill_complete,
+          last_sync = excluded.last_sync, last_error = NULL`)
+        .run(folder, uidvalidity, serverUids.length, indexed, pending === 0 ? 1 : 0, Date.now());
+      return { added, removed: vanished.length, pending, attempted: todo.length };
+    } finally {
+      conn.end();
+    }
+  }
+
+  async _indexBatch(conn, folder, uidvalidity, uids) {
+    const meta = await fetchMessages(conn, uids, { bodies: [HEADER_FIELDS], struct: true, size: true });
+    const parseHeader = conn.imap.constructor.parseHeader;
+
+    // Group messages by the exact set of text parts they need, so each group
+    // is one FETCH. Most messages share part "1" or "1.1".
+    const plans = new Map();
+    const groups = new Map();
+    for (const [uid, rec] of meta) {
+      const plan = planParts(rec.attributes.struct || []);
+      plans.set(uid, plan);
+      if (!plan.parts.length) continue;
+      const key = plan.parts.map((p) => p.partID).join(',');
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key).push(uid);
+    }
+    const bodies = new Map();
+    for (const [key, groupUids] of groups) {
+      const fetched = await fetchMessages(conn, groupUids, { bodies: key.split(',') });
+      for (const [uid, rec] of fetched) bodies.set(uid, rec.parts);
+    }
+
+    const insMsg = this.db.prepare(`INSERT OR IGNORE INTO messages
+      (folder, uid, uidvalidity, internal_date, sent_date, from_addr, to_addr, cc_addr, subject, message_id, size, attachments, body_chars)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const insFts = this.db.prepare('INSERT INTO fts (rowid, subject, from_addr, to_addr, attachments, body) VALUES (?, ?, ?, ?, ?, ?)');
+
+    let added = 0;
+    this.db.exec('BEGIN');
+    try {
+      for (const [uid, rec] of meta) {
+        const h = headerOf(rec, parseHeader);
+        const plan = plans.get(uid);
+        let body = '';
+        try {
+          body = partsToText(plan, bodies.get(uid) || {});
+        } catch (err) {
+          this.log(`[index] ${folder} uid ${uid}: body decode failed: ${err.message}`);
+        }
+        if (body.length > this.maxBodyChars) body = body.slice(0, this.maxBodyChars);
+        const from = addressText(h.from);
+        const to = addressText([...(h.to || []), ...(h.cc || [])]);
+        const subject = (h.subject || [''])[0];
+        const attachments = plan.attachments.join(', ');
+        const internal = rec.attributes.date instanceof Date ? rec.attributes.date.getTime() : null;
+        const res = insMsg.run(folder, uid, uidvalidity, internal, (h.date || [null])[0], from, addressText(h.to), addressText(h.cc),
+          subject, (h['message-id'] || [null])[0], rec.attributes.size ?? null, attachments, body.length);
+        if (res.changes) {
+          insFts.run(Number(res.lastInsertRowid), subject, from, to, attachments, body);
+          added++;
+        }
+      }
+      this.db.exec('COMMIT');
+    } catch (err) {
+      this.db.exec('ROLLBACK');
+      throw err;
+    }
+    return added;
+  }
+
+  status() {
+    const folders = this.db.prepare('SELECT * FROM folders ORDER BY name').all().map((r) => ({
+      folder: r.name,
+      server_count: r.server_count,
+      indexed_count: r.indexed_count,
+      complete: !!r.backfill_complete,
+      last_sync: r.last_sync ? new Date(r.last_sync).toISOString() : null,
+      last_error: r.last_error || undefined
+    }));
+    let sizeBytes = 0;
+    for (const suffix of ['', '-wal']) {
+      try { sizeBytes += fs.statSync(this.dbPath + suffix).size; } catch { /* ignore */ }
+    }
+    return {
+      db_path: this.dbPath,
+      db_size_mb: Math.round(sizeBytes / 1024 / 102.4) / 10,
+      sync_running: !!this.running,
+      sync_interval_minutes: this.intervalMs / 60000,
+      complete: folders.length > 0 && folders.every((f) => f.complete && !f.last_error),
+      last_run: this.lastRun ? {
+        finished: new Date(this.lastRun.finished).toISOString(),
+        added: this.lastRun.added,
+        removed: this.lastRun.removed,
+        duration_ms: this.lastRun.duration_ms
+      } : null,
+      folders
+    };
+  }
+
+  search({ query, folders = null, from = null, since_date = null, before_date = null, field = 'any', match = 'all', prefix = false, sort = 'date', limit = 20, offset = 0 }) {
+    const where = ['fts MATCH ?'];
+    const params = [ftsQuery(query, { match, prefix, field })];
+    const folderList = Array.isArray(folders) ? folders.filter(Boolean) : (folders ? [folders] : []);
+    if (folderList.length) {
+      where.push(`m.folder IN (${folderList.map(() => '?').join(', ')})`);
+      params.push(...folderList);
+    }
+    if (from) {
+      where.push('m.from_addr LIKE ?');
+      params.push(`%${from}%`);
+    }
+    if (since_date) {
+      where.push('m.internal_date >= ?');
+      params.push(localDate(since_date).getTime());
+    }
+    if (before_date) {
+      where.push('m.internal_date < ?');
+      params.push(localDate(before_date).getTime());
+    }
+    const whereSql = where.join(' AND ');
+    const order = sort === 'relevance' ? 'bm25(fts) ASC, m.internal_date DESC' : 'm.internal_date DESC';
+    const cap = Math.min(Math.max(1, Number(limit) || 20), 200);
+    const skip = Math.max(0, Number(offset) || 0);
+
+    const total = this.db.prepare(`SELECT count(*) AS n FROM fts JOIN messages m ON m.id = fts.rowid WHERE ${whereSql}`).get(...params).n;
+    const rows = this.db.prepare(`
+      SELECT m.folder, m.uid, m.internal_date, m.sent_date, m.from_addr, m.to_addr, m.subject, m.attachments,
+             snippet(fts, -1, '[', ']', '...', 16) AS snippet
+      FROM fts JOIN messages m ON m.id = fts.rowid
+      WHERE ${whereSql}
+      ORDER BY ${order}
+      LIMIT ? OFFSET ?`).all(...params, cap, skip);
+
+    const st = this.status();
+    const scope = folderList.length ? st.folders.filter((f) => folderList.includes(f.folder)) : st.folders;
+    return {
+      total_matches: total,
+      returned: rows.length,
+      offset: skip,
+      index: {
+        complete: scope.length > 0 && scope.every((f) => f.complete && !f.last_error),
+        sync_running: st.sync_running,
+        oldest_folder_sync: scope.reduce((min, f) => (f.last_sync && (!min || f.last_sync < min) ? f.last_sync : min), null),
+        incomplete_folders: scope.filter((f) => !f.complete || f.last_error).map((f) => f.folder)
+      },
+      results: rows.map((r) => ({
+        folder: r.folder,
+        uid: Number(r.uid),
+        date: r.sent_date || (r.internal_date ? new Date(Number(r.internal_date)).toISOString() : null),
+        from: r.from_addr,
+        to: r.to_addr,
+        subject: r.subject,
+        attachments: r.attachments || undefined,
+        snippet: r.snippet
+      }))
+    };
+  }
+}

package/lib/mime-text.js

@@ -0,0 +1,131 @@
+/**
+ * MIME text helpers for the local search index.
+ *
+ * @license MIT
+ */
+
+const MAX_PART_BYTES = 2 * 1024 * 1024;
+
+/** Flatten a node-imap BODYSTRUCTURE into its leaf parts. */
+export function leafParts(struct, out = []) {
+  if (!Array.isArray(struct)) return out;
+  for (const node of struct) {
+    if (Array.isArray(node)) {
+      leafParts(node, out);
+    } else if (node && typeof node === 'object' && node.partID && node.subtype) {
+      out.push(node);
+    }
+  }
+  return out;
+}
+
+function filenameOf(node) {
+  return node.disposition?.params?.filename || node.disposition?.params?.name || node.params?.name || null;
+}
+
+function isAttachment(node) {
+  const disposition = (node.disposition?.type || '').toLowerCase();
+  if (disposition === 'attachment') return true;
+  const ct = `${node.type}/${node.subtype}`.toLowerCase();
+  return !!filenameOf(node) && ct !== 'text/plain' && ct !== 'text/html';
+}
+
+/**
+ * Choose which parts to download for indexing. Prefers text/plain body parts
+ * and falls back to text/html. Also returns attachment filenames.
+ */
+export function planParts(struct) {
+  const leaves = leafParts(struct);
+  const bodyLeaves = leaves.filter((n) => !isAttachment(n) && (n.size == null || n.size <= MAX_PART_BYTES));
+  const plain = bodyLeaves.filter((n) => `${n.type}/${n.subtype}`.toLowerCase() === 'text/plain');
+  const html = bodyLeaves.filter((n) => `${n.type}/${n.subtype}`.toLowerCase() === 'text/html');
+  const chosen = plain.length ? plain : html;
+  const attachments = leaves.filter(isAttachment).map(filenameOf).filter(Boolean);
+  return {
+    parts: chosen.map((n) => ({
+      partID: String(n.partID),
+      html: `${n.subtype}`.toLowerCase() === 'html',
+      encoding: (n.encoding || '').toLowerCase(),
+      charset: (n.params?.charset || 'utf-8').toLowerCase()
+    })),
+    attachments
+  };
+}
+
+function decodeQuotedPrintable(input) {
+  const s = input.replace(/=\r?\n/g, '');
+  const bytes = [];
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '=' && /^[0-9A-Fa-f]{2}$/.test(s.slice(i + 1, i + 3))) {
+      bytes.push(parseInt(s.slice(i + 1, i + 3), 16));
+      i += 2;
+    } else {
+      const code = s.charCodeAt(i);
+      if (code < 256) bytes.push(code);
+      else bytes.push(...Buffer.from(ch, 'utf8'));
+    }
+  }
+  return Buffer.from(bytes);
+}
+
+export function decodeTransfer(buf, encoding) {
+  const enc = (encoding || '').toLowerCase();
+  if (enc === 'base64') return Buffer.from(buf.toString('latin1').replace(/[^A-Za-z0-9+/=]/g, ''), 'base64');
+  if (enc === 'quoted-printable') return decodeQuotedPrintable(buf.toString('latin1'));
+  return buf;
+}
+
+export function decodeCharset(buf, charset) {
+  const label = (charset || 'utf-8').toLowerCase().replace(/^"|"$/g, '');
+  try {
+    return new TextDecoder(label).decode(buf);
+  } catch {
+    try { return new TextDecoder('utf-8').decode(buf); } catch { return buf.toString('latin1'); }
+  }
+}
+
+const ENTITIES = { nbsp: ' ', amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", ndash: '-', mdash: '-', hellip: '...', rsquo: "'", lsquo: "'", rdquo: '"', ldquo: '"', eacute: 'é', egrave: 'è', agrave: 'à', ccedil: 'ç', uuml: 'ü', ouml: 'ö', auml: 'ä', euro: '€' };
+
+function decodeEntities(s) {
+  return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, code) => {
+    if (code[0] === '#') {
+      const n = code[1].toLowerCase() === 'x' ? parseInt(code.slice(2), 16) : parseInt(code.slice(1), 10);
+      try { return String.fromCodePoint(n); } catch { return m; }
+    }
+    const v = ENTITIES[code.toLowerCase()];
+    return v !== undefined ? v : m;
+  });
+}
+
+export function htmlToText(html) {
+  return decodeEntities(
+    String(html)
+      .replace(/<!--[\s\S]*?-->/g, ' ')
+      .replace(/<(head|style|script|title)[\s\S]*?<\/\1\s*>/gi, ' ')
+      .replace(/<br\s*\/?>/gi, '\n')
+      .replace(/<\/(p|div|tr|li|h[1-6]|blockquote|table)\s*>/gi, '\n')
+      .replace(/<[^>]+>/g, ' ')
+  )
+    .replace(/[ \t\u00a0]+/g, ' ')
+    .replace(/\s*\n\s*/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/** Remove inline data: images from HTML so it stays small enough for a tool result. */
+export function stripDataUris(html) {
+  return String(html).replace(/(["'(])data:[a-z0-9.+-]+\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=\s]+(["')])/gi, '$1[inline image removed]$2');
+}
+
+/** Turn fetched part buffers into one plain-text string. */
+export function partsToText(plan, partBuffers) {
+  const texts = [];
+  for (const p of plan.parts) {
+    const raw = partBuffers[p.partID];
+    if (!raw || !raw.length) continue;
+    const decoded = decodeCharset(decodeTransfer(raw, p.encoding), p.charset);
+    texts.push(p.html ? htmlToText(decoded) : decoded.replace(/\r\n/g, '\n'));
+  }
+  return texts.join('\n\n').trim();
+}

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "@lengelhard/imap-email-mcp",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "MCP server for Claude Code that provides email capabilities through IMAP/SMTP. Read, search, compose, and manage emails from any IMAP provider.",
   "type": "module",
   "main": "index.js",
   "bin": {
     "imap-email-mcp": "index.js"
   },
+  "files": [
+    "index.js",
+    "lib/",
+    "README.md",
+    "LICENSE",
+    ".env.example",
+    "CHANGELOG.md"
+  ],
   "scripts": {
     "start": "node index.js"
   },
@@ -26,7 +34,8 @@
     "outlook",
     "email-client",
     "ai-tools",
-    "llm-tools"
+    "llm-tools",
+    "full-text-search"
   ],
   "author": "",
   "license": "MIT",
@@ -45,6 +54,9 @@
     "@modelcontextprotocol/sdk": "^1.0.0",
     "imap-simple": "^5.1.0",
     "mailparser": "^3.7.2",
-    "nodemailer": "^6.9.16"
+    "mammoth": "^1.8.0",
+    "nodemailer": "^6.9.16",
+    "unpdf": "^1.8.1",
+    "xlsx": "^0.18.5"
   }
 }