@pheem49/mint 1.4.2 → 1.5.0

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
     }
 };

package/src/Plugins/notion.js

@@ -0,0 +1,256 @@
+const axios = require('axios');
+const { readConfig } = require('../System/config_manager');
+
+const NOTION_API_BASE = 'https://api.notion.com/v1';
+const NOTION_VERSION = '2022-06-28';
+
+function hasNotionConfig(config) {
+    return Boolean(config.notionApiKey);
+}
+
+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 || 'create_page'),
+                ...parsed
+            };
+        }
+    } catch {
+        // Plain text creates a note/page.
+    }
+
+    const lower = raw.toLowerCase();
+    if (lower === 'help') return { action: 'help' };
+    if (lower === 'list' || lower.startsWith('list database')) return { action: 'query_database' };
+    if (lower.startsWith('read database')) return { action: 'query_database' };
+
+    const [firstLine, ...rest] = raw.split('\n');
+    return {
+        action: 'create_page',
+        title: firstLine.trim() || 'Mint Note',
+        content: rest.join('\n').trim() || raw
+    };
+}
+
+function normalizeAction(action) {
+    const normalized = String(action || '').toLowerCase();
+    if (['create', 'create_note', 'note', 'create_page', 'page'].includes(normalized)) return 'create_page';
+    if (['list', 'read', 'query', 'query_database', 'read_database'].includes(normalized)) return 'query_database';
+    if (['append', 'append_block', 'append_to_page'].includes(normalized)) return 'append_block';
+    return normalized;
+}
+
+function notionHeaders(config) {
+    return {
+        Authorization: `Bearer ${config.notionApiKey}`,
+        'Notion-Version': NOTION_VERSION,
+        'Content-Type': 'application/json'
+    };
+}
+
+function textBlock(text) {
+    return {
+        object: 'block',
+        type: 'paragraph',
+        paragraph: {
+            rich_text: [
+                {
+                    type: 'text',
+                    text: { content: String(text || '') }
+                }
+            ]
+        }
+    };
+}
+
+function headingBlock(text) {
+    return {
+        object: 'block',
+        type: 'heading_2',
+        heading_2: {
+            rich_text: [
+                {
+                    type: 'text',
+                    text: { content: String(text || '') }
+                }
+            ]
+        }
+    };
+}
+
+function buildChildren(input) {
+    const content = input.content || input.body || input.text || '';
+    const blocks = [];
+
+    if (Array.isArray(input.children)) return input.children;
+    if (input.heading) blocks.push(headingBlock(input.heading));
+
+    const paragraphs = String(content || '')
+        .split(/\n\s*\n/)
+        .map(part => part.trim())
+        .filter(Boolean);
+
+    for (const paragraph of paragraphs.length ? paragraphs : ['Created by Mint.']) {
+        blocks.push(textBlock(paragraph));
+    }
+
+    return blocks;
+}
+
+function buildDatabaseProperties(input, config) {
+    const title = input.title || input.summary || input.name || 'Mint Note';
+    const titleProperty = input.titleProperty || config.notionTitleProperty || 'Name';
+    const properties = {
+        [titleProperty]: {
+            title: [
+                {
+                    text: { content: title }
+                }
+            ]
+        }
+    };
+
+    if (input.properties && typeof input.properties === 'object') {
+        return { ...properties, ...input.properties };
+    }
+
+    return properties;
+}
+
+function formatNotionTitle(properties = {}) {
+    for (const property of Object.values(properties)) {
+        if (property && property.type === 'title' && Array.isArray(property.title)) {
+            const title = property.title.map(part => part.plain_text || part.text?.content || '').join('');
+            if (title) return title;
+        }
+    }
+    return '(Untitled)';
+}
+
+async function createPage(config, input) {
+    const databaseId = input.databaseId || config.notionDatabaseId;
+    const pageId = input.pageId || config.notionPageId;
+
+    if (!databaseId && !pageId) {
+        throw new Error('Missing Notion databaseId or pageId. Configure one in onboarding or pass it in the instruction JSON.');
+    }
+
+    const payload = databaseId
+        ? {
+            parent: { database_id: databaseId },
+            properties: buildDatabaseProperties(input, config),
+            children: buildChildren(input)
+        }
+        : {
+            parent: { page_id: pageId },
+            properties: {
+                title: [
+                    {
+                        text: { content: input.title || input.summary || input.name || 'Mint Note' }
+                    }
+                ]
+            },
+            children: buildChildren(input)
+        };
+
+    const response = await axios.post(`${NOTION_API_BASE}/pages`, payload, {
+        headers: notionHeaders(config)
+    });
+
+    const page = response.data || {};
+    const title = input.title || input.summary || input.name || 'Mint Note';
+    return `Created Notion page "${title}".${page.url ? `\n${page.url}` : ''}`;
+}
+
+async function queryDatabase(config, input) {
+    const databaseId = input.databaseId || config.notionDatabaseId;
+    if (!databaseId) {
+        throw new Error('Missing Notion databaseId. Configure one in onboarding or pass it in the instruction JSON.');
+    }
+
+    const payload = {
+        page_size: Number(input.pageSize || input.limit || 10)
+    };
+
+    if (input.filter) payload.filter = input.filter;
+    if (input.sorts) payload.sorts = input.sorts;
+
+    const response = await axios.post(`${NOTION_API_BASE}/databases/${databaseId}/query`, payload, {
+        headers: notionHeaders(config)
+    });
+
+    const results = response.data.results || [];
+    if (results.length === 0) return 'No Notion database pages found.';
+
+    const lines = results.map((page, index) => {
+        const title = formatNotionTitle(page.properties);
+        return `${index + 1}. ${title}${page.url ? ` — ${page.url}` : ''}`;
+    });
+
+    return `Notion database pages:\n${lines.join('\n')}`;
+}
+
+async function appendBlock(config, input) {
+    const pageId = input.pageId || config.notionPageId;
+    if (!pageId) {
+        throw new Error('Missing Notion pageId. Configure one in onboarding or pass it in the instruction JSON.');
+    }
+
+    const response = await axios.patch(`${NOTION_API_BASE}/blocks/${pageId}/children`, {
+        children: buildChildren(input)
+    }, {
+        headers: notionHeaders(config)
+    });
+
+    const count = response.data.results ? response.data.results.length : buildChildren(input).length;
+    return `Appended ${count} block(s) to Notion page.`;
+}
+
+function helpText() {
+    return [
+        'Notion plugin commands:',
+        '- Create page: {"action":"create_page","title":"Note title","content":"Body text"}',
+        '- Query database: {"action":"query_database","limit":5}',
+        '- Append to page: {"action":"append_block","pageId":"...","content":"Text"}',
+        'Plain text creates a Notion page using the configured default database or page.'
+    ].join('\n');
+}
+
+module.exports = {
+    name: 'notion',
+    description: 'Manage Notion. Target can be JSON: {"action":"create_page","title":"Note","content":"Body","databaseId":"optional","pageId":"optional"}, {"action":"query_database","databaseId":"optional","limit":10}, or {"action":"append_block","pageId":"optional","content":"Text"}. Plain text creates a note.',
+
+    async execute(instruction) {
+        const config = readConfig();
+        const input = parseInstruction(instruction);
+
+        if (input.action === 'help') return helpText();
+        if (!hasNotionConfig(config)) {
+            return 'Notion API is not configured. Add a Notion internal integration secret with `mint onboard`, then share your Notion page/database with that integration.';
+        }
+
+        switch (input.action) {
+            case 'create_page':
+                return await createPage(config, input);
+            case 'query_database':
+                return await queryDatabase(config, input);
+            case 'append_block':
+                return await appendBlock(config, input);
+            default:
+                throw new Error(`Unsupported Notion action: ${input.action}`);
+        }
+    },
+
+    _helpers: {
+        parseInstruction,
+        buildChildren,
+        buildDatabaseProperties,
+        formatNotionTitle,
+        hasNotionConfig
+    }
+};

