@pheem49/mint 1.4.2 → 1.5.0

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: false
+    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 };

package/src/System/ipc_handlers.js

@@ -0,0 +1,238 @@
+function registerIpcHandlers({
+    app,
+    ipcMain,
+    shell,
+    clipboard,
+    windowManager,
+    proactiveLoop,
+    screenCapture,
+    services
+}) {
+    const {
+        handleChat,
+        resetChat,
+        getChatTranscript,
+        refreshApiKeyFromConfig,
+        getSystemInfo,
+        getWeather,
+        readConfig,
+        writeConfig,
+        parseCommand,
+        executeAction,
+        getGoogleTtsUrls,
+        customWorkflows
+    } = services;
+
+    ipcMain.handle('chat-message', async (event, message, base64Image = null, base64Audio = null) => {
+        try {
+            const rawResponse = await handleChat(message, base64Image, base64Audio);
+            const aiResponse = parseCommand(rawResponse);
+
+            if (aiResponse.action && aiResponse.action.type !== 'none') {
+                try {
+                    const actionResult = await executeAction(aiResponse.action, { clipboard });
+                    if (actionResult && typeof actionResult === 'string') {
+                        aiResponse.response += `\n\n${actionResult}`;
+                    }
+                } catch (err) {
+                    console.error("Action execution error:", err);
+                    aiResponse.response += "\n\n(Note: I tried to execute the action, but an error occurred.)";
+                }
+            }
+
+            return aiResponse;
+        } catch (error) {
+            console.error('Chat error:', error);
+            return { response: 'Error communicating with Gemini API. Check your console and API key.', action: { type: 'none' } };
+        }
+    });
+
+    ipcMain.on('close-window', () => {
+        const mainWindow = windowManager.getMainWindow();
+        if (mainWindow) mainWindow.hide();
+    });
+
+    ipcMain.on('minimize-window', () => {
+        const mainWindow = windowManager.getMainWindow();
+        if (mainWindow) mainWindow.minimize();
+    });
+
+    ipcMain.on('quit-app', () => {
+        app.isQuiting = true;
+        app.quit();
+    });
+
+    ipcMain.on('maximize-window', () => {
+        const mainWindow = windowManager.getMainWindow();
+        if (!mainWindow) return;
+        if (mainWindow.isMaximized()) {
+            mainWindow.unmaximize();
+        } else {
+            mainWindow.maximize();
+        }
+    });
+
+    ipcMain.handle('reset-chat', () => {
+        resetChat();
+        return { success: true };
+    });
+
+    ipcMain.handle('get-chat-history', () => getChatTranscript());
+
+    ipcMain.handle('open-settings', () => {
+        windowManager.createSettingsWindow();
+    });
+
+    ipcMain.handle('get-settings', () => readConfig());
+
+    ipcMain.handle('save-settings', (event, config) => {
+        console.log('[Settings] Saving new config. MCP Servers count:', Object.keys(config.mcpServers || {}).length);
+        const result = writeConfig(config);
+        refreshApiKeyFromConfig();
+
+        const mainWindow = windowManager.getMainWindow();
+        if (mainWindow && !mainWindow.isDestroyed()) {
+            mainWindow.webContents.send('settings-changed', config);
+        }
+
+        if (proactiveLoop.isRunning()) {
+            proactiveLoop.start(config.proactiveInterval);
+        }
+
+        if (config.enableCustomWorkflows !== false) {
+            customWorkflows.startMonitoring(mainWindow.webContents);
+        } else {
+            customWorkflows.stopMonitoring();
+        }
+
+        if (config.showDesktopWidget === false) {
+            windowManager.closeWidgetWindow();
+        } else {
+            windowManager.ensureWidgetWindow();
+        }
+
+        return result;
+    });
+
+    ipcMain.on('set-ai-state', (event, state) => {
+        const widgetWindow = windowManager.getWidgetWindow();
+        if (widgetWindow && !widgetWindow.isDestroyed()) {
+            widgetWindow.webContents.send('widget-state', state);
+        }
+    });
+
+    ipcMain.on('close-settings', () => {
+        const settingsWindow = windowManager.getSettingsWindow();
+        if (settingsWindow) settingsWindow.close();
+    });
+
+    ipcMain.handle('open-custom-workflows', () => {
+        customWorkflows.openConfigFile();
+    });
+
+    ipcMain.handle('reload-custom-workflows', () => {
+        customWorkflows.loadWorkflows();
+        return { success: true };
+    });
+
+    ipcMain.on('spotlight-close', () => {
+        const spotlightWindow = windowManager.getSpotlightWindow();
+        if (spotlightWindow) spotlightWindow.close();
+    });
+
+    ipcMain.on('spotlight-hide', () => {
+        const spotlightWindow = windowManager.getSpotlightWindow();
+        if (spotlightWindow) spotlightWindow.hide();
+    });
+
+    ipcMain.on('spotlight-submit', async (event, query) => {
+        console.log('[Spotlight] Submit:', query);
+        const spotlightWindow = windowManager.getSpotlightWindow();
+        if (spotlightWindow) spotlightWindow.hide();
+
+        const mainWindow = windowManager.getMainWindow();
+        if (mainWindow) {
+            mainWindow.show();
+            mainWindow.webContents.send('spotlight-to-chat', query);
+        }
+    });
+
+    ipcMain.on('spotlight-resize', (event, width, height) => {
+        const spotlightWindow = windowManager.getSpotlightWindow();
+        if (spotlightWindow) spotlightWindow.setSize(width, height);
+    });
+
+    ipcMain.handle('open-external', (event, url) => {
+        shell.openExternal(url);
+    });
+
+    ipcMain.handle('clipboard-read', () => clipboard.readText());
+
+    ipcMain.handle('clipboard-write', (event, text) => {
+        clipboard.writeText(text);
+        return { success: true };
+    });
+
+    ipcMain.handle('get-tts-urls', async (event, text) => {
+        try {
+            const isThai = /[\u0E00-\u0E7F]/.test(text);
+            return getGoogleTtsUrls(text, {
+                lang: isThai ? 'th' : 'en',
+                host: 'https://translate.google.com',
+            });
+        } catch (e) {
+            console.error("TTS Error:", e);
+            return [];
+        }
+    });
+
+    ipcMain.handle('get-system-info', async () => getSystemInfo());
+    ipcMain.handle('get-weather', async (event, city) => getWeather(city));
+
+    ipcMain.handle('start-screen-capture', () => screenCapture.startScreenCapture());
+    ipcMain.on('vision-selection', (event, base64Image) => screenCapture.handleSelection(base64Image));
+    ipcMain.on('vision-translate-start', (event, rect) => screenCapture.startLiveTranslate(rect));
+    ipcMain.on('vision-translate-stop', () => screenCapture.stopLiveTranslate());
+    ipcMain.on('vision-overlay-interactable', (event, isInteractable) => screenCapture.setOverlayInteractable(isInteractable));
+    ipcMain.on('vision-cancel', () => screenCapture.cancel());
+    ipcMain.handle('capture-silent-screen', () => screenCapture.captureSilentScreen());
+
+    ipcMain.on('toggle-proactive', (event, isOn) => {
+        if (isOn) {
+            proactiveLoop.start();
+        } else {
+            proactiveLoop.stop();
+        }
+    });
+
+    ipcMain.on('record-behavior', (event, contextDescription) => {
+        proactiveLoop.recordBehavior(contextDescription);
+    });
+
+    ipcMain.handle('execute-proactive-action', async (event, action) => {
+        if (!action || action.type === 'none') {
+            return { success: false, message: 'ไม่มี action ที่จะดำเนินการค่ะ' };
+        }
+        try {
+            const result = await executeAction(action, { clipboard });
+            const messages = {
+                open_url: `เปิดเว็บไซต์ให้แล้วค่ะ 🌐`,
+                open_app: `เปิดแอป ${action.target} ให้แล้วค่ะ 🚀`,
+                search: `ค้นหา "${action.target}" ให้แล้วค่ะ 🔍`,
+                web_automation: result || 'ดำเนินการเสร็จแล้วค่ะ ✅',
+                create_folder: `สร้างโฟลเดอร์ "${action.target}" แล้วค่ะ 📁`,
+                clipboard_write: `คัดลอกข้อความแล้วค่ะ 📋`,
+                learn_file: result || `เรียนรู้เอกสารเรียบร้อยค่ะ 📚`,
+            };
+            return {
+                success: true,
+                message: messages[action.type] || 'ดำเนินการเสร็จแล้วค่ะ ✅'
+            };
+        } catch (err) {
+            console.error('[ProactiveAction] Error:', err);
+            return { success: false, message: `เกิดข้อผิดพลาด: ${err.message}` };
+        }
+    });
+}
+
+module.exports = { registerIpcHandlers };

