ofw-mcp 2.0.4 → 2.0.5

package/dist/cache.js

@@ -0,0 +1,192 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { getCacheDbPath } from './config.js';
+let instance = null;
+const SCHEMA_V1 = `
+CREATE TABLE IF NOT EXISTS messages (
+  id INTEGER PRIMARY KEY,
+  folder TEXT NOT NULL,
+  subject TEXT NOT NULL,
+  from_user TEXT NOT NULL,
+  sent_at TEXT NOT NULL,
+  recipients_json TEXT NOT NULL,
+  body TEXT,
+  fetched_body_at TEXT,
+  reply_to_id INTEGER,
+  chain_root_id INTEGER,
+  list_data_json TEXT NOT NULL,
+  last_seen_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_messages_folder_sent_at ON messages(folder, sent_at DESC);
+CREATE INDEX IF NOT EXISTS idx_messages_chain_root ON messages(chain_root_id);
+
+CREATE TABLE IF NOT EXISTS drafts (
+  id INTEGER PRIMARY KEY,
+  subject TEXT NOT NULL,
+  body TEXT NOT NULL,
+  recipients_json TEXT NOT NULL,
+  reply_to_id INTEGER,
+  modified_at TEXT NOT NULL,
+  list_data_json TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sync_state (
+  folder TEXT PRIMARY KEY,
+  last_sync_at TEXT NOT NULL,
+  newest_id INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+`;
+function migrate(db) {
+    db.exec(SCHEMA_V1);
+    db.prepare('INSERT OR IGNORE INTO meta(key, value) VALUES(?, ?)').run('schema_version', '1');
+}
+export function openCache() {
+    if (instance)
+        return instance;
+    const path = getCacheDbPath();
+    mkdirSync(dirname(path), { recursive: true });
+    const db = new DatabaseSync(path);
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA foreign_keys = ON');
+    migrate(db);
+    instance = { db };
+    return instance;
+}
+export function closeCache() {
+    if (instance) {
+        instance.db.close();
+        instance = null;
+    }
+}
+function rowFromDb(r) {
+    return {
+        id: r.id,
+        folder: r.folder,
+        subject: r.subject,
+        fromUser: r.from_user,
+        sentAt: r.sent_at,
+        recipients: JSON.parse(r.recipients_json),
+        body: r.body,
+        fetchedBodyAt: r.fetched_body_at,
+        replyToId: r.reply_to_id,
+        chainRootId: r.chain_root_id,
+        listData: JSON.parse(r.list_data_json),
+    };
+}
+export function upsertMessage(row) {
+    const { db } = openCache();
+    db.prepare(`INSERT INTO messages (
+       id, folder, subject, from_user, sent_at, recipients_json,
+       body, fetched_body_at, reply_to_id, chain_root_id, list_data_json, last_seen_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       folder=excluded.folder,
+       subject=excluded.subject,
+       from_user=excluded.from_user,
+       sent_at=excluded.sent_at,
+       recipients_json=excluded.recipients_json,
+       body=excluded.body,
+       fetched_body_at=excluded.fetched_body_at,
+       reply_to_id=excluded.reply_to_id,
+       chain_root_id=excluded.chain_root_id,
+       list_data_json=excluded.list_data_json,
+       last_seen_at=excluded.last_seen_at`).run(row.id, row.folder, row.subject, row.fromUser, row.sentAt, JSON.stringify(row.recipients), row.body, row.fetchedBodyAt, row.replyToId, row.chainRootId, JSON.stringify(row.listData), new Date().toISOString());
+}
+export function getMessage(id) {
+    const { db } = openCache();
+    const r = db.prepare('SELECT * FROM messages WHERE id = ?').get(id);
+    return r ? rowFromDb(r) : null;
+}
+export function listMessages(opts) {
+    const { db } = openCache();
+    const offset = (opts.page - 1) * opts.size;
+    const rows = db.prepare(`SELECT * FROM messages WHERE folder = ?
+     ORDER BY sent_at DESC, id DESC
+     LIMIT ? OFFSET ?`).all(opts.folder, opts.size, offset);
+    return rows.map(rowFromDb);
+}
+function draftFromDb(r) {
+    return {
+        id: r.id,
+        subject: r.subject,
+        body: r.body,
+        recipients: JSON.parse(r.recipients_json),
+        replyToId: r.reply_to_id,
+        modifiedAt: r.modified_at,
+        listData: JSON.parse(r.list_data_json),
+    };
+}
+export function upsertDraft(row) {
+    const { db } = openCache();
+    db.prepare(`INSERT INTO drafts (id, subject, body, recipients_json, reply_to_id, modified_at, list_data_json)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       subject=excluded.subject,
+       body=excluded.body,
+       recipients_json=excluded.recipients_json,
+       reply_to_id=excluded.reply_to_id,
+       modified_at=excluded.modified_at,
+       list_data_json=excluded.list_data_json`).run(row.id, row.subject, row.body, JSON.stringify(row.recipients), row.replyToId, row.modifiedAt, JSON.stringify(row.listData));
+}
+export function getDraft(id) {
+    const { db } = openCache();
+    const r = db.prepare('SELECT * FROM drafts WHERE id = ?').get(id);
+    return r ? draftFromDb(r) : null;
+}
+export function listDrafts(opts) {
+    const { db } = openCache();
+    const offset = (opts.page - 1) * opts.size;
+    const rows = db.prepare('SELECT * FROM drafts ORDER BY modified_at DESC, id DESC LIMIT ? OFFSET ?').all(opts.size, offset);
+    return rows.map(draftFromDb);
+}
+export function deleteDraft(id) {
+    const { db } = openCache();
+    db.prepare('DELETE FROM drafts WHERE id = ?').run(id);
+}
+export function listDraftIds() {
+    const { db } = openCache();
+    const rows = db.prepare('SELECT id FROM drafts').all();
+    return rows.map((r) => r.id);
+}
+export function getSyncState(folder) {
+    const { db } = openCache();
+    const r = db.prepare('SELECT last_sync_at, newest_id FROM sync_state WHERE folder = ?')
+        .get(folder);
+    if (!r)
+        return null;
+    return { lastSyncAt: r.last_sync_at, newestId: r.newest_id };
+}
+export function setSyncState(folder, state) {
+    const { db } = openCache();
+    db.prepare(`INSERT INTO sync_state (folder, last_sync_at, newest_id) VALUES (?, ?, ?)
+     ON CONFLICT(folder) DO UPDATE SET
+       last_sync_at = excluded.last_sync_at,
+       newest_id = excluded.newest_id`).run(folder, state.lastSyncAt, state.newestId);
+}
+export function getMeta(key) {
+    const { db } = openCache();
+    const r = db.prepare('SELECT value FROM meta WHERE key = ?')
+        .get(key);
+    return r ? r.value : null;
+}
+export function setMeta(key, value) {
+    const { db } = openCache();
+    db.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value').run(key, value);
+}
+export function findLatestReplyTip(replyToId) {
+    const { db } = openCache();
+    const parent = db.prepare('SELECT id, folder, chain_root_id FROM messages WHERE id = ?').get(replyToId);
+    if (!parent)
+        return replyToId;
+    const chainRoot = parent.chain_root_id ?? parent.id;
+    const tip = db.prepare(`SELECT id FROM messages
+     WHERE folder = 'sent' AND chain_root_id = ?
+     ORDER BY id DESC LIMIT 1`).get(chainRoot);
+    return tip ? tip.id : replyToId;
+}

