@pheem49/mint 1.4.2 → 1.5.0

package/src/UI/settings.js

@@ -23,9 +23,17 @@ const DEFAULT_CONFIG = {
     ttsPitch: 1.0,
     pluginSpotifyEnabled: true,
     pluginCalendarEnabled: false,
+    pluginGmailEnabled: false,
+    pluginNotionEnabled: false,
     pluginDiscordEnabled: false,
     showDesktopWidget: true,
-    mcpServers: {}
+    mcpServers: {},
+    openaiModel: 'gpt-4o',
+    anthropicModel: 'claude-3-5-sonnet-latest',
+    hfModel: 'meta-llama/Meta-Llama-3-8B-Instruct',
+    localApiBaseUrl: '',
+    localModelName: 'local-model',
+    ollamaHost: ''
 };
 
 let currentConfig = { ...DEFAULT_CONFIG };
@@ -68,7 +76,7 @@ function applyConfig(config) {
     if (hfInput) hfInput.value = config.hfApiKey || '';
 
     const ollamaHostInput = document.getElementById('ollama-host-input');
-    if (ollamaHostInput) ollamaHostInput.value = config.ollamaHost || 'http://localhost:11434';
+    if (ollamaHostInput) ollamaHostInput.value = config.ollamaHost || '';
 
     // Apply Gemini model
     applyModelSelection(config.geminiModel);
@@ -95,7 +103,7 @@ function applyConfig(config) {
 
     const localApiBaseUrlInput = document.getElementById('local-api-base-url');
     if (localApiBaseUrlInput) {
-        localApiBaseUrlInput.value = config.localApiBaseUrl || 'http://localhost:1234/v1';
+        localApiBaseUrlInput.value = config.localApiBaseUrl || '';
     }
 
     const localModelNameInput = document.getElementById('local-model-name');
@@ -142,6 +150,8 @@ function applyConfig(config) {
     // Plugins logic
     updatePluginButton('spotify', config.pluginSpotifyEnabled);
     updatePluginButton('calendar', config.pluginCalendarEnabled);
+    updatePluginButton('gmail', config.pluginGmailEnabled);
+    updatePluginButton('notion', config.pluginNotionEnabled);
     updatePluginButton('discord', config.pluginDiscordEnabled);
 
     // Apply Automation Browser
@@ -691,7 +701,7 @@ function updatePluginButton(pluginName, isEnabled) {
 }
 
 // Bind plugin buttons
-['spotify', 'calendar', 'discord'].forEach(plugin => {
+['spotify', 'calendar', 'gmail', 'notion', 'discord'].forEach(plugin => {
     const btn = document.getElementById(`btn-plugin-${plugin}`);
     if (btn) {
         btn.addEventListener('click', () => {

package/src/UI/styles.css

@@ -251,6 +251,19 @@ h1 {
   padding: 0 6px;
   opacity: 0.7;
   font-weight: 400;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.provider-badge {
+  max-width: min(320px, 70vw);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--accent);
+  font-weight: 600;
 }
 
 @keyframes messagePopIn {
@@ -648,4 +661,4 @@ input:checked + .slider:before {
 
 .suggestion-chip:active {
   transform: scale(0.97);
-}
+}

package/tests/action_executor_safety.test.js

@@ -0,0 +1,67 @@
+jest.mock('electron', () => ({
+    clipboard: {
+        writeText: jest.fn()
+    }
+}));
+
+jest.mock('../src/Automation_Layer/file_operations', () => ({
+    createFolder: jest.fn(() => ({ success: true })),
+    openFile: jest.fn(async () => true),
+    deleteFile: jest.fn(async () => ({ success: true })),
+    findPath: jest.fn(() => ({ success: false, message: 'not found', matches: [] }))
+}));
+
+jest.mock('../src/Automation_Layer/open_app', () => ({
+    openApp: jest.fn()
+}));
+
+jest.mock('../src/Automation_Layer/open_website', () => ({
+    openWebsite: jest.fn(),
+    openSearch: jest.fn()
+}));
+
+jest.mock('../src/Automation_Layer/browser_automation', () => ({
+    performWebAutomation: jest.fn(async () => 'done')
+}));
+
+jest.mock('../src/AI_Brain/knowledge_base', () => ({
+    indexFile: jest.fn(async () => 'indexed'),
+    indexFolder: jest.fn(async () => 'indexed')
+}));
+
+jest.mock('../src/Plugins/plugin_manager', () => ({
+    executePlugin: jest.fn()
+}));
+
+jest.mock('../src/Plugins/mcp_manager', () => ({
+    callTool: jest.fn()
+}));
+
+jest.mock('../src/System/granular_automation', () => ({
+    mouseMove: jest.fn(),
+    mouseClick: jest.fn(),
+    typeText: jest.fn(),
+    keyTap: jest.fn()
+}));
+
+jest.mock('../src/System/system_automation', () => ({
+    shutdown: jest.fn(),
+    restart: jest.fn(),
+    sleep: jest.fn(),
+    setVolume: jest.fn(),
+    mute: jest.fn(),
+    setBrightness: jest.fn(),
+    minimizeAll: jest.fn()
+}));
+
+describe('action_executor safety integration', () => {
+    test('blocks dangerous delete actions unless explicitly allowed', async () => {
+        const { executeAction } = require('../src/System/action_executor');
+        await expect(executeAction({ type: 'delete_file', target: 'notes.txt' })).rejects.toThrow(/Dangerous action/);
+    });
+
+    test('allows dangerous actions with explicit permission flag', async () => {
+        const { executeAction } = require('../src/System/action_executor');
+        await expect(executeAction({ type: 'delete_file', target: 'notes.txt' }, { allowDangerous: true })).resolves.toBeUndefined();
+    });
+});

package/tests/gmail.test.js

@@ -0,0 +1,135 @@
+/**
+ * Tests: gmail.js plugin
+ */
+
+jest.mock('axios', () => ({
+    post: jest.fn(),
+    get: jest.fn()
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn()
+}));
+
+const axios = require('axios');
+const { readConfig } = require('../src/System/config_manager');
+const gmail = require('../src/Plugins/gmail');
+
+describe('gmail plugin', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('has required plugin fields', () => {
+        expect(gmail.name).toBe('gmail');
+        expect(typeof gmail.description).toBe('string');
+        expect(typeof gmail.execute).toBe('function');
+    });
+
+    test('returns configuration message when OAuth config is missing', async () => {
+        readConfig.mockReturnValue({});
+
+        const result = await gmail.execute('inbox');
+
+        expect(result).toContain('Gmail API is not configured');
+        expect(axios.get).not.toHaveBeenCalled();
+    });
+
+    test('searches Gmail and fetches metadata for results', async () => {
+        readConfig.mockReturnValue({
+            gmailClientId: 'client-id',
+            gmailClientSecret: 'client-secret',
+            gmailRefreshToken: 'refresh-token',
+            gmailUserId: 'me'
+        });
+        axios.post.mockResolvedValueOnce({ data: { access_token: 'access-token' } });
+        axios.get
+            .mockResolvedValueOnce({ data: { messages: [{ id: 'msg-1' }] } })
+            .mockResolvedValueOnce({
+                data: {
+                    id: 'msg-1',
+                    snippet: 'Hello snippet',
+                    payload: {
+                        headers: [
+                            { name: 'From', value: 'A <a@example.com>' },
+                            { name: 'Subject', value: 'Hello' },
+                            { name: 'Date', value: 'Fri, 15 May 2026 10:00:00 +0700' }
+                        ]
+                    }
+                }
+            });
+
+        const result = await gmail.execute(JSON.stringify({ action: 'search', query: 'is:unread', limit: 1 }));
+
+        expect(axios.get).toHaveBeenCalledTimes(2);
+        expect(axios.get.mock.calls[0][0]).toBe('https://gmail.googleapis.com/gmail/v1/users/me/messages');
+        expect(result).toContain('Hello');
+        expect(result).toContain('msg-1');
+    });
+
+    test('reads full Gmail message body', async () => {
+        readConfig.mockReturnValue({
+            gmailClientId: 'client-id',
+            gmailClientSecret: 'client-secret',
+            gmailRefreshToken: 'refresh-token',
+            gmailUserId: 'me'
+        });
+        axios.post.mockResolvedValueOnce({ data: { access_token: 'access-token' } });
+        axios.get.mockResolvedValueOnce({
+            data: {
+                id: 'msg-1',
+                payload: {
+                    headers: [
+                        { name: 'From', value: 'A <a@example.com>' },
+                        { name: 'Subject', value: 'Hello' }
+                    ],
+                    mimeType: 'text/plain',
+                    body: { data: gmail._helpers.encodeBase64Url('Full body text') }
+                }
+            }
+        });
+
+        const result = await gmail.execute(JSON.stringify({ action: 'read', id: 'msg-1' }));
+
+        expect(result).toContain('Full body text');
+        expect(result).toContain('Hello');
+    });
+
+    test('creates Gmail draft only', async () => {
+        readConfig.mockReturnValue({
+            gmailClientId: 'client-id',
+            gmailClientSecret: 'client-secret',
+            gmailRefreshToken: 'refresh-token',
+            gmailUserId: 'me'
+        });
+        axios.post
+            .mockResolvedValueOnce({ data: { access_token: 'access-token' } })
+            .mockResolvedValueOnce({ data: { id: 'draft-1' } });
+
+        const result = await gmail.execute(JSON.stringify({
+            action: 'draft',
+            to: 'person@example.com',
+            subject: 'Draft subject',
+            body: 'Draft body'
+        }));
+
+        expect(axios.post).toHaveBeenCalledTimes(2);
+        expect(axios.post.mock.calls[1][0]).toBe('https://gmail.googleapis.com/gmail/v1/users/me/drafts');
+        expect(axios.post.mock.calls[1][1].message.raw).toBeTruthy();
+        expect(result).toContain('Created Gmail draft');
+        expect(result).toContain('Review it in Gmail before sending');
+    });
+
+    test('buildRawEmail removes newline injection from headers', () => {
+        const raw = gmail._helpers.buildRawEmail({
+            to: 'person@example.com\nBcc: attacker@example.com',
+            subject: 'Hello\r\nBad: header',
+            body: 'Body'
+        });
+        const decoded = gmail._helpers.decodeBase64Url(raw);
+
+        expect(decoded).toContain('To: person@example.com Bcc: attacker@example.com');
+        expect(decoded).toContain('Subject: Hello Bad: header');
+        expect(decoded).not.toContain('\nBcc: attacker@example.com');
+    });
+});

package/tests/gmail_auth.test.js

@@ -0,0 +1,129 @@
+/**
+ * Tests: gmail_auth.js OAuth helper
+ */
+
+jest.mock('axios', () => ({
+    post: jest.fn()
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn(),
+    writeConfig: jest.fn()
+}));
+
+const axios = require('axios');
+const gmailAuth = require('../src/CLI/gmail_auth');
+
+describe('gmail_auth helper', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('buildAuthUrl includes offline access and consent prompt', () => {
+        const url = gmailAuth.buildAuthUrl({
+            clientId: 'client-id',
+            redirectUri: 'http://127.0.0.1:3333/oauth2callback',
+            state: 'state-1'
+        });
+
+        const parsed = new URL(url);
+        expect(parsed.origin + parsed.pathname).toBe('https://accounts.google.com/o/oauth2/v2/auth');
+        expect(parsed.searchParams.get('client_id')).toBe('client-id');
+        expect(parsed.searchParams.get('access_type')).toBe('offline');
+        expect(parsed.searchParams.get('prompt')).toBe('consent');
+        expect(parsed.searchParams.get('scope')).toContain('gmail.readonly');
+        expect(parsed.searchParams.get('scope')).toContain('gmail.compose');
+    });
+
+    test('exchanges authorization code for token', async () => {
+        axios.post.mockResolvedValueOnce({
+            data: {
+                refresh_token: 'refresh-token'
+            }
+        });
+
+        const token = await gmailAuth.exchangeCodeForToken({
+            clientId: 'client-id',
+            clientSecret: 'client-secret',
+            code: 'code-1',
+            redirectUri: 'http://127.0.0.1:3333/oauth2callback'
+        });
+
+        expect(token.refresh_token).toBe('refresh-token');
+        expect(axios.post).toHaveBeenCalledWith(
+            'https://oauth2.googleapis.com/token',
+            expect.stringContaining('grant_type=authorization_code'),
+            expect.any(Object)
+        );
+    });
+
+    test('runGmailAuth opens browser, accepts callback, and saves refresh token', async () => {
+        axios.post.mockResolvedValueOnce({
+            data: {
+                refresh_token: 'new-refresh-token'
+            }
+        });
+
+        const writeConfig = jest.fn(() => ({ success: true }));
+        const result = await gmailAuth.runGmailAuth({
+            readConfig: () => ({
+                gmailClientId: 'client-id',
+                gmailClientSecret: 'client-secret',
+                gmailUserId: 'me'
+            }),
+            writeConfig,
+            logger: { log: jest.fn() },
+            openBrowser: jest.fn(),
+            getAuthorizationCode: async ({ authUrl, state, redirectUri }) => {
+                expect(authUrl).toContain(encodeURIComponent(redirectUri));
+                expect(state).toBeTruthy();
+                return 'auth-code';
+            },
+            timeoutMs: 5000
+        });
+
+        expect(result.success).toBe(true);
+        expect(writeConfig).toHaveBeenCalledWith(expect.objectContaining({
+            gmailRefreshToken: 'new-refresh-token',
+            gmailUserId: 'me',
+            pluginGmailEnabled: true
+        }));
+    });
+
+    test('runGmailAuth can print link without opening browser', async () => {
+        axios.post.mockResolvedValueOnce({
+            data: {
+                refresh_token: 'manual-refresh-token'
+            }
+        });
+
+        const openBrowser = jest.fn();
+        const writeConfig = jest.fn(() => ({ success: true }));
+
+        const result = await gmailAuth.runGmailAuth({
+            readConfig: () => ({
+                gmailClientId: 'client-id',
+                gmailClientSecret: 'client-secret',
+                gmailUserId: 'me'
+            }),
+            writeConfig,
+            logger: { log: jest.fn() },
+            openBrowser: false,
+            getAuthorizationCode: async () => 'manual-code'
+        });
+
+        expect(result.success).toBe(true);
+        expect(openBrowser).not.toHaveBeenCalled();
+        expect(writeConfig).toHaveBeenCalledWith(expect.objectContaining({
+            gmailRefreshToken: 'manual-refresh-token'
+        }));
+    });
+
+    test('runGmailAuth requires saved client credentials', async () => {
+        await expect(gmailAuth.runGmailAuth({
+            readConfig: () => ({}),
+            openBrowser: jest.fn(),
+            logger: { log: jest.fn() }
+        })).rejects.toThrow('Missing Gmail OAuth Client ID');
+    });
+});

package/tests/google_calendar.test.js

@@ -0,0 +1,113 @@
+/**
+ * Tests: google_calendar.js plugin
+ */
+
+jest.mock('axios', () => ({
+    post: jest.fn(),
+    get: jest.fn()
+}));
+
+jest.mock('electron', () => ({
+    shell: {
+        openExternal: jest.fn()
+    }
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn()
+}));
+
+const axios = require('axios');
+const { shell } = require('electron');
+const { readConfig } = require('../src/System/config_manager');
+
+describe('google_calendar plugin', () => {
+    let plugin;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        plugin = require('../src/Plugins/google_calendar');
+    });
+
+    test('has required plugin fields', () => {
+        expect(plugin.name).toBe('google_calendar');
+        expect(typeof plugin.description).toBe('string');
+        expect(typeof plugin.execute).toBe('function');
+    });
+
+    test('falls back to opening Google Calendar when API config is missing', async () => {
+        readConfig.mockReturnValue({});
+
+        const result = await plugin.execute('open');
+
+        expect(shell.openExternal).toHaveBeenCalledWith('https://calendar.google.com/');
+        expect(result).toContain('Google Calendar');
+    });
+
+    test('creates event through Google Calendar API', async () => {
+        readConfig.mockReturnValue({
+            googleCalendarClientId: 'client-id',
+            googleCalendarClientSecret: 'client-secret',
+            googleCalendarRefreshToken: 'refresh-token',
+            googleCalendarId: 'primary'
+        });
+        axios.post
+            .mockResolvedValueOnce({ data: { access_token: 'access-token' } })
+            .mockResolvedValueOnce({
+                data: {
+                    summary: 'Demo meeting',
+                    htmlLink: 'https://calendar.google.com/event/demo'
+                }
+            });
+
+        const result = await plugin.execute(JSON.stringify({
+            action: 'create',
+            summary: 'Demo meeting',
+            start: '2026-05-15T10:00:00+07:00',
+            end: '2026-05-15T11:00:00+07:00'
+        }));
+
+        expect(axios.post).toHaveBeenCalledTimes(2);
+        expect(axios.post.mock.calls[1][0]).toContain('/calendars/primary/events');
+        expect(axios.post.mock.calls[1][1].summary).toBe('Demo meeting');
+        expect(result).toContain('Demo meeting');
+        expect(result).toContain('https://calendar.google.com/event/demo');
+    });
+
+    test('lists upcoming events through Google Calendar API', async () => {
+        readConfig.mockReturnValue({
+            googleCalendarClientId: 'client-id',
+            googleCalendarClientSecret: 'client-secret',
+            googleCalendarRefreshToken: 'refresh-token',
+            googleCalendarId: 'primary'
+        });
+        axios.post.mockResolvedValueOnce({ data: { access_token: 'access-token' } });
+        axios.get.mockResolvedValueOnce({
+            data: {
+                items: [
+                    {
+                        summary: 'Planning',
+                        start: { dateTime: '2026-05-15T10:00:00+07:00' },
+                        end: { dateTime: '2026-05-15T11:00:00+07:00' }
+                    }
+                ]
+            }
+        });
+
+        const result = await plugin.execute(JSON.stringify({ action: 'list', days: 3 }));
+
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(axios.get.mock.calls[0][0]).toContain('/calendars/primary/events');
+        expect(result).toContain('Planning');
+    });
+
+    test('builds all-day event payload with exclusive end date', () => {
+        const payload = plugin._helpers.buildEventPayload({
+            summary: 'All day',
+            date: '2026-05-15'
+        });
+
+        expect(payload.start).toEqual({ date: '2026-05-15' });
+        expect(payload.end).toEqual({ date: '2026-05-16' });
+    });
+});

package/tests/google_tts_urls.test.js

@@ -0,0 +1,24 @@
+const { getGoogleTtsUrls, splitTextForTts } = require('../src/System/google_tts_urls');
+
+describe('google_tts_urls', () => {
+    test('returns no URLs for empty text', () => {
+        expect(getGoogleTtsUrls('')).toEqual([]);
+    });
+
+    test('builds Google Translate TTS URLs with encoded text', () => {
+        const urls = getGoogleTtsUrls('hello world', { lang: 'en' });
+
+        expect(urls).toHaveLength(1);
+        expect(urls[0].shortText).toBe('hello world');
+        expect(urls[0].url).toContain('translate_tts?');
+        expect(urls[0].url).toContain('q=hello+world');
+        expect(urls[0].url).toContain('tl=en');
+    });
+
+    test('splits long text into bounded chunks', () => {
+        const chunks = splitTextForTts('a '.repeat(150), 50);
+
+        expect(chunks.length).toBeGreaterThan(1);
+        expect(chunks.every(chunk => chunk.length <= 50)).toBe(true);
+    });
+});

package/tests/notion.test.js

@@ -0,0 +1,121 @@
+/**
+ * Tests: notion.js plugin
+ */
+
+jest.mock('axios', () => ({
+    post: jest.fn(),
+    patch: jest.fn()
+}));
+
+jest.mock('../src/System/config_manager', () => ({
+    readConfig: jest.fn()
+}));
+
+const axios = require('axios');
+const { readConfig } = require('../src/System/config_manager');
+const notion = require('../src/Plugins/notion');
+
+describe('notion plugin', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('has required plugin fields', () => {
+        expect(notion.name).toBe('notion');
+        expect(typeof notion.description).toBe('string');
+        expect(typeof notion.execute).toBe('function');
+    });
+
+    test('returns configuration message when API key is missing', async () => {
+        readConfig.mockReturnValue({});
+
+        const result = await notion.execute('My note');
+
+        expect(result).toContain('Notion API is not configured');
+        expect(axios.post).not.toHaveBeenCalled();
+    });
+
+    test('creates a page in default database', async () => {
+        readConfig.mockReturnValue({
+            notionApiKey: 'secret',
+            notionDatabaseId: 'db-id',
+            notionTitleProperty: 'Name'
+        });
+        axios.post.mockResolvedValueOnce({
+            data: {
+                url: 'https://notion.so/page'
+            }
+        });
+
+        const result = await notion.execute(JSON.stringify({
+            action: 'create_page',
+            title: 'Project note',
+            content: 'Body text'
+        }));
+
+        expect(axios.post).toHaveBeenCalledTimes(1);
+        expect(axios.post.mock.calls[0][0]).toBe('https://api.notion.com/v1/pages');
+        expect(axios.post.mock.calls[0][1].parent).toEqual({ database_id: 'db-id' });
+        expect(axios.post.mock.calls[0][1].properties.Name.title[0].text.content).toBe('Project note');
+        expect(result).toContain('Project note');
+        expect(result).toContain('https://notion.so/page');
+    });
+
+    test('queries database pages', async () => {
+        readConfig.mockReturnValue({
+            notionApiKey: 'secret',
+            notionDatabaseId: 'db-id'
+        });
+        axios.post.mockResolvedValueOnce({
+            data: {
+                results: [
+                    {
+                        url: 'https://notion.so/one',
+                        properties: {
+                            Name: {
+                                type: 'title',
+                                title: [{ plain_text: 'First page' }]
+                            }
+                        }
+                    }
+                ]
+            }
+        });
+
+        const result = await notion.execute(JSON.stringify({ action: 'query_database', limit: 1 }));
+
+        expect(axios.post).toHaveBeenCalledWith(
+            'https://api.notion.com/v1/databases/db-id/query',
+            { page_size: 1 },
+            expect.any(Object)
+        );
+        expect(result).toContain('First page');
+    });
+
+    test('appends blocks to default page', async () => {
+        readConfig.mockReturnValue({
+            notionApiKey: 'secret',
+            notionPageId: 'page-id'
+        });
+        axios.patch.mockResolvedValueOnce({
+            data: { results: [{ id: 'block-1' }] }
+        });
+
+        const result = await notion.execute(JSON.stringify({
+            action: 'append_block',
+            content: 'Follow-up note'
+        }));
+
+        expect(axios.patch).toHaveBeenCalledTimes(1);
+        expect(axios.patch.mock.calls[0][0]).toBe('https://api.notion.com/v1/blocks/page-id/children');
+        expect(result).toContain('Appended 1 block');
+    });
+
+    test('plain text becomes create_page instruction', () => {
+        const parsed = notion._helpers.parseInstruction('Title line\n\nBody line');
+
+        expect(parsed.action).toBe('create_page');
+        expect(parsed.title).toBe('Title line');
+        expect(parsed.content).toBe('Body line');
+    });
+});