@pheem49/mint 1.4.1 → 1.5.0

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

package/src/System/bridge_manager.js

@@ -0,0 +1,76 @@
+const { readConfig } = require('./config_manager');
+const path = require('path');
+const fs = require('fs');
+
+class BridgeManager {
+    constructor() {
+        this.bridges = new Map();
+        this.channelsDir = path.join(__dirname, '..', 'Channels');
+        
+        if (!fs.existsSync(this.channelsDir)) {
+            fs.mkdirSync(this.channelsDir, { recursive: true });
+        }
+    }
+
+    async init() {
+        const config = readConfig();
+        console.log('[BridgeManager] Initializing messaging bridges...');
+
+        // Load Discord Bridge
+        if (config.enableDiscordBridge && config.discordBotToken) {
+            await this.startBridge('discord', config.discordBotToken);
+        }
+
+        // Load Telegram Bridge
+        if (config.enableTelegramBridge && config.telegramBotToken) {
+            await this.startBridge('telegram', config.telegramBotToken);
+        }
+
+        // Load Slack Bridge
+        if (config.enableSlackBridge && config.slackBotToken && config.slackAppToken) {
+            await this.startBridge('slack', { botToken: config.slackBotToken, appToken: config.slackAppToken });
+        }
+
+        // Load LINE Bridge
+        if (config.enableLineBridge && config.lineChannelAccessToken && config.lineChannelSecret) {
+            await this.startBridge('line', { accessToken: config.lineChannelAccessToken, secret: config.lineChannelSecret, port: config.lineWebhookPort });
+        }
+
+        // Load WhatsApp Bridge
+        if (config.enableWhatsappBridge) {
+            await this.startBridge('whatsapp', null);
+        }
+    }
+
+    async startBridge(type, credentials) {
+        try {
+            const bridgePath = path.join(this.channelsDir, `${type}_bridge.js`);
+            if (!fs.existsSync(bridgePath)) {
+                console.error(`[BridgeManager] Bridge file not found: ${bridgePath}`);
+                return;
+            }
+
+            const BridgeClass = require(bridgePath);
+            const bridge = new BridgeClass(credentials);
+            await bridge.connect();
+            this.bridges.set(type, bridge);
+            console.log(`[BridgeManager] ${type.toUpperCase()} bridge connected successfully.`);
+        } catch (err) {
+            console.error(`[BridgeManager] Failed to start ${type} bridge:`, err.message);
+        }
+    }
+
+    async shutdown() {
+        for (const [type, bridge] of this.bridges.entries()) {
+            try {
+                await bridge.disconnect();
+                console.log(`[BridgeManager] ${type.toUpperCase()} bridge disconnected.`);
+            } catch (err) {
+                console.error(`[BridgeManager] Error disconnecting ${type} bridge:`, err.message);
+            }
+        }
+        this.bridges.clear();
+    }
+}
+
+module.exports = new BridgeManager();

package/src/System/chat_history_manager.js

@@ -10,14 +10,32 @@ try {
     app = null;
 }
 
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'mint');
 const MINT_DIR = path.join(os.homedir(), '.mint');
-if (!fs.existsSync(MINT_DIR)) {
-    fs.mkdirSync(MINT_DIR, { recursive: true });
+
+if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
 }
 