package/dist/config.js

@@ -0,0 +1,21 @@
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function readUsername() {
+    const raw = process.env.OFW_USERNAME;
+    if (typeof raw !== 'string' || raw.trim().length === 0) {
+        throw new Error('OFW_USERNAME must be set to derive cache path');
+    }
+    return raw.trim();
+}
+export function getCacheDir() {
+    const override = process.env.OFW_CACHE_DIR;
+    if (override && override.trim().length > 0)
+        return override.trim();
+    return join(homedir(), '.cache', 'ofw-mcp');
+}
+export function getCacheDbPath() {
+    const username = readUsername();
+    const hash = createHash('sha256').update(username).digest('hex').slice(0, 16);
+    return join(getCacheDir(), `${hash}.db`);
+}

package/dist/index.js

@@ -1,4 +1,14 @@
 #!/usr/bin/env node
+const originalEmit = process.emit.bind(process);
+process.emit = function (event, ...args) {
+    if (event === 'warning') {
+        const w = args[0];
+        if (w?.name === 'ExperimentalWarning' && /SQLite/i.test(w.message ?? '')) {
+            return false;
+        }
+    }
+    return originalEmit(event, ...args);
+};
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { client } from './client.js';
@@ -7,7 +17,7 @@ import { registerMessageTools } from './tools/messages.js';
 import { registerCalendarTools } from './tools/calendar.js';
 import { registerExpenseTools } from './tools/expenses.js';
 import { registerJournalTools } from './tools/journal.js';
-const server = new McpServer({ name: 'ofw', version: '2.0.4' });
+const server = new McpServer({ name: 'ofw', version: '2.0.5' });
 registerUserTools(server, client);
 registerMessageTools(server, client);
 registerCalendarTools(server, client);

package/dist/sync.js

