@pheem49/mint 1.5.3 → 1.5.5

package/src/CLI/interactive_chat.js

@@ -119,7 +119,7 @@ function buildExitSummary(stats) {
     const activeMs = stats.agentActiveMs + (stats.activeStartedAt ? Date.now() - stats.activeStartedAt : 0);
     const total = stats.toolCalls.total;
     return {
-        message: 'Agent powering down. Goodbye!',
+        message: 'Goodbye! See you again.',
         sessionId: stats.sessionId,
         toolCalls: {
             ...stats.toolCalls,
@@ -327,6 +327,7 @@ async function runAgentTask(text, { appendMessage, streamMessage, setThinking, r
             askUser,
             provider: preferredProvider,
             history:  contextualHistory,
+            signal:   sharedState.abortController?.signal,
             onProgress: (info) => {
                 if (info && info.phase === 'tool_call') {
                     sharedState.stats.toolCalls.total += 1;
@@ -381,6 +382,7 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
         lastResponseText:        '',
         recentImageContextText:  '',
         isBusy:                  false,
+        abortController:         null,
         stats:                   createSessionStats()
     };
 
@@ -396,12 +398,19 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
             }
         },
 
+        onCancel: () => {
+            if (sharedState.abortController) {
+                sharedState.abortController.abort();
+            }
+        },
+
         onSubmit: async (text, submitOptions = {}) => {
             if (sharedState.isBusy) {
                 ui.appendMessage('system', 'Mint is still working on the previous request. Please wait for it to finish before sending another command.');
                 return;
             }
             sharedState.isBusy = true;
+            sharedState.abortController = new AbortController();
 
             const {
                 appendMessage, streamMessage, setThinking, updateStatusModel,
@@ -574,6 +583,7 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
                 }, sharedState);
             } finally {
                 sharedState.isBusy = false;
+                sharedState.abortController = null;
             }
         },
 
@@ -625,10 +635,17 @@ async function startInteractiveChat(initialMessage = null, options = {}) {
             return;
         }
 
-        await runAgentTask(initialMessage, {
-            appendMessage, streamMessage, setThinking,
-            requestApproval, askUser, setMode, appendCodeStep
-        }, sharedState);
+        sharedState.isBusy = true;
+        sharedState.abortController = new AbortController();
+        try {
+            await runAgentTask(initialMessage, {
+                appendMessage, streamMessage, setThinking,
+                requestApproval, askUser, setMode, appendCodeStep
+            }, sharedState);
+        } finally {
+            sharedState.isBusy = false;
+            sharedState.abortController = null;
+        }
     }
 }
 

package/src/System/config_manager.js

