@pheem49/mint 1.4.1 → 1.5.0

package/src/Plugins/gmail.js

@@ -0,0 +1,251 @@
+const axios = require('axios');
+const { readConfig } = require('../System/config_manager');
+
+const TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const GMAIL_API_BASE = 'https://gmail.googleapis.com/gmail/v1';
+
+function hasGmailConfig(config) {
+    return Boolean(config.gmailClientId && config.gmailClientSecret && config.gmailRefreshToken);
+}
+
+function parseInstruction(instruction) {
+    const raw = (instruction || '').trim();
+    if (!raw) return { action: 'help' };
+
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') {
+            return {
+                action: normalizeAction(parsed.action || 'search'),
+                ...parsed
+            };
+        }
+    } catch {
+        // Plain text searches Gmail.
+    }
+
+    const lower = raw.toLowerCase();
+    if (lower === 'help') return { action: 'help' };
+    if (lower === 'unread') return { action: 'search', query: 'is:unread' };
+    if (lower === 'inbox') return { action: 'search', query: 'in:inbox' };
+    if (lower.startsWith('read ')) return { action: 'read', id: raw.slice(5).trim() };
+    if (lower.startsWith('draft ')) return { action: 'draft', body: raw.slice(6).trim() };
+    if (lower.startsWith('search ')) return { action: 'search', query: raw.slice(7).trim() };
+
+    return { action: 'search', query: raw };
+}
+
+function normalizeAction(action) {
+    const normalized = String(action || '').toLowerCase();
+    if (['list', 'search', 'inbox', 'unread'].includes(normalized)) return 'search';
+    if (['get', 'read', 'read_email', 'message'].includes(normalized)) return 'read';
+    if (['draft', 'create_draft', 'compose', 'write'].includes(normalized)) return 'draft';
+    return normalized;
+}
+
+function gmailUserId(config) {
+    return encodeURIComponent(config.gmailUserId || 'me');
+}
+
+async function getAccessToken(config) {
+    const params = new URLSearchParams({
+        client_id: config.gmailClientId,
+        client_secret: config.gmailClientSecret,
+        refresh_token: config.gmailRefreshToken,
+        grant_type: 'refresh_token'
+    });
+
+    const response = await axios.post(TOKEN_URL, params.toString(), {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+
+    return response.data.access_token;
+}
+
+function gmailHeaders(accessToken) {
+    return {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+    };
+}
+
+function decodeBase64Url(data = '') {
+    const normalized = String(data).replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized.padEnd(normalized.length + ((4 - normalized.length % 4) % 4), '=');
+    return Buffer.from(padded, 'base64').toString('utf8');
+}
+
+function encodeBase64Url(data = '') {
+    return Buffer.from(String(data), 'utf8')
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/g, '');
+}
+
+function getHeader(message, name) {
+    const headers = message.payload?.headers || [];
+    const found = headers.find(header => header.name && header.name.toLowerCase() === name.toLowerCase());
+    return found ? found.value : '';
+}
+
+function findTextPart(payload) {
+    if (!payload) return '';
+    if (payload.mimeType === 'text/plain' && payload.body?.data) {
+        return decodeBase64Url(payload.body.data);
+    }
+    if (payload.mimeType === 'text/html' && payload.body?.data) {
+        return decodeBase64Url(payload.body.data).replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    }
+    for (const part of payload.parts || []) {
+        const text = findTextPart(part);
+        if (text) return text;
+    }
+    return payload.body?.data ? decodeBase64Url(payload.body.data) : '';
+}
+
+function formatMessageSummary(message) {
+    const subject = getHeader(message, 'Subject') || '(No subject)';
+    const from = getHeader(message, 'From') || '(Unknown sender)';
+    const date = getHeader(message, 'Date');
+    const snippet = message.snippet || '';
+    return [
+        `ID: ${message.id}`,
+        `From: ${from}`,
+        `Subject: ${subject}`,
+        date ? `Date: ${date}` : '',
+        snippet ? `Snippet: ${snippet}` : ''
+    ].filter(Boolean).join('\n');
+}
+
+async function fetchMessage(config, accessToken, id, format = 'metadata') {
+    const response = await axios.get(`${GMAIL_API_BASE}/users/${gmailUserId(config)}/messages/${encodeURIComponent(id)}`, {
+        headers: gmailHeaders(accessToken),
+        params: {
+            format,
+            metadataHeaders: ['From', 'To', 'Subject', 'Date']
+        }
+    });
+    return response.data;
+}
+
+async function searchMessages(config, input, accessToken) {
+    const query = input.query || input.q || 'in:inbox';
+    const maxResults = Number(input.maxResults || input.limit || 10);
+    const response = await axios.get(`${GMAIL_API_BASE}/users/${gmailUserId(config)}/messages`, {
+        headers: gmailHeaders(accessToken),
+        params: {
+            q: query,
+            maxResults
+        }
+    });
+
+    const messages = response.data.messages || [];
+    if (messages.length === 0) return `No Gmail messages found for query: ${query}`;
+
+    const detailed = [];
+    for (const message of messages.slice(0, maxResults)) {
+        const full = await fetchMessage(config, accessToken, message.id, 'metadata');
+        detailed.push(formatMessageSummary(full));
+    }
+
+    return `Gmail search results for "${query}":\n\n${detailed.join('\n\n')}`;
+}
+
+async function readMessage(config, input, accessToken) {
+    const id = input.id || input.messageId;
+    if (!id) throw new Error('Missing Gmail message id.');
+
+    const message = await fetchMessage(config, accessToken, id, 'full');
+    const body = findTextPart(message.payload);
+    return [
+        formatMessageSummary(message),
+        '',
+        body ? `Body:\n${body.slice(0, Number(input.maxChars || 4000))}` : 'Body: (No readable text body found)'
+    ].join('\n');
+}
+
+function sanitizeHeader(value = '') {
+    return String(value).replace(/[\r\n]+/g, ' ').trim();
+}
+
+function buildRawEmail(input) {
+    const to = sanitizeHeader(input.to || input.recipient || '');
+    if (!to) throw new Error('Missing email recipient.');
+
+    const cc = sanitizeHeader(input.cc || '');
+    const bcc = sanitizeHeader(input.bcc || '');
+    const subject = sanitizeHeader(input.subject || '(No subject)');
+    const body = String(input.body || input.content || input.text || '');
+
+    const headers = [
+        `To: ${to}`,
+        cc ? `Cc: ${cc}` : '',
+        bcc ? `Bcc: ${bcc}` : '',
+        `Subject: ${subject}`,
+        'MIME-Version: 1.0',
+        'Content-Type: text/plain; charset="UTF-8"'
+    ].filter(Boolean);
+
+    return encodeBase64Url(`${headers.join('\r\n')}\r\n\r\n${body}`);
+}
+
+async function createDraft(config, input, accessToken) {
+    const raw = buildRawEmail(input);
+    const response = await axios.post(`${GMAIL_API_BASE}/users/${gmailUserId(config)}/drafts`, {
+        message: { raw }
+    }, {
+        headers: gmailHeaders(accessToken)
+    });
+
+    const draft = response.data || {};
+    return `Created Gmail draft${draft.id ? ` ${draft.id}` : ''} for ${sanitizeHeader(input.to || input.recipient)}. Review it in Gmail before sending.`;
+}
+
+function helpText() {
+    return [
+        'Gmail plugin commands:',
+        '- Search inbox: {"action":"search","query":"in:inbox newer_than:7d","limit":5}',
+        '- Read message: {"action":"read","id":"MESSAGE_ID"}',
+        '- Create draft: {"action":"draft","to":"person@example.com","subject":"Hello","body":"Draft body"}',
+        'For safety, this plugin creates drafts only. It does not send email automatically.'
+    ].join('\n');
+}
+
+module.exports = {
+    name: 'gmail',
+    description: 'Manage Gmail safely. Target can be JSON: {"action":"search","query":"in:inbox is:unread","limit":10}, {"action":"read","id":"MESSAGE_ID"}, or {"action":"draft","to":"person@example.com","subject":"Subject","body":"Body"}. This plugin creates drafts only and does not send email.',
+
+    async execute(instruction) {
+        const config = readConfig();
+        const input = parseInstruction(instruction);
+
+        if (input.action === 'help') return helpText();
+        if (!hasGmailConfig(config)) {
+            return 'Gmail API is not configured. Add Gmail OAuth credentials with `mint onboard`. Use scopes for gmail.readonly and gmail.compose.';
+        }
+
+        const accessToken = await getAccessToken(config);
+
+        switch (input.action) {
+            case 'search':
+                return await searchMessages(config, input, accessToken);
+            case 'read':
+                return await readMessage(config, input, accessToken);
+            case 'draft':
+                return await createDraft(config, input, accessToken);
+            default:
+                throw new Error(`Unsupported Gmail action: ${input.action}`);
+        }
+    },
+
+    _helpers: {
+        parseInstruction,
+        buildRawEmail,
+        decodeBase64Url,
+        encodeBase64Url,
+        findTextPart,
+        formatMessageSummary,
+        hasGmailConfig
+    }
+};

package/src/Plugins/google_calendar.js

@@ -1,26 +1,252 @@
-const { shell } = require('electron');
+const axios = require('axios');
+const { readConfig } = require('../System/config_manager');
+
+let shell = null;
+try {
+    ({ shell } = require('electron'));
+} catch {
+    shell = null;
+}
+
+const TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const CALENDAR_API_BASE = 'https://www.googleapis.com/calendar/v3';
+
+function hasCalendarApiConfig(config) {
+    return Boolean(
+        config.googleCalendarClientId &&
+        config.googleCalendarClientSecret &&
+        config.googleCalendarRefreshToken
+    );
+}
+
+function parseInstruction(instruction) {
+    const raw = (instruction || '').trim();
+    if (!raw) return { action: 'open' };
+
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') {
+            return {
+                action: (parsed.action || 'create').toLowerCase(),
+                ...parsed
+            };
+        }
+    } catch {
+        // Plain text remains supported for backward compatibility.
+    }
+
+    const lower = raw.toLowerCase();
+    if (['open', 'view', 'calendar'].includes(lower)) return { action: 'open' };
+    if (['today', 'list today'].includes(lower)) return { action: 'list', range: 'today' };
+    if (lower.startsWith('list') || lower.startsWith('upcoming')) return { action: 'list', range: 'upcoming' };
+
+    return { action: 'create', summary: raw };
+}
+
+async function getAccessToken(config) {
+    const params = new URLSearchParams({
+        client_id: config.googleCalendarClientId,
+        client_secret: config.googleCalendarClientSecret,
+        refresh_token: config.googleCalendarRefreshToken,
+        grant_type: 'refresh_token'
+    });
+
+    const response = await axios.post(TOKEN_URL, params.toString(), {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+
+    return response.data.access_token;
+}
+
+function getCalendarId(config) {
+    return config.googleCalendarId || 'primary';
+}
+
+function getLocalDayBounds(date = new Date()) {
+    const start = new Date(date);
+    start.setHours(0, 0, 0, 0);
+
+    const end = new Date(start);
+    end.setDate(end.getDate() + 1);
+
+    return { start, end };
+}
+
+function addDays(date, days) {
+    const next = new Date(date);
+    next.setDate(next.getDate() + days);
+    return next;
+}
+
+function addDaysToIsoDate(dateString, days) {
+    const [year, month, day] = dateString.split('-').map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    date.setUTCDate(date.getUTCDate() + days);
+    return date.toISOString().slice(0, 10);
+}
+
+function formatEventTime(event) {
+    const start = event.start || {};
+    const end = event.end || {};
+    const startValue = start.dateTime || start.date;
+    const endValue = end.dateTime || end.date;
+
+    if (!startValue) return '';
+    if (start.date) return startValue;
+
+    const startText = new Date(startValue).toLocaleString('th-TH', {
+        dateStyle: 'medium',
+        timeStyle: 'short'
+    });
+    if (!endValue) return startText;
+
+    const endText = new Date(endValue).toLocaleTimeString('th-TH', {
+        hour: '2-digit',
+        minute: '2-digit'
+    });
+    return `${startText} - ${endText}`;
+}
+
+function buildEventPayload(input) {
+    const summary = (input.summary || input.title || input.name || '').trim();
+    if (!summary) {
+        throw new Error('Missing event summary/title.');
+    }
+
+    const payload = {
+        summary,
+        description: input.description || undefined,
+        location: input.location || undefined
+    };
+
+    if (input.start || input.startDateTime || input.end || input.endDateTime) {
+        const start = input.start || input.startDateTime;
+        const end = input.end || input.endDateTime;
+        if (!start) throw new Error('Missing event start time.');
+
+        payload.start = { dateTime: new Date(start).toISOString() };
+        payload.end = { dateTime: end ? new Date(end).toISOString() : new Date(new Date(start).getTime() + 60 * 60 * 1000).toISOString() };
+    } else if (input.date) {
+        payload.start = { date: input.date };
+        payload.end = { date: input.endDate || input.date };
+        if (payload.end.date === payload.start.date) {
+            payload.end.date = addDaysToIsoDate(input.date, 1);
+        }
+    } else {
+        const now = new Date();
+        const start = addDays(now, 1);
+        start.setHours(9, 0, 0, 0);
+        payload.start = { dateTime: start.toISOString() };
+        payload.end = { dateTime: new Date(start.getTime() + 60 * 60 * 1000).toISOString() };
+    }
+
+    return payload;
+}
+
+async function listEvents(config, input, accessToken) {
+    const now = new Date();
+    let timeMin = now;
+    let timeMax = addDays(now, Number(input.days || 7));
+
+    if (input.range === 'today') {
+        const bounds = getLocalDayBounds(now);
+        timeMin = bounds.start;
+        timeMax = bounds.end;
+    }
+
+    if (input.timeMin) timeMin = new Date(input.timeMin);
+    if (input.timeMax) timeMax = new Date(input.timeMax);
+
+    const calendarId = encodeURIComponent(getCalendarId(config));
+    const response = await axios.get(`${CALENDAR_API_BASE}/calendars/${calendarId}/events`, {
+        headers: { Authorization: `Bearer ${accessToken}` },
+        params: {
+            singleEvents: true,
+            orderBy: 'startTime',
+            maxResults: Number(input.maxResults || 10),
+            timeMin: timeMin.toISOString(),
+            timeMax: timeMax.toISOString()
+        }
+    });
+
+    const events = response.data.items || [];
+    if (events.length === 0) {
+        return input.range === 'today'
+            ? 'No Google Calendar events found for today. 📅'
+            : 'No upcoming Google Calendar events found. 📅';
+    }
+
+    const lines = events.map((event, index) => {
+        const when = formatEventTime(event);
+        return `${index + 1}. ${event.summary || '(Untitled)'}${when ? ` — ${when}` : ''}`;
+    });
+
+    return `Google Calendar events:\n${lines.join('\n')}`;
+}
+
+async function createEvent(config, input, accessToken) {
+    const payload = buildEventPayload(input);
+    const calendarId = encodeURIComponent(getCalendarId(config));
+    const response = await axios.post(`${CALENDAR_API_BASE}/calendars/${calendarId}/events`, payload, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
+        }
+    });
+
+    const event = response.data || {};
+    return `Created "${event.summary || payload.summary}" in Google Calendar. 📅${event.htmlLink ? `\n${event.htmlLink}` : ''}`;
+}
+
+function openCalendarFallback(input) {
+    if (!shell || typeof shell.openExternal !== 'function') {
+        return 'Google Calendar API is not configured, and this environment cannot open a browser.';
+    }
+
+    if (input.action === 'open') {
+        shell.openExternal('https://calendar.google.com/');
+        return 'Opening Google Calendar. 📅';
+    }
+
+    const title = encodeURIComponent(input.summary || input.title || input.name || 'New event');
+    const url = `https://calendar.google.com/calendar/r/eventedit?text=${title}`;
+    shell.openExternal(url);
+    return `Google Calendar API is not configured, so I opened the event creation page for "${decodeURIComponent(title)}" instead. 📅`;
+}
 
 module.exports = {
     name: 'google_calendar',
-    description: 'Quickly open Google Calendar to add a new event or view the calendar. Instruction should be the event title (e.g., "Meeting with team"). If no title, just put "open".',
-    
+    description: 'Manage Google Calendar. Target can be JSON: {"action":"list","range":"today|upcoming","days":7} or {"action":"create","summary":"Meeting","start":"2026-05-15T10:00:00+07:00","end":"2026-05-15T11:00:00+07:00","description":"","location":""}. Plain text creates a new event title. Use action "open" to open Calendar.',
+
     async execute(instruction) {
-        const inst = (instruction || '').trim();
-        
-        if (!inst || inst.toLowerCase() === 'open') {
-            shell.openExternal('https://calendar.google.com/');
-            return 'กำลังเปิดหน้าต่างปฏิทินให้ค่ะ 📅';
-        }
-        
-        // Encode the event title for the URL
-        const title = encodeURIComponent(inst);
-        const url = `https://calendar.google.com/calendar/r/eventedit?text=${title}`;
-        
-        try {
-            shell.openExternal(url);
-            return `กำลังเปิดหน้าต่างสร้างกิจกรรม "${inst}" ใน Google Calendar ให้ลูกพี่ค่ะ 📅✨`;
-        } catch (e) {
-            return `เกิดข้อผิดพลาดในการเปิด Calendar ค่ะ: ${e.message}`;
+        const config = readConfig();
+        const input = parseInstruction(instruction);
+
+        if (!hasCalendarApiConfig(config)) {
+            return openCalendarFallback(input);
+        }
+
+        const accessToken = await getAccessToken(config);
+
+        if (input.action === 'list' || input.action === 'today' || input.action === 'upcoming') {
+            return await listEvents(config, input, accessToken);
+        }
+
+        if (input.action === 'open') {
+            return openCalendarFallback(input);
         }
+
+        if (input.action === 'create' || input.action === 'add') {
+            return await createEvent(config, input, accessToken);
+        }
+
+        throw new Error(`Unsupported Google Calendar action: ${input.action}`);
+    },
+
+    _helpers: {
+        parseInstruction,
+        buildEventPayload,
+        hasCalendarApiConfig,
+        addDaysToIsoDate
     }
 };