@@ -0,0 +1,149 @@
+import { setMeta, upsertMessage, getMessage, setSyncState, upsertDraft, getDraft, deleteDraft, listDraftIds, } from './cache.js';
+export async function resolveFolderIds(client) {
+    const data = await client.request('GET', '/pub/v1/messageFolders?includeFolderCounts=true');
+    const sys = data.systemFolders ?? [];
+    const find = (type) => {
+        const f = sys.find((x) => x.folderType === type);
+        if (!f)
+            throw new Error(`OFW system folder not found: ${type}`);
+        return f.id;
+    };
+    const ids = {
+        inbox: find('INBOX'),
+        sent: find('SENT_MESSAGES'),
+        drafts: find('DRAFTS'),
+    };
+    setMeta('drafts_folder_id', ids.drafts);
+    return ids;
+}
+function recipientsFromList(item) {
+    return (item.recipients ?? []).map((r) => ({
+        userId: r.user.id,
+        name: r.user.name,
+        viewedAt: r.viewed?.dateTime ?? null,
+    }));
+}
+export async function syncMessageFolder(client, folder, folderId, opts) {
+    let page = 1;
+    let synced = 0;
+    let newestId = null;
+    const unread = [];
+    while (true) {
+        const path = `/pub/v3/messages?folders=${encodeURIComponent(folderId)}&page=${page}&size=50&sort=date&sortDirection=desc`;
+        const list = await client.request('GET', path);
+        const items = list.data ?? [];
+        if (items.length === 0)
+            break;
+        let pageSawKnownItem = false;
+        for (const item of items) {
+            if (newestId === null || item.id > newestId)
+                newestId = item.id;
+            const existing = getMessage(item.id);
+            if (existing) {
+                pageSawKnownItem = true;
+                continue;
+            }
+            const isInboxUnread = folder === 'inbox' && item.showNeverViewed === true;
+            const shouldFetchBody = !isInboxUnread || opts.fetchUnreadBodies;
+            let body = null;
+            let fetchedBodyAt = null;
+            if (shouldFetchBody) {
+                const detail = await client.request('GET', `/pub/v3/messages/${item.id}`);
+                body = detail.body ?? '';
+                fetchedBodyAt = new Date().toISOString();
+            }
+            else {
+                unread.push({
+                    id: item.id,
+                    subject: item.subject,
+                    from: item.from?.name ?? '',
+                    sentAt: item.date.dateTime,
+                });
+            }
+            const row = {
+                id: item.id,
+                folder,
+                subject: item.subject,
+                fromUser: item.from?.name ?? '',
+                sentAt: item.date.dateTime,
+                recipients: recipientsFromList(item),
+                body,
+                fetchedBodyAt,
+                replyToId: null,
+                chainRootId: null,
+                listData: item,
+            };
+            upsertMessage(row);
+            synced++;
+        }
+        // OFW returns date-desc, so a known item means we've reached cached history.
+        if (pageSawKnownItem)
+            break;
+        page++;
+    }
+    setSyncState(folder, {
+        lastSyncAt: new Date().toISOString(),
+        newestId,
+    });
+    return { synced, unread };
+}
+export async function syncDrafts(client, draftsFolderId) {
+    const path = `/pub/v3/messages?folders=${encodeURIComponent(draftsFolderId)}&page=1&size=50&sort=date&sortDirection=desc`;
+    const list = await client.request('GET', path);
+    const items = list.data ?? [];
+    const seenIds = new Set();
+    let synced = 0;
+    for (const item of items) {
+        seenIds.add(item.id);
+        const existing = getDraft(item.id);
+        if (existing && existing.modifiedAt === item.date.dateTime) {
+            continue;
+        }
+        const detail = await client.request('GET', `/pub/v3/messages/${item.id}`);
+        const row = {
+            id: item.id,
+            subject: detail.subject ?? item.subject,
+            body: detail.body ?? '',
+            recipients: (item.recipients ?? []).map((r) => ({
+                userId: r.user.id, name: r.user.name, viewedAt: r.viewed?.dateTime ?? null,
+            })),
+            replyToId: item.replyToId,
+            modifiedAt: item.date.dateTime,
+            listData: item,
+        };
+        upsertDraft(row);
+        synced++;
+    }
+    for (const id of listDraftIds()) {
+        if (!seenIds.has(id))
+            deleteDraft(id);
+    }
+    return { synced };
+}
+export async function syncAll(client, opts) {
+    const folders = opts.folders ?? ['inbox', 'sent', 'drafts'];
+    const ids = await resolveFolderIds(client);
+    const synced = {};
+    let unreadInbox = [];
+    for (const folder of folders) {
+        if (folder === 'inbox') {
+            const r = await syncMessageFolder(client, 'inbox', ids.inbox, {
+                fetchUnreadBodies: opts.fetchUnreadBodies ?? false,
+            });
+            synced.inbox = r.synced;
+            unreadInbox = r.unread;
+        }
+        else if (folder === 'sent') {
+            const r = await syncMessageFolder(client, 'sent', ids.sent, { fetchUnreadBodies: false });
+            synced.sent = r.synced;
+        }
+        else if (folder === 'drafts') {
+            const r = await syncDrafts(client, ids.drafts);
+            synced.drafts = r.synced;
+        }
+    }
+    const note = unreadInbox.length > 0
+        ? `${unreadInbox.length} unread inbox messages cached without bodies. Call ofw_get_message(id) to read them — this will mark them as read on OFW.`
+        : undefined;
+    return { synced, unreadInbox, ...(note ? { note } : {}) };
+}