-const CHAT_HISTORY_PATH = app && app.getPath 
-    ? path.join(app.getPath('userData'), 'mint-chat-history.json')
-    : path.join(MINT_DIR, 'mint-chat-history.json');
+const CHAT_HISTORY_PATH = path.join(CONFIG_DIR, 'mint-chat-history.json');
+
+// Migration Logic: Consolidate from Electron userData or old ~/.mint to ~/.config/mint
+if (!fs.existsSync(CHAT_HISTORY_PATH)) {
+    const electronUserData = app && app.getPath ? path.join(app.getPath('userData'), 'mint-chat-history.json') : null;
+    const legacyPath = path.join(MINT_DIR, 'mint-chat-history.json');
+
+    if (electronUserData && fs.existsSync(electronUserData)) {
+        try {
+            fs.copyFileSync(electronUserData, CHAT_HISTORY_PATH);
+            console.log('[History] Migrated chat history from Electron userData');
+        } catch (e) { console.error('[History] Migration from Electron failed:', e); }
+    } else if (fs.existsSync(legacyPath)) {
+        try {
+            fs.copyFileSync(legacyPath, CHAT_HISTORY_PATH);
+            console.log('[History] Migrated chat history from ~/.mint');
+        } catch (e) { console.error('[History] Migration from ~/.mint failed:', e); }
+    }
+}
 
 function readChatHistory() {
     try {

package/src/System/config_manager.js

@@ -53,21 +53,53 @@ const DEFAULT_CONFIG = {
     ttsVolume: 1.0,
     ttsSpeed: 1.0,
     ttsPitch: 1.0,
-    pluginSpotifyEnabled: true,
     pluginCalendarEnabled: false,
+    pluginGmailEnabled: false,
+    pluginNotionEnabled: false,
     pluginDiscordEnabled: false,
     showDesktopWidget: true,
     mcpServers: {},
+    telegramBotToken: '',
+    enableTelegramBridge: false,
+    discordBotToken: '',
+    enableDiscordBridge: false,
+    slackBotToken: '',
+    slackAppToken: '',
+    enableSlackBridge: false,
+    lineChannelAccessToken: '',
+    lineChannelSecret: '',
+    enableLineBridge: false,
+    lineWebhookPort: 3000,
+    enableWhatsappBridge: false,
+    googleSearchApiKey: '',
+    googleSearchCx: '',
+    googleCalendarClientId: '',
+    googleCalendarClientSecret: '',
+    googleCalendarRefreshToken: '',
+    googleCalendarId: 'primary',
+    gmailClientId: '',
+    gmailClientSecret: '',
+    gmailRefreshToken: '',
+    gmailUserId: 'me',
+    notionApiKey: '',
+    notionDatabaseId: '',
+    notionPageId: '',
+    notionTitleProperty: 'Name',
+    braveSearchApiKey: '',
     anthropicApiKey: '',
+
     openaiApiKey: '',
     hfApiKey: '',
     anthropicModel: 'claude-3-5-sonnet-latest',
     openaiModel: 'gpt-4o',
     hfModel: 'meta-llama/Meta-Llama-3-8B-Instruct',
-    localApiBaseUrl: 'http://localhost:1234/v1',
+    localApiBaseUrl: '',
     localModelName: 'local-model',
-    ollamaHost: 'http://localhost:11434',
-    enableAgentCollaboration: true
+    ollamaHost: '',
+    enableAgentCollaboration: false,
+    enableAutoUpdate: true,
+    autoUpdateCheckIntervalHours: 24,
+    lastUpdateCheckAt: ''
 };
 
 
@@ -100,8 +132,6 @@ function getAvailableProviders(config) {
     const providers = [];
     const cfg = config || readConfig();
     
-    const isPlaceholder = (val) => !val || val.startsWith('your_') || val.includes('key_here') || val.trim() === '';
-
     // Check which providers have API keys or URLs configured
     const anthropicKey = cfg.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
     if (!isPlaceholder(anthropicKey)) providers.push('anthropic');
@@ -123,4 +153,8 @@ function getAvailableProviders(config) {
     return providers;
 }
 
-module.exports = { readConfig, writeConfig, getAvailableProviders, CONFIG_PATH };
+function isPlaceholder(val) {
+    return !val || val.startsWith('your_') || val.includes('key_here') || val.trim() === '';
+}
+
+module.exports = { readConfig, writeConfig, getAvailableProviders, isPlaceholder, CONFIG_PATH };

package/src/System/custom_workflows.js

@@ -1,15 +1,27 @@
 const fs = require('fs');
 const path = require('path');
-const { app, shell } = require('electron');
+const os = require('os');
 const { exec } = require('child_process');
 
+// Handle electron dependency safely
+let app, shell;
+try {
+    const electron = require('electron');
+    app = electron.app;
+    shell = electron.shell;
+} catch (e) {
+    app = null;
+    shell = null;
+}
+
 function escapeRegExp(text) {
     return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 class CustomWorkflows {
     constructor() {
-        this.configPath = path.join(app.getPath('userData'), 'workflows.json');
+        const configDir = path.join(os.homedir(), '.config', 'mint');
+        this.configPath = path.join(configDir, 'workflows.json');
         this.workflows = [];
         this.lastTriggered = {};
         this.cooldownMs = 60 * 60 * 1000; // 1 hour cooldown per rule
@@ -17,10 +29,27 @@ class CustomWorkflows {
         this.timer = null;
         this.webContents = null;
         
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+
+        this.migrateConfig();
         this.ensureConfigExists();
         this.loadWorkflows();
     }
     
+    migrateConfig() {
+        if (!fs.existsSync(this.configPath) && app && app.getPath) {
+            const electronPath = path.join(app.getPath('userData'), 'workflows.json');
+            if (fs.existsSync(electronPath)) {
+                try {
+                    fs.copyFileSync(electronPath, this.configPath);
+                    console.log('[CustomWorkflows] Migrated workflows from Electron userData');
+                } catch (e) { console.error('[CustomWorkflows] Migration failed:', e); }
+            }
+        }
+    }
+    
     ensureConfigExists() {
         if (!fs.existsSync(this.configPath)) {
             const defaultWorkflows = [

package/src/System/google_tts_urls.js

@@ -0,0 +1,51 @@
+const MAX_GOOGLE_TTS_CHARS = 200;
+
+function splitTextForTts(text, maxLength = MAX_GOOGLE_TTS_CHARS) {
+    const normalized = String(text || '').replace(/\s+/g, ' ').trim();
+    if (!normalized) return [];
+
+    const chunks = [];
+    let remaining = normalized;
+
+    while (remaining.length > maxLength) {
+        const slice = remaining.slice(0, maxLength + 1);
+        const splitAt = Math.max(
+            slice.lastIndexOf('.'),
+            slice.lastIndexOf('?'),
+            slice.lastIndexOf('!'),
+            slice.lastIndexOf(','),
+            slice.lastIndexOf(' ')
+        );
+        const safeSplit = splitAt > 0 ? splitAt : maxLength;
+        chunks.push(remaining.slice(0, safeSplit).trim());
+        remaining = remaining.slice(safeSplit).trim();
+    }
+
+    if (remaining) chunks.push(remaining);
+    return chunks;
+}
+
+function getGoogleTtsUrls(text, options = {}) {
+    const lang = options.lang || 'en';
+    const host = options.host || 'https://translate.google.com';
+    const chunks = splitTextForTts(text);
+
+    return chunks.map((chunk, index) => {
+        const params = new URLSearchParams({
+            ie: 'UTF-8',
+            q: chunk,
+            tl: lang,
+            client: 'tw-ob',
+            idx: String(index),
+            total: String(chunks.length),
+            textlen: String(chunk.length)
+        });
+
+        return {
+            shortText: chunk,
+            url: `${host}/translate_tts?${params.toString()}`
+        };
+    });
+}
+
+module.exports = { getGoogleTtsUrls, splitTextForTts };