@pheem49/mint 1.4.1 → 1.5.0

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

package/src/System/safety_manager.js

@@ -0,0 +1,165 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const TIERS = Object.freeze({
+    SAFE: 'safe',
+    APPROVAL: 'approval',
+    DANGEROUS: 'dangerous',
+    BLOCKED: 'blocked'
+});
+
+const BLOCKED_COMMAND_PATTERNS = [
+    { pattern: /\brm\s+(-[^\s]*r[^\s]*f|-rf|-fr)\b/, reason: 'recursive force delete' },
+    { pattern: /\bgit\s+reset\s+--hard\b/, reason: 'destructive git reset' },
+    { pattern: /\bgit\s+checkout\s+--\b/, reason: 'destructive git checkout path restore' },
+    { pattern: /\bgit\s+clean\b.*\s-[^\s]*f/, reason: 'destructive git clean' },
+    { pattern: /\bmkfs(?:\.\w+)?\b/, reason: 'filesystem formatting' },
+    { pattern: /\bdd\s+.*\bof=\/dev\//, reason: 'raw disk write' },
+    { pattern: />\s*\/dev\/(?:sd|nvme|hd|mapper)/, reason: 'write redirection to block device' },
+    { pattern: /\b(shutdown|reboot|poweroff|halt)\b/, reason: 'system power command' },
+    { pattern: /\bsudo\b/, reason: 'privilege escalation' },
+    { pattern: /\bchmod\s+-R\s+777\b/, reason: 'unsafe recursive permissions' },
+    { pattern: /\bchown\s+-R\b/, reason: 'unsafe recursive ownership change' },
+    { pattern: /\bcurl\b.*\|\s*(sh|bash|zsh)\b/, reason: 'remote script piping' },
+    { pattern: /\bwget\b.*\|\s*(sh|bash|zsh)\b/, reason: 'remote script piping' }
+];
+
+const DANGEROUS_ACTIONS = new Set([
+    'delete_file',
+    'system_automation'
+]);
+
+const SAFE_ACTIONS = new Set([
+    'open_url',
+    'search',
+    'open_app',
+    'open_file',
+    'open_folder',
+    'find_path',
+    'clipboard_write',
+    'learn_file',
+    'learn_folder',
+    'mcp_tool',
+    'mouse_move',
+    'mouse_click',
+    'type_text',
+    'key_tap',
+    'plugin',
+    'web_automation',
+    'create_folder'
+]);
+
+const DANGEROUS_SYSTEM_COMMANDS = new Set(['shutdown', 'restart', 'reboot', 'poweroff', 'sleep']);
+
+function normalizeCommand(command) {
+    return String(command || '').replace(/\s+/g, ' ').trim();
+}
+
+function classifyShellCommand(command) {
+    const normalized = normalizeCommand(command);
+    if (!normalized) {
+        return { tier: TIERS.BLOCKED, reason: 'empty shell command' };
+    }
+
+    for (const rule of BLOCKED_COMMAND_PATTERNS) {
+        if (rule.pattern.test(normalized)) {
+            return { tier: TIERS.BLOCKED, reason: rule.reason };
+        }
+    }
+
+    return { tier: TIERS.APPROVAL, reason: 'shell command requires approval' };
+}
+
+function assertShellCommandAllowed(command) {
+    const result = classifyShellCommand(command);
+    if (result.tier === TIERS.BLOCKED) {
+        throw new Error(`Blocked unsafe command (${result.reason}): ${command}`);
+    }
+    return result;
+}
+
+function classifyAction(action = {}) {
+    const type = action.type || 'none';
+    if (type === 'none') return { tier: TIERS.SAFE, reason: 'no-op action' };
+
+    if (type === 'system_automation') {
+        const command = String(action.target || '').split(':')[0];
+        if (DANGEROUS_SYSTEM_COMMANDS.has(command)) {
+            return { tier: TIERS.DANGEROUS, reason: `system automation command '${command}'` };
+        }
+        return { tier: TIERS.APPROVAL, reason: 'system automation requires approval' };
+    }
+
+    if (DANGEROUS_ACTIONS.has(type)) {
+        return { tier: TIERS.DANGEROUS, reason: `${type} can affect user data or system state` };
+    }
+
+    if (SAFE_ACTIONS.has(type)) {
+        return { tier: TIERS.SAFE, reason: 'allowed action' };
+    }
+
+    return { tier: TIERS.APPROVAL, reason: 'unknown action requires approval' };
+}
+
+function assertActionAllowed(action, options = {}) {
+    const classification = classifyAction(action);
+    const allowDangerous = options.allowDangerous === true;
+
+    if (classification.tier === TIERS.BLOCKED) {
+        throw new Error(`Blocked action (${classification.reason}): ${action.type}`);
+    }
+
+    if (classification.tier === TIERS.DANGEROUS && !allowDangerous) {
+        throw new Error(`Dangerous action requires explicit permission (${classification.reason}): ${action.type}`);
+    }
+
+    return classification;
+}
+
+function resolveWithinRoot(root, targetPath) {
+    if (!root) throw new Error('Root path is required.');
+    if (!targetPath) throw new Error('Target path is required.');
+
+    const resolvedRoot = path.resolve(root);
+    const expandedTarget = String(targetPath).startsWith('~/')
+        ? path.join(os.homedir(), String(targetPath).slice(2))
+        : targetPath;
+    const resolvedTarget = path.resolve(resolvedRoot, expandedTarget);
+    const relative = path.relative(resolvedRoot, resolvedTarget);
+
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`Path is outside allowed root: ${targetPath}`);
+    }
+
+    return resolvedTarget;
+}
+
+function appendActionLog(entry, options = {}) {
+    const logPath = options.logPath || path.join(os.homedir(), '.config', 'mint', 'action-log.jsonl');
+    const payload = {
+        time: new Date().toISOString(),
+        ...entry
+    };
+
+    try {
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        fs.appendFileSync(logPath, `${JSON.stringify(payload)}\n`, 'utf8');
+    } catch (error) {
+        if (process.env.MINT_DEBUG === '1') {
+            console.error('[Safety] Failed to append action log:', error.message);
+        }
+    }
+
+    return payload;
+}
+
+module.exports = {
+    TIERS,
+    classifyShellCommand,
+    assertShellCommandAllowed,
+    classifyAction,
+    assertActionAllowed,
+    resolveWithinRoot,
+    appendActionLog
+};