bluelamp 4.1.2 → 4.2.0

package/lib/mcp-gmail/index.js

@@ -0,0 +1,547 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { google } from 'googleapis';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// --- Config ---
+const CONFIG_DIR = path.join(process.env.HOME || '/tmp', '.config', 'gmail-mcp');
+const TOKENS_DIR = path.join(CONFIG_DIR, 'tokens');
+const CREDENTIALS_PATH = path.join(CONFIG_DIR, 'credentials.json');
+const ACCOUNTS_PATH = path.join(CONFIG_DIR, 'accounts.json');
+// Legacy single-token path (for migration)
+const LEGACY_TOKEN_PATH = path.join(CONFIG_DIR, 'token.json');
+const SCOPES = ['https://www.googleapis.com/auth/gmail.readonly'];
+const DEFAULT_TEXT_BODY_LIMIT = 10000;
+// --- Account discovery ---
+function getAccounts() {
+    // 1. Explicit accounts.json takes priority
+    if (fs.existsSync(ACCOUNTS_PATH)) {
+        const data = JSON.parse(fs.readFileSync(ACCOUNTS_PATH, 'utf-8'));
+        if (Array.isArray(data))
+            return data;
+        if (data.accounts && Array.isArray(data.accounts))
+            return data.accounts;
+    }
+    // 2. Auto-discover from token files
+    if (fs.existsSync(TOKENS_DIR)) {
+        return fs.readdirSync(TOKENS_DIR)
+            .filter(f => f.endsWith('.json'))
+            .map(f => f.replace(/\.json$/, ''));
+    }
+    return [];
+}
+function getAuthenticatedAccounts() {
+    return getAccounts().filter(email => loadToken(email) !== null);
+}
+// --- Auth helpers ---
+function ensureConfigDir() {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    fs.mkdirSync(TOKENS_DIR, { recursive: true, mode: 0o700 });
+}
+function loadCredentials() {
+    if (!fs.existsSync(CREDENTIALS_PATH)) {
+        throw new Error(`credentials.json not found at ${CREDENTIALS_PATH}\n` +
+            'Place your Google OAuth credentials file there, or set GMAIL_MCP_CREDENTIALS_PATH env var.');
+    }
+    const raw = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf-8'));
+    return raw.installed || raw.web;
+}
+function makeOAuth2Client() {
+    const creds = loadCredentials();
+    return new google.auth.OAuth2(creds.client_id, creds.client_secret, creds.redirect_uris[0] || 'http://localhost');
+}
+function tokenPathFor(email) {
+    return path.join(TOKENS_DIR, `${email}.json`);
+}
+function loadToken(email) {
+    const p = tokenPathFor(email);
+    if (fs.existsSync(p)) {
+        return JSON.parse(fs.readFileSync(p, 'utf-8'));
+    }
+    return null;
+}
+function saveToken(email, token) {
+    ensureConfigDir();
+    fs.writeFileSync(tokenPathFor(email), JSON.stringify(token, null, 2), { mode: 0o600 });
+}
+function getAuthenticatedClient(email) {
+    const token = loadToken(email);
+    if (!token)
+        return null;
+    const client = makeOAuth2Client();
+    client.setCredentials(token);
+    client.on('tokens', (newTokens) => {
+        const existing = loadToken(email) || {};
+        saveToken(email, { ...existing, ...newTokens });
+    });
+    return client;
+}
+function getGmail(auth) {
+    return google.gmail({ version: 'v1', auth });
+}
+function decodeBase64(data) {
+    return Buffer.from(data.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf-8');
+}
+function getHeader(headers, name) {
+    const h = headers?.find(h => h.name?.toLowerCase() === name.toLowerCase());
+    return h?.value || '';
+}
+function extractAttachments(parts) {
+    const attachments = [];
+    for (const part of parts) {
+        if (part.filename && part.body?.attachmentId) {
+            attachments.push({
+                id: part.body.attachmentId,
+                filename: part.filename,
+                mimeType: part.mimeType || 'application/octet-stream',
+                size: part.body.size || 0,
+            });
+        }
+        if (part.parts) {
+            attachments.push(...extractAttachments(part.parts));
+        }
+    }
+    return attachments;
+}
+function extractHtmlBody(parts) {
+    for (const part of parts) {
+        if (part.mimeType === 'text/html' && part.body?.data) {
+            return decodeBase64(part.body.data);
+        }
+        if (part.parts) {
+            const found = extractHtmlBody(part.parts);
+            if (found)
+                return found;
+        }
+    }
+    return '';
+}
+function extractTextBody(parts) {
+    for (const part of parts) {
+        if (part.mimeType === 'text/plain' && part.body?.data) {
+            return decodeBase64(part.body.data);
+        }
+        if (part.parts) {
+            const found = extractTextBody(part.parts);
+            if (found)
+                return found;
+        }
+    }
+    return '';
+}
+async function searchAccount(email, query, maxResults) {
+    const auth = getAuthenticatedClient(email);
+    if (!auth)
+        return [];
+    const gmail = getGmail(auth);
+    const listRes = await gmail.users.messages.list({
+        userId: 'me',
+        q: query,
+        maxResults,
+    });
+    const messages = listRes.data.messages || [];
+    const results = [];
+    for (const msg of messages) {
+        const detail = await gmail.users.messages.get({
+            userId: 'me',
+            id: msg.id,
+            format: 'metadata',
+            metadataHeaders: ['Subject', 'From', 'Date'],
+        });
+        const headers = detail.data.payload?.headers || [];
+        const parts = detail.data.payload?.parts || [];
+        const attachments = extractAttachments(parts);
+        results.push({
+            account: email,
+            messageId: msg.id,
+            subject: getHeader(headers, 'Subject'),
+            from: getHeader(headers, 'From'),
+            date: getHeader(headers, 'Date'),
+            snippet: detail.data.snippet || '',
+            hasAttachments: attachments.length > 0,
+            attachments,
+        });
+    }
+    return results;
+}
+function buildQuery(params) {
+    const parts = [];
+    if (params.from)
+        parts.push(`from:${params.from}`);
+    if (params.after)
+        parts.push(`after:${params.after}`);
+    if (params.before)
+        parts.push(`before:${params.before}`);
+    if (params.subject)
+        parts.push(`subject:${params.subject}`);
+    if (params.has_attachment)
+        parts.push('has:attachment');
+    if (params.query)
+        parts.push(params.query);
+    return parts.join(' ');
+}
+// --- MCP Server ---
+const server = new Server({ name: 'mcp-gmail', version: '2.0.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'list_accounts',
+            description: 'List configured Gmail accounts and their authentication status',
+            inputSchema: { type: 'object', properties: {}, required: [] },
+        },
+        {
+            name: 'authorize_account',
+            description: 'Authorize a Gmail account. Call without auth_code to get the authorization URL, then call again with the code.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    email: { type: 'string', description: 'Email address to authorize' },
+                    auth_code: { type: 'string', description: 'Authorization code from OAuth flow (optional on first call)' },
+                },
+                required: ['email'],
+            },
+        },
+        {
+            name: 'search_emails',
+            description: 'Search emails across Gmail accounts by sender, date, keywords, etc.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    accounts: { type: 'array', items: { type: 'string' }, description: 'Email accounts to search (default: all authenticated)' },
+                    from: { type: 'string', description: 'Filter by sender' },
+                    after: { type: 'string', description: 'After date (YYYY/MM/DD)' },
+                    before: { type: 'string', description: 'Before date (YYYY/MM/DD)' },
+                    subject: { type: 'string', description: 'Subject keyword' },
+                    query: { type: 'string', description: 'Raw Gmail search query' },
+                    has_attachment: { type: 'boolean', description: 'Only emails with attachments' },
+                    max_results: { type: 'number', description: 'Max results per account (default: 10)' },
+                },
+                required: [],
+            },
+        },
+        {
+            name: 'get_email',
+            description: 'Get full email content (HTML body + text body + attachment list)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    account: { type: 'string', description: 'Email account' },
+                    message_id: { type: 'string', description: 'Gmail message ID' },
+                    text_body_limit: { type: 'number', description: `Max text body chars (default: ${DEFAULT_TEXT_BODY_LIMIT})` },
+                },
+                required: ['account', 'message_id'],
+            },
+        },
+        {
+            name: 'download_attachment',
+            description: 'Download an email attachment to a local file path',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    account: { type: 'string', description: 'Email account' },
+                    message_id: { type: 'string', description: 'Gmail message ID' },
+                    attachment_id: { type: 'string', description: 'Attachment ID' },
+                    save_path: { type: 'string', description: 'Absolute path to save the file' },
+                },
+                required: ['account', 'message_id', 'attachment_id', 'save_path'],
+            },
+        },
+        {
+            name: 'save_email_as_html',
+            description: 'Save email body as an HTML file',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    account: { type: 'string', description: 'Email account' },
+                    message_id: { type: 'string', description: 'Gmail message ID' },
+                    save_path: { type: 'string', description: 'Absolute path to save HTML file' },
+                },
+                required: ['account', 'message_id', 'save_path'],
+            },
+        },
+        {
+            name: 'batch_search_receipts',
+            description: 'Search for multiple receipts at once. Provide vendor/date/amount items and search all accounts.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                vendor: { type: 'string', description: 'Vendor/sender name' },
+                                date: { type: 'string', description: 'Transaction date (YYYY/MM/DD)' },
+                                amount: { type: 'number', description: 'Amount in JPY (optional)' },
+                            },
+                            required: ['vendor', 'date'],
+                        },
+                        description: 'List of receipts to search for',
+                    },
+                    date_tolerance_days: { type: 'number', description: 'Days before/after to search (default: 7)' },
+                },
+                required: ['items'],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'list_accounts': {
+                const accounts = getAccounts();
+                const statuses = accounts.map(email => {
+                    const token = loadToken(email);
+                    return {
+                        email,
+                        authenticated: !!token,
+                        hasRefreshToken: !!(token && token.refresh_token),
+                    };
+                });
+                // Also show any token files not in accounts list
+                if (fs.existsSync(TOKENS_DIR)) {
+                    const tokenEmails = fs.readdirSync(TOKENS_DIR)
+                        .filter(f => f.endsWith('.json'))
+                        .map(f => f.replace(/\.json$/, ''));
+                    for (const email of tokenEmails) {
+                        if (!accounts.includes(email)) {
+                            const token = loadToken(email);
+                            statuses.push({
+                                email,
+                                authenticated: !!token,
+                                hasRefreshToken: !!(token && token.refresh_token),
+                            });
+                        }
+                    }
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(statuses, null, 2) }] };
+            }
+            case 'authorize_account': {
+                const email = args.email;
+                const authCode = args.auth_code;
+                if (!authCode) {
+                    const client = makeOAuth2Client();
+                    const url = client.generateAuthUrl({
+                        access_type: 'offline',
+                        scope: SCOPES,
+                        login_hint: email,
+                        prompt: 'consent',
+                    });
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Open this URL in a browser and authorize:\n\n${url}\n\nAfter authorizing, you'll be redirected to localhost. Copy the "code" parameter from the URL bar and call this tool again with auth_code.`,
+                            }],
+                    };
+                }
+                const client = makeOAuth2Client();
+                const { tokens } = await client.getToken(authCode);
+                saveToken(email, tokens);
+                return { content: [{ type: 'text', text: `Account ${email} authorized and token saved.` }] };
+            }
+            case 'search_emails': {
+                const a = args;
+                const targetAccounts = a.accounts?.length
+                    ? a.accounts
+                    : getAuthenticatedAccounts();
+                const query = buildQuery({
+                    from: a.from,
+                    after: a.after,
+                    before: a.before,
+                    subject: a.subject,
+                    query: a.query,
+                    has_attachment: a.has_attachment,
+                });
+                const maxResults = a.max_results || 10;
+                const allResults = await Promise.all(targetAccounts.map((email) => searchAccount(email, query, maxResults).catch(err => {
+                    return [{ account: email, error: err.message }];
+                })));
+                const flat = allResults.flat();
+                return { content: [{ type: 'text', text: JSON.stringify(flat, null, 2) }] };
+            }
+            case 'get_email': {
+                const { account, message_id, text_body_limit } = args;
+                const limit = text_body_limit || DEFAULT_TEXT_BODY_LIMIT;
+                const auth = getAuthenticatedClient(account);
+                if (!auth) {
+                    return {
+                        content: [{ type: 'text', text: `Account ${account} not authenticated. Use authorize_account first.` }],
+                        isError: true,
+                    };
+                }
+                const gmail = getGmail(auth);
+                const detail = await gmail.users.messages.get({
+                    userId: 'me',
+                    id: message_id,
+                    format: 'full',
+                });
+                const headers = detail.data.payload?.headers || [];
+                const parts = detail.data.payload?.parts || [detail.data.payload];
+                const htmlBody = extractHtmlBody(parts);
+                const textBody = extractTextBody(parts);
+                const attachments = extractAttachments(parts);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                subject: getHeader(headers, 'Subject'),
+                                from: getHeader(headers, 'From'),
+                                date: getHeader(headers, 'Date'),
+                                textBody: textBody.substring(0, limit),
+                                textBodyTruncated: textBody.length > limit,
+                                htmlBodyLength: htmlBody.length,
+                                attachments,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case 'download_attachment': {
+                const { account, message_id, attachment_id, save_path } = args;
+                const auth = getAuthenticatedClient(account);
+                if (!auth) {
+                    return {
+                        content: [{ type: 'text', text: `Account ${account} not authenticated.` }],
+                        isError: true,
+                    };
+                }
+                const gmail = getGmail(auth);
+                const att = await gmail.users.messages.attachments.get({
+                    userId: 'me',
+                    messageId: message_id,
+                    id: attachment_id,
+                });
+                const data = att.data.data;
+                const buffer = Buffer.from(data.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+                const dir = path.dirname(save_path);
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(save_path, buffer);
+                return { content: [{ type: 'text', text: `Saved attachment (${buffer.length} bytes) to ${save_path}` }] };
+            }
+            case 'save_email_as_html': {
+                const { account, message_id, save_path } = args;
+                const auth = getAuthenticatedClient(account);
+                if (!auth) {
+                    return {
+                        content: [{ type: 'text', text: `Account ${account} not authenticated.` }],
+                        isError: true,
+                    };
+                }
+                const gmail = getGmail(auth);
+                const detail = await gmail.users.messages.get({
+                    userId: 'me',
+                    id: message_id,
+                    format: 'full',
+                });
+                const headers = detail.data.payload?.headers || [];
+                const parts = detail.data.payload?.parts || [detail.data.payload];
+                let htmlBody = extractHtmlBody(parts);
+                if (!htmlBody) {
+                    const textBody = extractTextBody(parts);
+                    htmlBody = `<pre>${textBody}</pre>`;
+                }
+                const subject = getHeader(headers, 'Subject');
+                const from = getHeader(headers, 'From');
+                const date = getHeader(headers, 'Date');
+                const fullHtml = `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>${subject}</title></head><body>
+<div style="border-bottom:2px solid #333;padding:12px;margin-bottom:16px;font-family:sans-serif;font-size:14px">
+<p><b>From:</b> ${from}</p>
+<p><b>Date:</b> ${date}</p>
+<p><b>Subject:</b> ${subject}</p>
+</div>
+${htmlBody}
+</body></html>`;
+                const dir = path.dirname(save_path);
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(save_path, fullHtml, 'utf-8');
+                return { content: [{ type: 'text', text: `Saved email HTML (${fullHtml.length} chars) to ${save_path}` }] };
+            }
+            case 'batch_search_receipts': {
+                const { items, date_tolerance_days = 7 } = args;
+                const authenticatedAccounts = getAuthenticatedAccounts();
+                if (authenticatedAccounts.length === 0) {
+                    return {
+                        content: [{ type: 'text', text: 'No authenticated accounts. Use authorize_account first.' }],
+                        isError: true,
+                    };
+                }
+                const results = [];
+                for (const item of items) {
+                    const d = new Date(item.date.replace(/\//g, '-'));
+                    const after = new Date(d);
+                    after.setDate(after.getDate() - date_tolerance_days);
+                    const before = new Date(d);
+                    before.setDate(before.getDate() + date_tolerance_days);
+                    const afterStr = `${after.getFullYear()}/${String(after.getMonth() + 1).padStart(2, '0')}/${String(after.getDate()).padStart(2, '0')}`;
+                    const beforeStr = `${before.getFullYear()}/${String(before.getMonth() + 1).padStart(2, '0')}/${String(before.getDate()).padStart(2, '0')}`;
+                    const query = `${item.vendor} after:${afterStr} before:${beforeStr}`;
+                    const allMatches = await Promise.all(authenticatedAccounts.map(email => searchAccount(email, query, 5).catch(() => [])));
+                    const matches = allMatches.flat();
+                    if (item.amount) {
+                        const amtStr = item.amount.toLocaleString();
+                        for (const m of matches) {
+                            m.amountMatch = m.snippet.includes(amtStr) ||
+                                m.snippet.includes(String(item.amount));
+                        }
+                    }
+                    results.push({
+                        vendor: item.vendor,
+                        date: item.date,
+                        amount: item.amount,
+                        matchCount: matches.length,
+                        matches,
+                    });
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
+            }
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+// --- Start ---
+async function main() {
+    ensureConfigDir();
+    // Migrate legacy single token if needed
+    if (fs.existsSync(LEGACY_TOKEN_PATH)) {
+        const tokenFiles = fs.existsSync(TOKENS_DIR) ? fs.readdirSync(TOKENS_DIR) : [];
+        if (tokenFiles.length === 0) {
+            // Try to determine which account this token belongs to
+            const accounts = getAccounts();
+            if (accounts.length > 0) {
+                fs.copyFileSync(LEGACY_TOKEN_PATH, tokenPathFor(accounts[0]));
+                process.stderr.write(`Migrated legacy token to ${accounts[0]}\n`);
+            }
+        }
+    }
+    // Fix permissions on existing token files
+    if (fs.existsSync(TOKENS_DIR)) {
+        for (const f of fs.readdirSync(TOKENS_DIR)) {
+            if (f.endsWith('.json')) {
+                try {
+                    fs.chmodSync(path.join(TOKENS_DIR, f), 0o600);
+                }
+                catch { }
+            }
+        }
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write('Gmail MCP server running (v2.0.0)\n');
+}
+main().catch((err) => {
+    process.stderr.write(`Fatal: ${err.message}\n`);
+    process.exit(1);
+});