@pheem49/mint 1.5.0 → 1.5.2

package/src/Channels/discord_bridge.js

@@ -1,9 +1,15 @@
-const { Client, GatewayIntentBits, Partials } = require('discord.js');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class DiscordBridge {
     constructor(token) {
         this.token = token;
+        const { Client, GatewayIntentBits, Partials } = requireOptional(
+            'discord.js',
+            'npm install discord.js'
+        );
         this.client = new Client({
             intents: [
                 GatewayIntentBits.Guilds,
@@ -21,30 +27,22 @@ class DiscordBridge {
         });
 
         this.client.on('messageCreate', async (message) => {
-            // Ignore bot messages
             if (message.author.bot) return;
-
-            // Handle DMs or Mentions
             const isDM = !message.guild;
             const isMentioned = message.mentions.has(this.client.user);
 
             if (isDM || isMentioned) {
                 try {
-                    // Clean up the message if it's a mention
                     let cleanContent = message.content;
                     if (isMentioned) {
-                        cleanContent = message.content.replace(`<@!${this.client.user.id}>`, '').replace(`<@${this.client.user.id}>`, '').trim();
+                        cleanContent = message.content
+                            .replace(`<@!${this.client.user.id}>`, '')
+                            .replace(`<@${this.client.user.id}>`, '')
+                            .trim();
                     }
-
                     if (!cleanContent) return;
-
-                    // Show typing indicator
                     await message.channel.sendTyping();
-
-                    // Send to Mint AI Brain
                     const result = await handleChat(cleanContent);
-
-                    // Reply to user
                     if (result && result.response) {
                         await message.reply(result.response);
                     }

package/src/Channels/line_bridge.js

@@ -1,22 +1,25 @@
-const line = require('@line/bot-sdk');
-const express = require('express');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class LineBridge {
     constructor(credentials) {
+        this._line    = requireOptional('@line/bot-sdk', 'npm install @line/bot-sdk express');
+        this._express = requireOptional('express',       'npm install @line/bot-sdk express');
         this.config = {
             channelAccessToken: credentials.accessToken,
             channelSecret: credentials.secret,
         };
-        this.port = credentials.port || 3000;
-        this.client = new line.messagingApi.MessagingApiClient({
+        this.port   = credentials.port || 3000;
+        this.client = new this._line.messagingApi.MessagingApiClient({
             channelAccessToken: credentials.accessToken
         });
-        this.app = express();
+        this.app    = this._express();
     }
 
     async connect() {
-        this.app.post('/callback', line.middleware(this.config), (req, res) => {
+        this.app.post('/callback', this._line.middleware(this.config), (req, res) => {
             Promise
                 .all(req.body.events.map(event => this.handleEvent(event)))
                 .then((result) => res.json(result))
@@ -36,7 +39,6 @@ class LineBridge {
         if (event.type !== 'message' || event.message.type !== 'text') {
             return Promise.resolve(null);
         }
-
         try {
             const result = await handleChat(event.message.text);
             if (result && result.response) {
@@ -51,9 +53,7 @@ class LineBridge {
     }
 
     async disconnect() {
-        if (this.server) {
-            this.server.close();
-        }
+        if (this.server) this.server.close();
     }
 }
 

package/src/Channels/slack_bridge.js

@@ -1,8 +1,11 @@
-const { App } = require('@slack/bolt');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class SlackBridge {
     constructor(credentials) {
+        const { App } = requireOptional('@slack/bolt', 'npm install @slack/bolt');
         this.app = new App({
             token: credentials.botToken,
             appToken: credentials.appToken,
@@ -15,24 +18,18 @@ class SlackBridge {
             try {
                 const text = event.text.replace(/<@.*?>/g, '').trim();
                 if (!text) return;
-
                 const result = await handleChat(text);
-                if (result && result.response) {
-                    await say(result.response);
-                }
+                if (result && result.response) await say(result.response);
             } catch (err) {
                 console.error('[Slack Bridge] Error processing app_mention:', err);
             }
         });
 
         this.app.event('message', async ({ event, say }) => {
-            // Only respond in DMs
             if (event.channel_type === 'im') {
                 try {
                     const result = await handleChat(event.text);
-                    if (result && result.response) {
-                        await say(result.response);
-                    }
+                    if (result && result.response) await say(result.response);
                 } catch (err) {
                     console.error('[Slack Bridge] Error processing message:', err);
                 }
@@ -44,9 +41,7 @@ class SlackBridge {
     }
 
     async disconnect() {
-        if (this.app) {
-            await this.app.stop();
-        }
+        if (this.app) await this.app.stop();
     }
 }
 

package/src/Channels/telegram_bridge.js

@@ -1,9 +1,12 @@
-const { Telegraf } = require('telegraf');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class TelegramBridge {
     constructor(token) {
         this.token = token;
+        const { Telegraf } = requireOptional('telegraf', 'npm install telegraf');
         this.bot = new Telegraf(token);
     }
 
@@ -12,19 +15,11 @@ class TelegramBridge {
 
         this.bot.on('text', async (ctx) => {
             try {
-                // Show typing status
                 await ctx.sendChatAction('typing');
-
                 const message = ctx.message.text;
                 if (!message) return;
-
-                // Send to Mint AI Brain
                 const result = await handleChat(message);
-
-                // Reply to user
-                if (result && result.response) {
-                    await ctx.reply(result.response);
-                }
+                if (result && result.response) await ctx.reply(result.response);
             } catch (err) {
                 console.error('[Telegram Bridge] Error processing message:', err);
                 await ctx.reply('ขออภัยค่ะ เกิดข้อผิดพลาดบางอย่างในการประมวลผลข้อความ');
@@ -34,15 +29,12 @@ class TelegramBridge {
         this.bot.launch();
         console.log('[Telegram Bridge] Bot started!');
 
-        // Enable graceful stop
         process.once('SIGINT', () => this.bot.stop('SIGINT'));
         process.once('SIGTERM', () => this.bot.stop('SIGTERM'));
     }
 
     async disconnect() {
-        if (this.bot) {
-            await this.bot.stop();
-        }
+        if (this.bot) await this.bot.stop();
     }
 }
 

package/src/Channels/whatsapp_bridge.js

@@ -1,9 +1,16 @@
-const { Client, LocalAuth } = require('whatsapp-web.js');
-const qrcode = require('qrcode-terminal');
+'use strict';
+
+const { requireOptional } = require('../System/optional_require');
 const { handleChat } = require('../AI_Brain/Gemini_API');
 
 class WhatsappBridge {
     constructor() {
+        // Dynamic require — only loads if user has installed whatsapp-web.js
+        const { Client, LocalAuth } = requireOptional(
+            'whatsapp-web.js',
+            'npm install whatsapp-web.js qrcode-terminal'
+        );
+        this._qrcode = requireOptional('qrcode-terminal', 'npm install qrcode-terminal');
         this.client = new Client({
             authStrategy: new LocalAuth({
                 dataPath: require('path').join(require('os').homedir(), '.config', 'mint', 'whatsapp-session')
@@ -17,7 +24,7 @@ class WhatsappBridge {
     async connect() {
         this.client.on('qr', (qr) => {
             console.log('[WhatsApp Bridge] Scan this QR code to login:');
-            qrcode.generate(qr, { small: true });
+            this._qrcode.generate(qr, { small: true });
         });
 
         this.client.on('ready', () => {
@@ -26,13 +33,8 @@ class WhatsappBridge {
 
         this.client.on('message', async (msg) => {
             try {
-                // Ignore messages from groups unless mentioned (simple implementation)
                 const chat = await msg.getChat();
-                if (chat.isGroup) {
-                    // For groups, we could add a mention check here if desired
-                    return;
-                }
-
+                if (chat.isGroup) return;
                 const result = await handleChat(msg.body);
                 if (result && result.response) {
                     await msg.reply(result.response);

package/src/System/action_executor.js

@@ -1,19 +1,33 @@
-const { clipboard: electronClipboard } = require('electron');
+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 granularAutomation = require('./granular_automation');
 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 = {}) {
-    console.log("Executing action:", action);
+    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({
@@ -21,7 +35,7 @@ async function executeAction(action, options = {}) {
         action: action.type,
         target: action.target || action.path || '',
         tier: safety.tier,
-        approved: options.allowDangerous === true || safety.tier !== safetyManager.TIERS.DANGEROUS
+        approved: options.allowApproval === true || options.allowDangerous === true || safety.tier === safetyManager.TIERS.SAFE
     });
 
     switch (action.type) {
@@ -37,17 +51,23 @@ async function executeAction(action, options = {}) {
         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':
@@ -56,21 +76,33 @@ async function executeAction(action, options = {}) {
             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':
+        case 'mouse_move': {
+            const granularAutomation = require('./granular_automation');
             return await granularAutomation.mouseMove(action.x, action.y);
-        case 'mouse_click':
+        }
+        case 'mouse_click': {
+            const granularAutomation = require('./granular_automation');
             return await granularAutomation.mouseClick(action.x, action.y, action.button || 1);
-        case 'type_text':
+        }
+        case 'type_text': {
+            const granularAutomation = require('./granular_automation');
             return await granularAutomation.typeText(action.target);
-        case 'key_tap':
+        }
+        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':
@@ -80,10 +112,27 @@ async function executeAction(action, options = {}) {
     }
 }
 
+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
+        maxResults: 10,
+        roots: safetyManager.getAllowedRoots('read')
     });
     if (!result.success) {
         return result.message;
@@ -126,4 +175,4 @@ async function handleSystemAutomation(target) {
     }
 }
 
-module.exports = { executeAction, handleSystemAutomation };
+module.exports = { executeAction, handleSystemAutomation, handleSystemInfo };

package/src/System/chat_history_manager.js

@@ -19,21 +19,29 @@ if (!fs.existsSync(CONFIG_DIR)) {
 
 const CHAT_HISTORY_PATH = path.join(CONFIG_DIR, 'mint-chat-history.json');
 
-// Migration Logic: Consolidate from Electron userData or old ~/.mint to ~/.config/mint
+// Migration Logic: Consolidate from various legacy locations 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');
+    const legacyDotMint    = path.join(MINT_DIR, 'mint-chat-history.json');
+    // Legacy: file was written to the project root (CWD) before v1.5.2
+    const legacyProjectRoot = path.join(process.cwd(), '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); }
+    const candidates = [
+        electronUserData,
+        legacyDotMint,
+        legacyProjectRoot
+    ].filter(Boolean);
+
+    for (const candidate of candidates) {
+        if (candidate !== CHAT_HISTORY_PATH && fs.existsSync(candidate)) {
+            try {
+                fs.copyFileSync(candidate, CHAT_HISTORY_PATH);
+                console.log(`[History] Migrated chat history from ${candidate}`);
+            } catch (e) {
+                console.error('[History] Migration failed:', e);
+            }
+            break;
+        }
     }
 }
 

package/src/System/config_manager.js

@@ -99,7 +99,37 @@ const DEFAULT_CONFIG = {
     enableAgentCollaboration: false,
     enableAutoUpdate: true,
     autoUpdateCheckIntervalHours: 24,
-    lastUpdateCheckAt: ''
+    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']
 };