@pheem49/mint 1.5.5 → 1.6.1

package/src/Plugins/system_metrics.js

@@ -1,31 +0,0 @@
-const os = require('os');
-const { getSystemInfo } = require('../System/system_info');
-
-/**
- * System Metrics Plugin — Provides real-time hardware stats to Gemini
- */
-module.exports = {
-    name: 'system_metrics',
-    description: 'Get real-time system metrics like CPU usage, RAM, and uptime. Instruction can be "all", "ram", "cpu", or "uptime".',
-    
-    async execute(instruction) {
-        const info = getSystemInfo();
-        const uptimeMin = Math.floor(os.uptime() / 60);
-        const uptimeHours = (uptimeMin / 60).toFixed(1);
-        
-        const inst = (instruction || 'all').toLowerCase();
-
-        if (inst.includes('ram')) {
-            return `ความจำเครื่อง (RAM): ใช้ไป ${info.ram.used} จากทั้งหมด ${info.ram.total} (${info.ram.percent})`;
-        } 
-        if (inst.includes('cpu')) {
-            return `หน่วยประมวลผล (CPU): ${info.cpu.model} มีทั้งหมด ${info.cpu.cores} คอร์`;
-        }
-        if (inst.includes('uptime')) {
-            return `เปิดเครื่องมาแล้ว: ${uptimeMin} นาที (${uptimeHours} ชั่วโมง)`;
-        }
-
-        // Default: Return basic summary in Thai for Mint's personality
-        return `สรุปสถานะระบบ: RAM ใช้ไป ${info.ram.percent}, CPU ${info.cpu.cores} Cores, เปิดเครื่องมาแล้ว ${uptimeMin} นาทีค่ะ ✨`;
-    }
-};

package/src/Plugins/system_monitor.js

@@ -1,72 +0,0 @@
-/**
- * Mint System Monitor Plugin
- * --------------------------
- * Provides real-time system statistics for the host machine.
- * Uses standard Linux commands (uptime, free, df) for lightweight monitoring.
- */
-
-const { exec } = require('child_process');
-const { promisify } = require('util');
-const execAsync = promisify(exec);
-const os = require('os');
-
-async function getStats() {
-    try {
-        const [uptime, free, df] = await Promise.all([
-            execAsync('uptime -p'),
-            execAsync('free -h'),
-            execAsync('df -h / --output=pcent,avail')
-        ]);
-
-        // Parse Memory
-        const memLines = free.stdout.split('\n');
-        const memLine = memLines.find(l => l.startsWith('Mem:')) || '';
-        const memParts = memLine.split(/\s+/).filter(Boolean);
-        const memUsed = memParts[2] || 'Unknown';
-        const memTotal = memParts[1] || 'Unknown';
-
-        // Parse Disk
-        const diskLines = df.stdout.trim().split('\n');
-        const diskLine = diskLines[1] || '';
-        const [diskPercent, diskAvail] = diskLine.trim().split(/\s+/);
-
-        const cpuLoad = os.loadavg()[0].toFixed(2);
-        const cpuCores = os.cpus().length;
-
-        let report = `📊 **System Health Report**\n`;
-        report += `⏱️ **Uptime:** ${uptime.stdout.trim()}\n`;
-        report += `💻 **CPU Load:** ${cpuLoad} (on ${cpuCores} cores)\n`;
-        report += `🧠 **Memory:** ${memUsed} / ${memTotal} used\n`;
-        report += `💽 **Disk (/):** ${diskAvail} available (${diskPercent} full)`;
-
-        return report;
-    } catch (err) {
-        return `❌ Error fetching system stats: ${err.message}`;
-    }
-}
-
-module.exports = {
-    name: 'system_monitor',
-    description: 'Provides system statistics like CPU load, memory usage, disk space, and uptime. Target can be "stats", "cpu", "memory", or "disk".',
-
-    async execute(target) {
-        const cmd = (target || 'stats').toLowerCase().trim();
-        
-        switch (cmd) {
-            case 'stats':
-            case 'health':
-                return await getStats();
-            case 'cpu':
-                return `💻 **CPU Load (1m):** ${os.loadavg()[0].toFixed(2)}\nCores: ${os.cpus().length}\nModel: ${os.cpus()[0].model}`;
-            case 'memory':
-            case 'ram':
-                const { stdout: mem } = await execAsync('free -h');
-                return `🧠 **Memory Status:**\n\`\`\`\n${mem}\`\`\``;
-            case 'disk':
-                const { stdout: disk } = await execAsync('df -h /');
-                return `💽 **Disk Status:**\n\`\`\`\n${disk}\`\`\``;
-            default:
-                return await getStats();
-        }
-    }
-};

package/src/System/action_executor.js

