@pheem49/mint 1.4.2 → 1.5.1

package/src/System/action_executor.js

@@ -0,0 +1,178 @@
+let electronClipboard = null;
+try {
+    ({ clipboard: electronClipboard } = require('electron'));
+} catch (_) {
+    electronClipboard = {
+        writeText: () => {}
+    };
+}
+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 { getSystemInfo, getWeather } = require('./system_info');
+const pluginManager = require('../Plugins/plugin_manager');
+const mcpManager = require('../Plugins/mcp_manager');
+const SystemAutomation = require('./system_automation');
+const safetyManager = require('./safety_manager');
+const toolRegistry = require('./tool_registry');
+const os = require('os');
+const path = require('path');
+
+async function executeAction(action, options = {}) {
+    if (process.env.MINT_DEBUG === '1') {
+        console.log("Executing action:", action);
+    }
+    toolRegistry.validateToolInput(action.type, action);
+    const clipboard = options.clipboard || electronClipboard;
+    const safety = safetyManager.assertActionAllowed(action, {
+        allowApproval: options.allowApproval === true,
+        allowDangerous: options.allowDangerous === true
+    });
+    safetyManager.appendActionLog({
+        source: options.source || 'action_executor',
+        action: action.type,
+        target: action.target || action.path || '',
+        tier: safety.tier,
+        approved: options.allowApproval === true || options.allowDangerous === true || safety.tier === safetyManager.TIERS.SAFE
+    });
+
+    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':
+            safetyManager.assertPathCapability(action.target, 'write', {
+                defaultBase: path.join(os.homedir(), 'Desktop')
+            });
+            createFolder(action.target);
+            break;
+        case 'open_file': {
+            safetyManager.assertPathCapability(action.target, 'read');
+            const fileRes = await openFile(action.target);
+            return fileRes || `Successfully opened file: ${action.target} ✅`;
+        }
+        case 'open_folder': {
+            safetyManager.assertPathCapability(action.target, 'read');
+            const folderRes = await openFile(action.target);
+            return folderRes || `Successfully opened folder: ${action.target} ✅`;
+        }
+        case 'delete_file':
+            safetyManager.assertPathCapability(action.target, 'write');
+            await deleteFile(action.target);
+            break;
+        case 'find_path':
+            return await executeFindPath(action);
+        case 'clipboard_write':
+            clipboard.writeText(action.target);
+            break;
+        case 'learn_file':
+            safetyManager.assertPathCapability(action.target, 'read');
+            return await indexFile(action.target);
+        case 'learn_folder':
+            safetyManager.assertPathCapability(action.target, 'read');
+            return await indexFolder(action.target);
+        case 'system_info':
+            return await handleSystemInfo(action.target);
+        case 'mcp_tool': {
+            const mcpResult = await mcpManager.callTool(action.server, action.target, action.args);
+            return JSON.stringify(mcpResult.content);
+        }
+        case 'mouse_move': {
+            const granularAutomation = require('./granular_automation');
+            return await granularAutomation.mouseMove(action.x, action.y);
+        }
+        case 'mouse_click': {
+            const granularAutomation = require('./granular_automation');
+            return await granularAutomation.mouseClick(action.x, action.y, action.button || 1);
+        }
+        case 'type_text': {
+            const granularAutomation = require('./granular_automation');
+            return await granularAutomation.typeText(action.target);
+        }
+        case 'key_tap': {
+            const granularAutomation = require('./granular_automation');
+            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 handleSystemInfo(target = '') {
+    const query = String(target || '').trim();
+    if (query) {
+        const weather = await getWeather(query);
+        return JSON.stringify({
+            type: 'weather',
+            target: query,
+            ...weather
+        });
+    }
+    return JSON.stringify({
+        type: 'system_info',
+        data: getSystemInfo()
+    });
+}
+
+async function executeFindPath(action) {
+    const result = findPath(action.target, {
+        type: action.pathType,
+        maxResults: 10,
+        roots: safetyManager.getAllowedRoots('read')
+    });
+    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, handleSystemInfo };

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,83 @@ 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: '',
+    safetyEnabled: true,
+    sandboxMode: 'prefer', // off | prefer | enforce
+    sandboxCommand: process.platform === 'darwin' ? 'sandbox-exec' : process.platform === 'linux' ? 'bwrap' : '',
+    allowedReadPaths: [
+        os.homedir(),
+        process.cwd(),
+        path.join(os.homedir(), 'Desktop'),
+        path.join(os.homedir(), 'Documents'),
+        path.join(os.homedir(), 'Downloads'),
+        path.join(os.homedir(), 'Pictures'),
+        path.join(os.homedir(), 'Music'),
+        path.join(os.homedir(), 'Videos')
+    ],
+    allowedWritePaths: [
+        os.homedir(),
+        process.cwd(),
+        path.join(os.homedir(), 'Desktop'),
+        path.join(os.homedir(), 'Documents'),
+        path.join(os.homedir(), 'Downloads'),
+        path.join(os.homedir(), 'Pictures'),
+        path.join(os.homedir(), 'Music'),
+        path.join(os.homedir(), 'Videos')
+    ],
+    blockedPaths: [
+        path.join(os.homedir(), '.ssh'),
+        path.join(os.homedir(), '.gnupg'),
+        path.join(os.homedir(), '.config', 'mint', 'mint-config.json'),
+        path.join(os.homedir(), '.mint', 'mint-config.json')
+    ],
+    blockedFileNames: ['.env', 'id_rsa', 'id_ed25519']
 };
 
 
@@ -100,8 +162,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 +183,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 };