package/src/System/proactive_loop.js

@@ -0,0 +1,137 @@
+const { BrowserWindow, desktopCapturer, screen, powerMonitor } = require('electron');
+const path = require('path');
+const { analyzeAndSuggest } = require('../AI_Brain/proactive_engine');
+const { recordBehavior, getBehaviorSummary } = require('../AI_Brain/behavior_memory');
+
+const IDLE_THRESHOLD_SEC = 300;
+
+function createProactiveLoop({ app, projectRoot, readConfig, getMainWindow }) {
+    let proactiveGlowWindow = null;
+    let proactiveIntervalHandle = null;
+    let idleWatcherHandle = null;
+
+    async function runProactiveCycle() {
+        const mainWindow = getMainWindow();
+        if (!mainWindow || mainWindow.isDestroyed()) return;
+
+        try {
+            showProactiveGlow();
+
+            const primaryDisplay = screen.getPrimaryDisplay();
+            const width = Math.floor(primaryDisplay.size.width * 0.5);
+            const height = Math.floor(primaryDisplay.size.height * 0.5);
+            const sources = await desktopCapturer.getSources({
+                types: ['screen'],
+                thumbnailSize: { width, height }
+            });
+
+            const primarySource = sources[0];
+            if (!primarySource || !primarySource.thumbnail) return;
+
+            const base64Image = primarySource.thumbnail.toJPEG(60).toString('base64');
+            const result = await analyzeAndSuggest(base64Image, getBehaviorSummary());
+
+            if (result && result.message && Array.isArray(result.suggestions)) {
+                if (result.context) recordBehavior(result.context);
+
+                const currentMainWindow = getMainWindow();
+                if (currentMainWindow && !currentMainWindow.isDestroyed()) {
+                    currentMainWindow.webContents.send('proactive-suggestion', result);
+                }
+            }
+
+            hideProactiveGlow();
+        } catch (err) {
+            console.error('[Proactive] Cycle error:', err.message);
+            hideProactiveGlow();
+        }
+    }
+
+    function createProactiveGlowWindow() {
+        if (proactiveGlowWindow) return proactiveGlowWindow;
+        const { width, height } = screen.getPrimaryDisplay().bounds;
+
+        proactiveGlowWindow = new BrowserWindow({
+            width,
+            height,
+            x: 0,
+            y: 0,
+            frame: false,
+            transparent: true,
+            alwaysOnTop: true,
+            skipTaskbar: true,
+            focusable: false,
+            show: false,
+            webPreferences: {
+                nodeIntegration: false,
+                contextIsolation: true
+            }
+        });
+
+        proactiveGlowWindow.setIgnoreMouseEvents(true);
+        proactiveGlowWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+        proactiveGlowWindow.setAlwaysOnTop(true, 'screen-saver');
+        proactiveGlowWindow.loadFile(path.join(projectRoot, 'src/UI/proactive-glow.html'));
+        proactiveGlowWindow.on('closed', () => { proactiveGlowWindow = null; });
+        return proactiveGlowWindow;
+    }
+
+    function showProactiveGlow() {
+        if (!proactiveGlowWindow) createProactiveGlowWindow();
+        if (proactiveGlowWindow) proactiveGlowWindow.showInactive();
+    }
+
+    function hideProactiveGlow() {
+        if (proactiveGlowWindow && !proactiveGlowWindow.isDestroyed()) {
+            proactiveGlowWindow.hide();
+        }
+    }
+
+    function start(intervalSec) {
+        stop();
+        const cfg = readConfig();
+        const ms = (intervalSec || cfg.proactiveInterval || 60) * 1000;
+        console.log(`[Proactive] Starting loop — interval: ${ms / 1000}s`);
+        proactiveIntervalHandle = setInterval(runProactiveCycle, ms);
+    }
+
+    function stop() {
+        if (proactiveIntervalHandle) {
+            clearInterval(proactiveIntervalHandle);
+            proactiveIntervalHandle = null;
+            console.log('[Proactive] Stopped proactive loop.');
+        }
+    }
+
+    function startIdleWatcher() {
+        if (idleWatcherHandle) return;
+        idleWatcherHandle = setInterval(() => {
+            if (!proactiveIntervalHandle) return;
+            if (!app.isReady()) return;
+
+            const idleSec = powerMonitor.getSystemIdleTime();
+            if (idleSec < IDLE_THRESHOLD_SEC) return;
+
+            console.log(`[System Idle] User idle for ${idleSec}s. Pausing Proactive loop to save resources.`);
+            stop();
+
+            const resumeChecker = setInterval(() => {
+                if (powerMonitor.getSystemIdleTime() < 10) {
+                    console.log('[System Idle] User returned. Resuming Proactive loop.');
+                    clearInterval(resumeChecker);
+                    start();
+                }
+            }, 5000);
+        }, 60000);
+    }
+
+    return {
+        start,
+        stop,
+        startIdleWatcher,
+        isRunning: () => Boolean(proactiveIntervalHandle),
+        recordBehavior
+    };
+}
+
+module.exports = { createProactiveLoop };