@@ -1,178 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,83 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-let app;
-try {
-    const electron = require('electron');
-    app = electron.app;
-} catch (e) {
-    app = null;
-}
-
-const CONFIG_DIR = path.join(os.homedir(), '.config', 'mint');
-const MINT_DIR = path.join(os.homedir(), '.mint');
-
-if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-}
-
-const CHAT_HISTORY_PATH = path.join(CONFIG_DIR, 'mint-chat-history.json');
-
-// 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 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');
-
-    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;
-        }
-    }
-}
-
-function readChatHistory() {
-    try {
-        if (!fs.existsSync(CHAT_HISTORY_PATH)) {
-            return [];
-        }
-
-        const raw = fs.readFileSync(CHAT_HISTORY_PATH, 'utf-8');
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) ? parsed : [];
-    } catch (err) {
-        console.error('readChatHistory error:', err);
-        return [];
-    }
-}
-
-function writeChatHistory(history) {
-    try {
-        const safeHistory = Array.isArray(history) ? history : [];
-        fs.writeFileSync(CHAT_HISTORY_PATH, JSON.stringify(safeHistory, null, 2), 'utf-8');
-        return { success: true };
-    } catch (err) {
-        console.error('writeChatHistory error:', err);
-        return { success: false, message: err.message };
-    }
-}
-
-function clearChatHistory() {
-    return writeChatHistory([]);
-}
-
-module.exports = {
-    CHAT_HISTORY_PATH,
-    readChatHistory,
-    writeChatHistory,
-    clearChatHistory
-};

package/src/System/config_manager.js

@@ -1,194 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-let app;
-try {
-    const electron = require('electron');
-    app = electron.app;
-} catch (e) {
-    app = null;
-}
-
-const CONFIG_DIR = path.join(os.homedir(), '.config', 'mint');
-const LEGACY_DIR = path.join(os.homedir(), '.mint');
-
-if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-}
-
-// Migration: If old .mint exists but new .config/mint is empty, move files
-if (fs.existsSync(LEGACY_DIR) && fs.readdirSync(CONFIG_DIR).length === 0) {
-    try {
-        const files = fs.readdirSync(LEGACY_DIR);
-        for (const file of files) {
-            fs.copyFileSync(path.join(LEGACY_DIR, file), path.join(CONFIG_DIR, file));
-        }
-        console.log('[Config] Migrated settings from ~/.mint to ~/.config/mint');
-    } catch (e) {
-        console.error('[Config] Migration failed:', e);
-    }
-}
-
-const CONFIG_PATH = path.join(CONFIG_DIR, 'mint-config.json');
-
-const DEFAULT_CONFIG = {
-    theme: 'dark',
-    accentColor: '#8b5cf6',
-    systemTextColor: '#f8fafc',
-    customBgStart: '#0f172a',
-    customBgEnd: '#1e1b4b',
-    customPanelBg: '#1e293b',
-    glassBlur: 'blur(16px)',
-    fontFamily: "'Outfit', sans-serif",
-    fontSize: '15px',
-    apiKey: '',
-    geminiModel: 'gemini-2.5-flash',
-    language: 'th-TH',
-    assistantMode: 'chat',
-    automationBrowser: 'chromium',
-    proactiveInterval: 60,   // seconds between screen captures
-    proactiveCooldown: 120,   // seconds minimum between actual suggestions
-    aiProvider: 'gemini',
-    ollamaModel: 'llama3:latest',
-    enableVoiceReply: true,
-    enableCustomWorkflows: true,
-    ttsProvider: 'google',
-    ttsVolume: 1.0,
-    ttsSpeed: 1.0,
-    ttsPitch: 1.0,
-    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: '',
-    localModelName: 'local-model',
-    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']
-};
-
-
-
-function readConfig() {
-    try {
-        if (!fs.existsSync(CONFIG_PATH)) {
-            writeConfig(DEFAULT_CONFIG);
-            return DEFAULT_CONFIG;
-        }
-        const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
-        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
-    } catch (err) {
-        console.error('readConfig error:', err);
-        return DEFAULT_CONFIG;
-    }
-}
-
-function writeConfig(config) {
-    try {
-        fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
-        return { success: true };
-    } catch (err) {
-        console.error('writeConfig error:', err);
-        return { success: false, message: err.message };
-    }
-}
-
-function getAvailableProviders(config) {
-    const providers = [];
-    const cfg = config || readConfig();
-    
-    // Check which providers have API keys or URLs configured
-    const anthropicKey = cfg.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-    if (!isPlaceholder(anthropicKey)) providers.push('anthropic');
-
-    const openaiKey = cfg.openaiApiKey || process.env.OPENAI_API_KEY;
-    if (!isPlaceholder(openaiKey)) providers.push('openai');
-
-    const geminiKey = cfg.apiKey || process.env.GEMINI_API_KEY;
-    if (!isPlaceholder(geminiKey)) providers.push('gemini');
-
-    const hfKey = cfg.hfApiKey || process.env.HF_API_KEY;
-    if (!isPlaceholder(hfKey)) providers.push('huggingface');
-
-    if (cfg.localApiBaseUrl && cfg.localApiBaseUrl.trim() !== '') providers.push('local_openai');
-    
-    // Always push ollama at the end since it's local
-    providers.push('ollama');
-
-    return providers;
-}
-
-function isPlaceholder(val) {
-    return !val || val.startsWith('your_') || val.includes('key_here') || val.trim() === '';
-}
-
-module.exports = { readConfig, writeConfig, getAvailableProviders, isPlaceholder, CONFIG_PATH, CONFIG_DIR };