package/src/System/action_executor.js

@@ -0,0 +1,129 @@
+const { clipboard: electronClipboard } = require('electron');
+const { openApp } = require('../Automation_Layer/open_app');
+const { openWebsite, openSearch } = require('../Automation_Layer/open_website');
+const { performWebAutomation } = require('../Automation_Layer/browser_automation');
+const { createFolder, openFile, deleteFile, findPath } = require('../Automation_Layer/file_operations');
+const { indexFile, indexFolder } = require('../AI_Brain/knowledge_base');
+const pluginManager = require('../Plugins/plugin_manager');
+const mcpManager = require('../Plugins/mcp_manager');
+const granularAutomation = require('./granular_automation');
+const SystemAutomation = require('./system_automation');
+const safetyManager = require('./safety_manager');
+
+async function executeAction(action, options = {}) {
+    console.log("Executing action:", action);
+    const clipboard = options.clipboard || electronClipboard;
+    const safety = safetyManager.assertActionAllowed(action, {
+        allowDangerous: options.allowDangerous === true
+    });
+    safetyManager.appendActionLog({
+        source: options.source || 'action_executor',
+        action: action.type,
+        target: action.target || action.path || '',
+        tier: safety.tier,
+        approved: options.allowDangerous === true || safety.tier !== safetyManager.TIERS.DANGEROUS
+    });
+
+    switch (action.type) {
+        case 'open_url':
+            openWebsite(action.target);
+            break;
+        case 'search':
+            openSearch(action.target);
+            break;
+        case 'open_app':
+            openApp(action.target);
+            break;
+        case 'web_automation':
+            return await performWebAutomation(action.target);
+        case 'create_folder':
+            createFolder(action.target);
+            break;
+        case 'open_file': {
+            const fileRes = await openFile(action.target);
+            return fileRes || `Successfully opened file: ${action.target} ✅`;
+        }
+        case 'open_folder': {
+            const folderRes = await openFile(action.target);
+            return folderRes || `Successfully opened folder: ${action.target} ✅`;
+        }
+        case 'delete_file':
+            await deleteFile(action.target);
+            break;
+        case 'find_path':
+            return await executeFindPath(action);
+        case 'clipboard_write':
+            clipboard.writeText(action.target);
+            break;
+        case 'learn_file':
+            return await indexFile(action.target);
+        case 'learn_folder':
+            return await indexFolder(action.target);
+        case 'mcp_tool': {
+            const mcpResult = await mcpManager.callTool(action.server, action.target, action.args);
+            return JSON.stringify(mcpResult.content);
+        }
+        case 'mouse_move':
+            return await granularAutomation.mouseMove(action.x, action.y);
+        case 'mouse_click':
+            return await granularAutomation.mouseClick(action.x, action.y, action.button || 1);
+        case 'type_text':
+            return await granularAutomation.typeText(action.target);
+        case 'key_tap':
+            return await granularAutomation.keyTap(action.target);
+        case 'plugin':
+            return await pluginManager.executePlugin(action.pluginName, action.target);
+        case 'system_automation':
+            return await handleSystemAutomation(action.target);
+        default:
+            return undefined;
+    }
+}
+
+async function executeFindPath(action) {
+    const result = findPath(action.target, {
+        type: action.pathType,
+        maxResults: 10
+    });
+    if (!result.success) {
+        return result.message;
+    }
+
+    if (action.openAfter === true) {
+        if (result.matches.length === 1) {
+            const match = result.matches[0];
+            const openResult = await openFile(match.path);
+            return openResult || `Successfully found and opened ${match.type === 'dir' ? 'folder' : 'file'}: ${match.path} ✅`;
+        }
+        return `Found multiple matches for "${action.target}". Please be more specific:\n${result.matches.map(m => `- [${m.type}] ${m.path}`).join('\n')}`;
+    }
+
+    return `Found matches for "${action.target}":\n${result.matches.map(m => `- [${m.type}] ${m.path}`).join('\n')}`;
+}
+
+async function handleSystemAutomation(target) {
+    const [cmd, value] = target.split(':');
+    switch (cmd) {
+        case 'volume':
+            return await SystemAutomation.setVolume(parseInt(value));
+        case 'mute':
+            return await SystemAutomation.mute();
+        case 'brightness':
+            return await SystemAutomation.setBrightness(parseInt(value));
+        case 'sleep':
+            return await SystemAutomation.sleep();
+        case 'restart':
+            return await SystemAutomation.restart();
+        case 'shutdown':
+            return await SystemAutomation.shutdown();
+        case 'minimize_all':
+            return await SystemAutomation.minimizeAll();
+        default:
+            if (SystemAutomation[target]) {
+                return await SystemAutomation[target]();
+            }
+            throw new Error(`Unknown system automation command: ${target}`);
+    }
+}
+
+module.exports = { executeAction, handleSystemAutomation };