@@ -45,6 +45,7 @@ const DEFAULT_CONFIG = {
     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

package/src/System/ipc_handlers.js

@@ -1,3 +1,43 @@
+const safetyManager = require('./safety_manager');
+const { getSmartContext } = require('./smart_context');
+
+function buildApprovalRequest(action) {
+    const classification = safetyManager.classifyAction(action);
+    if (
+        classification.tier !== safetyManager.TIERS.APPROVAL &&
+        classification.tier !== safetyManager.TIERS.DANGEROUS
+    ) {
+        return null;
+    }
+
+    return {
+        required: true,
+        tier: classification.tier,
+        reason: classification.reason,
+        action
+    };
+}
+
+async function executeApprovedAction(executeAction, action, clipboard) {
+    const classification = safetyManager.classifyAction(action);
+    const options = {
+        clipboard,
+        source: 'user_approved_action',
+        allowApproval: classification.tier === safetyManager.TIERS.APPROVAL,
+        allowDangerous: classification.tier === safetyManager.TIERS.DANGEROUS
+    };
+    const result = await executeAction(action, options);
+    return {
+        success: true,
+        action,
+        tier: classification.tier,
+        result,
+        message: result && typeof result === 'string'
+            ? result
+            : 'Action completed.'
+    };
+}
+
 function registerIpcHandlers({
     app,
     ipcMain,
@@ -36,6 +76,12 @@ function registerIpcHandlers({
 
             if (aiResponse.action && aiResponse.action.type !== 'none') {
                 try {
+                    const approval = buildApprovalRequest(aiResponse.action);
+                    if (approval) {
+                        aiResponse.approval = approval;
+                        return aiResponse;
+                    }
+
                     const actionResult = await executeAction(aiResponse.action, { clipboard });
                     if (actionResult && typeof actionResult === 'string') {
                         aiResponse.response += `\n\n${actionResult}`;
@@ -53,6 +99,18 @@ function registerIpcHandlers({
         }
     });
 
+    ipcMain.handle('execute-approved-action', async (event, action) => {
+        try {
+            if (!action || action.type === 'none') {
+                return { success: false, message: 'No action to execute.' };
+            }
+            return await executeApprovedAction(executeAction, action, clipboard);
+        } catch (err) {
+            console.error('[ApprovedAction] Error:', err);
+            return { success: false, message: err.message || 'Action failed.' };
+        }
+    });
+
     ipcMain.on('close-window', () => {
         const mainWindow = windowManager.getMainWindow();
         if (mainWindow) mainWindow.hide();
@@ -167,6 +225,30 @@ function registerIpcHandlers({
         }
     });
 
+    ipcMain.handle('spotlight-action', async (event, action) => {
+        const spotlightWindow = windowManager.getSpotlightWindow();
+        if (spotlightWindow) spotlightWindow.hide();
+
+        if (!action || action.type === 'none') {
+            return { success: false, message: 'No Spotlight action to execute.' };
+        }
+
+        try {
+            const result = await executeAction(action, {
+                clipboard,
+                source: 'spotlight'
+            });
+            return {
+                success: true,
+                action,
+                message: result && typeof result === 'string' ? result : 'Spotlight action completed.'
+            };
+        } catch (err) {
+            console.error('[SpotlightAction] Error:', err);
+            return { success: false, message: err.message || 'Spotlight action failed.' };
+        }
+    });
+
     ipcMain.on('spotlight-resize', (event, width, height) => {
         const spotlightWindow = windowManager.getSpotlightWindow();
         if (spotlightWindow) spotlightWindow.setSize(width, height);
@@ -207,6 +289,8 @@ function registerIpcHandlers({
     ipcMain.on('vision-cancel', () => screenCapture.cancel());
     ipcMain.handle('capture-silent-screen', () => screenCapture.captureSilentScreen());
 
+    ipcMain.handle('get-smart-context', () => getSmartContext({ clipboard }));
+
     ipcMain.on('toggle-proactive', (event, isOn) => {
         if (isOn) {
             proactiveLoop.start();
@@ -245,4 +329,4 @@ function registerIpcHandlers({
     });
 }
 
-module.exports = { registerIpcHandlers };
+module.exports = { registerIpcHandlers, buildApprovalRequest, executeApprovedAction };

package/src/System/smart_context.js

@@ -0,0 +1,227 @@
+const { execFile } = require('child_process');
+const os = require('os');
+
+const MAX_TEXT_LENGTH = 2000;
+const BROWSER_NAMES = [
+    'chrome',
+    'chromium',
+    'brave',
+    'firefox',
+    'edge',
+    'safari',
+    'opera',
+    'vivaldi'
+];
+
+function run(command, args = [], options = {}) {
+    return new Promise((resolve) => {
+        execFile(command, args, { timeout: options.timeout || 1200 }, (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            resolve(String(stdout || '').trim() || null);
+        });
+    });
+}
+
+function truncateText(value, maxLength = MAX_TEXT_LENGTH) {
+    const text = String(value || '').replace(/\0/g, '').trim();
+    if (text.length <= maxLength) return text;
+    return `${text.slice(0, maxLength)}\n[truncated ${text.length - maxLength} chars]`;
+}
+
+function normalizeProcessName(value) {
+    return String(value || '').trim().replace(/\.exe$/i, '');
+}
+
+function isBrowserProcess(name = '') {
+    const normalized = normalizeProcessName(name).toLowerCase();
+    return BROWSER_NAMES.some(browser => normalized.includes(browser));
+}
+
+async function getLinuxActiveWindow() {
+    const windowId = await run('xdotool', ['getactivewindow']);
+    if (!windowId) return null;
+
+    const [title, pid] = await Promise.all([
+        run('xdotool', ['getwindowname', windowId]),
+        run('xdotool', ['getwindowpid', windowId])
+    ]);
+
+    let processName = '';
+    if (pid) {
+        processName = await run('ps', ['-p', pid, '-o', 'comm=']) || '';
+    }
+
+    return {
+        id: windowId,
+        title: title || '',
+        appName: normalizeProcessName(processName),
+        processName: normalizeProcessName(processName),
+        pid: pid ? Number(pid) : null,
+        platform: 'linux'
+    };
+}
+
+async function getMacActiveWindow() {
+    const script = [
+        'tell application "System Events"',
+        'set frontApp to first application process whose frontmost is true',
+        'set appName to name of frontApp',
+        'set windowTitle to ""',
+        'try',
+        'set windowTitle to name of front window of frontApp',
+        'end try',
+        'return appName & linefeed & windowTitle',
+        'end tell'
+    ].join('\n');
+    const output = await run('osascript', ['-e', script]);
+    if (!output) return null;
+    const [appName = '', title = ''] = output.split(/\r?\n/);
+    return {
+        title,
+        appName,
+        processName: appName,
+        pid: null,
+        platform: 'darwin'
+    };
+}
+
+async function getWindowsActiveWindow() {
+    const script = [
+        'Add-Type @\'',
+        'using System;',
+        'using System.Runtime.InteropServices;',
+        'using System.Text;',
+        'public class Win {',
+        '[DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();',
+        '[DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);',
+        '[DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);',
+        '}',
+        '\'@',
+        '$hwnd = [Win]::GetForegroundWindow()',
+        '$builder = New-Object System.Text.StringBuilder 1024',
+        '[void][Win]::GetWindowText($hwnd, $builder, $builder.Capacity)',
+        '$pid = 0',
+        '[void][Win]::GetWindowThreadProcessId($hwnd, [ref]$pid)',
+        '$proc = Get-Process -Id $pid -ErrorAction SilentlyContinue',
+        '[PSCustomObject]@{ title = $builder.ToString(); appName = $proc.ProcessName; pid = $pid } | ConvertTo-Json -Compress'
+    ].join('\n');
+    const output = await run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], { timeout: 1800 });
+    if (!output) return null;
+    try {
+        const parsed = JSON.parse(output);
+        return {
+            title: parsed.title || '',
+            appName: normalizeProcessName(parsed.appName),
+            processName: normalizeProcessName(parsed.appName),
+            pid: parsed.pid ? Number(parsed.pid) : null,
+            platform: 'win32'
+        };
+    } catch (_) {
+        return null;
+    }
+}
+
+async function getActiveWindowContext(platform = process.platform) {
+    try {
+        if (platform === 'darwin') return await getMacActiveWindow();
+        if (platform === 'win32') return await getWindowsActiveWindow();
+        return await getLinuxActiveWindow();
+    } catch (_) {
+        return null;
+    }
+}
+
+async function getLinuxSelectedText() {
+    const attempts = [
+        ['wl-paste', ['--primary', '--no-newline']],
+        ['xclip', ['-selection', 'primary', '-out']],
+        ['xsel', ['--primary', '--output']]
+    ];
+
+    for (const [command, args] of attempts) {
+        const text = await run(command, args);
+        if (text) return truncateText(text);
+    }
+    return '';
+}
+
+async function getSelectedText(platform = process.platform) {
+    if (platform === 'linux') return getLinuxSelectedText();
+    return '';
+}
+
+async function getMacBrowserContext(appName) {
+    const normalized = String(appName || '').toLowerCase();
+    let script = '';
+    if (normalized.includes('safari')) {
+        script = 'tell application "Safari" to return name of front document & linefeed & URL of front document';
+    } else if (normalized.includes('chrome') || normalized.includes('chromium') || normalized.includes('brave') || normalized.includes('edge')) {
+        script = `tell application "${appName}" to return title of active tab of front window & linefeed & URL of active tab of front window`;
+    }
+    if (!script) return null;
+    const output = await run('osascript', ['-e', script], { timeout: 1500 });
+    if (!output) return null;
+    const [title = '', url = ''] = output.split(/\r?\n/);
+    return { title, url };
+}
+
+async function getBrowserContext(activeWindow, platform = process.platform) {
+    if (!activeWindow || !isBrowserProcess(activeWindow.appName || activeWindow.processName)) {
+        return null;
+    }
+    if (platform === 'darwin') {
+        const browser = await getMacBrowserContext(activeWindow.appName);
+        if (browser) return browser;
+    }
+    return {
+        title: activeWindow.title || '',
+        url: '',
+        urlUnavailableReason: 'Browser URL is not available from the current OS context without browser integration.'
+    };
+}
+
+async function getSmartContext(options = {}) {
+    const platform = options.platform || process.platform;
+    const clipboard = options.clipboard || null;
+    const [activeWindow, selectedText] = await Promise.all([
+        getActiveWindowContext(platform),
+        getSelectedText(platform)
+    ]);
+
+    let clipboardText = '';
+    try {
+        clipboardText = clipboard && typeof clipboard.readText === 'function'
+            ? truncateText(clipboard.readText())
+            : '';
+    } catch (_) {
+        clipboardText = '';
+    }
+
+    const browser = await getBrowserContext(activeWindow, platform);
+    return {
+        capturedAt: new Date().toISOString(),
+        platform,
+        host: os.hostname(),
+        activeWindow,
+        currentApp: activeWindow ? {
+            name: activeWindow.appName || activeWindow.processName || '',
+            processName: activeWindow.processName || activeWindow.appName || '',
+            pid: activeWindow.pid || null
+        } : null,
+        browser,
+        selectedText,
+        clipboardText
+    };
+}
+
+module.exports = {
+    getSmartContext,
+    getActiveWindowContext,
+    getBrowserContext,
+    getSelectedText,
+    truncateText,
+    isBrowserProcess
+};

package/src/UI/preload-spotlight.js

@@ -2,6 +2,7 @@ const { contextBridge, ipcRenderer } = require('electron');
 
 contextBridge.exposeInMainWorld('spotlightAPI', {
     submit: (query) => ipcRenderer.send('spotlight-submit', query),
+    executeAction: (action) => ipcRenderer.invoke('spotlight-action', action),
     close: () => ipcRenderer.send('spotlight-close'),
     hide: () => ipcRenderer.send('spotlight-hide'),
     resize: (width, height) => ipcRenderer.send('spotlight-resize', width, height),