@pheem49/mint 1.5.2 → 1.5.4

package/src/System/config_manager.js

@@ -39,9 +39,13 @@ const DEFAULT_CONFIG = {
     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
@@ -187,4 +191,4 @@ function isPlaceholder(val) {
     return !val || val.startsWith('your_') || val.includes('key_here') || val.trim() === '';
 }
 
-module.exports = { readConfig, writeConfig, getAvailableProviders, isPlaceholder, CONFIG_PATH };
+module.exports = { readConfig, writeConfig, getAvailableProviders, isPlaceholder, CONFIG_PATH, CONFIG_DIR };

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,
@@ -17,6 +57,8 @@ function registerIpcHandlers({
         getWeather,
         readConfig,
         writeConfig,
+        saveChatImages,
+        listSavedPictures,
         parseCommand,
         executeAction,
         getGoogleTtsUrls,
@@ -25,11 +67,21 @@ function registerIpcHandlers({
 
     ipcMain.handle('chat-message', async (event, message, base64Image = null, base64Audio = null) => {
         try {
+            if (base64Image && saveChatImages) {
+                saveChatImages(base64Image, { source: 'chat', message });
+            }
+
             const rawResponse = await handleChat(message, base64Image, base64Audio);
             const aiResponse = parseCommand(rawResponse);
 
             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}`;
@@ -47,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();
@@ -79,6 +143,10 @@ function registerIpcHandlers({
 
     ipcMain.handle('get-chat-history', () => getChatTranscript());
 
+    ipcMain.handle('list-saved-pictures', () => {
+        return listSavedPictures ? listSavedPictures() : [];
+    });
+
     ipcMain.handle('open-settings', () => {
         windowManager.createSettingsWindow();
     });
@@ -157,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);
@@ -197,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();
@@ -235,4 +329,4 @@ function registerIpcHandlers({
     });
 }
 
-module.exports = { registerIpcHandlers };
+module.exports = { registerIpcHandlers, buildApprovalRequest, executeApprovedAction };

package/src/System/picture_store.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { pathToFileURL } = require('url');
+
+const PICTURES_DIR = path.join(os.homedir(), '.config', 'mint', 'Pictures');
+const INDEX_PATH = path.join(PICTURES_DIR, 'pictures.json');
+
+const EXTENSIONS = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/jpg': 'jpg',
+    'image/webp': 'webp',
+    'image/gif': 'gif'
+};
+
+function ensurePicturesDir() {
+    fs.mkdirSync(PICTURES_DIR, { recursive: true });
+}
+
+function readIndex() {
+    try {
+        if (!fs.existsSync(INDEX_PATH)) return [];
+        const parsed = JSON.parse(fs.readFileSync(INDEX_PATH, 'utf8'));
+        return Array.isArray(parsed) ? parsed : [];
+    } catch (error) {
+        console.error('[Pictures] Failed to read index:', error.message);
+        return [];
+    }
+}
+
+function writeIndex(entries) {
+    ensurePicturesDir();
+    fs.writeFileSync(INDEX_PATH, JSON.stringify(entries, null, 2), 'utf8');
+}
+
+function parseImageDataUri(dataUri) {
+    if (!dataUri || typeof dataUri !== 'string') return null;
+    const match = dataUri.match(/^data:(image\/[\w.+-]+);base64,([\s\S]+)$/);
+    if (!match) return null;
+
+    const mimeType = match[1].toLowerCase();
+    const extension = EXTENSIONS[mimeType] || 'png';
+    return {
+        mimeType,
+        extension,
+        buffer: Buffer.from(match[2], 'base64')
+    };
+}
+
+function createFilename(extension) {
+    const stamp = new Date().toISOString()
+        .replace(/[-:]/g, '')
+        .replace(/\..+$/, '')
+        .replace('T', '-');
+    const id = crypto.randomBytes(4).toString('hex');
+    return `mint-${stamp}-${id}.${extension}`;
+}
+
+function saveChatImages(base64Image, metadata = {}) {
+    const images = Array.isArray(base64Image) ? base64Image : (base64Image ? [base64Image] : []);
+    const saved = [];
+    if (images.length === 0) return saved;
+
+    ensurePicturesDir();
+    const index = readIndex();
+
+    for (const item of images) {
+        const parsed = parseImageDataUri(item);
+        if (!parsed || parsed.buffer.length === 0) continue;
+
+        const filename = createFilename(parsed.extension);
+        const filePath = path.join(PICTURES_DIR, filename);
+        fs.writeFileSync(filePath, parsed.buffer);
+
+        const entry = {
+            id: path.basename(filename, path.extname(filename)),
+            filename,
+            path: filePath,
+            mimeType: parsed.mimeType,
+            createdAt: new Date().toISOString(),
+            source: metadata.source || 'chat',
+            message: String(metadata.message || '').slice(0, 240)
+        };
+
+        index.unshift(entry);
+        saved.push(entry);
+    }
+
+    writeIndex(index);
+    return saved;
+}
+
+function listSavedPictures() {
+    ensurePicturesDir();
+    return readIndex()
+        .filter(entry => entry && entry.path && fs.existsSync(entry.path))
+        .map(entry => ({
+            ...entry,
+            url: pathToFileURL(entry.path).href
+        }));
+}
+
+module.exports = {
+    PICTURES_DIR,
+    saveChatImages,
+    listSavedPictures
+};

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/System/task_manager.js

@@ -57,6 +57,12 @@ function addTask(description) {
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
         steps: [],
+        subtasks: [],
+        checkpoints: [],
+        artifacts: [],
+        retryCount: 0,
+        maxRetries: 1,
+        lastCheckpointAt: null,
         result: null
     };
     tasks.push(newTask);
@@ -80,6 +86,120 @@ function updateTask(id, updates) {
     return null;
 }
 
+function getTask(id) {
+    return readTasks().find(t => t.id === id) || null;
+}
+
+function normalizeTask(task) {
+    return {
+        ...task,
+        steps: Array.isArray(task.steps) ? task.steps : [],
+        subtasks: Array.isArray(task.subtasks) ? task.subtasks : [],
+        checkpoints: Array.isArray(task.checkpoints) ? task.checkpoints : [],
+        artifacts: Array.isArray(task.artifacts) ? task.artifacts : [],
+        retryCount: Number.isFinite(task.retryCount) ? task.retryCount : 0,
+        maxRetries: Number.isFinite(task.maxRetries) ? task.maxRetries : 1
+    };
+}
+
+function mutateTask(id, mutator) {
+    const tasks = readTasks();
+    const idx = tasks.findIndex(t => t.id === id);
+    if (idx === -1) return null;
+    const next = normalizeTask(tasks[idx]);
+    mutator(next);
+    next.updatedAt = new Date().toISOString();
+    tasks[idx] = next;
+    writeTasks(tasks);
+    return next;
+}
+
+function addSubtask(taskId, title, extra = {}) {
+    return mutateTask(taskId, task => {
+        task.subtasks.push({
+            id: `${taskId}-${task.subtasks.length + 1}`,
+            title,
+            status: extra.status || 'pending',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            ...extra
+        });
+    });
+}
+
+function updateSubtask(taskId, subtaskId, updates = {}) {
+    return mutateTask(taskId, task => {
+        const subtask = task.subtasks.find(item => item.id === subtaskId);
+        if (!subtask) return;
+        Object.assign(subtask, updates, { updatedAt: new Date().toISOString() });
+    });
+}
+
+function addCheckpoint(taskId, checkpoint = {}) {
+    return mutateTask(taskId, task => {
+        const entry = {
+            id: `${taskId}-checkpoint-${task.checkpoints.length + 1}`,
+            time: new Date().toISOString(),
+            ...checkpoint
+        };
+        task.checkpoints.push(entry);
+        task.lastCheckpointAt = entry.time;
+        task.steps.push(entry);
+    });
+}
+
+function addArtifact(taskId, artifact = {}) {
+    return mutateTask(taskId, task => {
+        task.artifacts.push({
+            id: `${taskId}-artifact-${task.artifacts.length + 1}`,
+            time: new Date().toISOString(),
+            ...artifact
+        });
+    });
+}
+
+function failTaskWithRetry(id, errorMessage) {
+    return mutateTask(id, task => {
+        const retryCount = Number(task.retryCount) || 0;
+        const maxRetries = Number.isFinite(task.maxRetries) ? task.maxRetries : 1;
+        task.result = errorMessage;
+        task.retryCount = retryCount + 1;
+        task.status = task.retryCount <= maxRetries ? 'pending' : 'failed';
+        const checkpoint = {
+            id: `${id}-checkpoint-${task.checkpoints.length + 1}`,
+            time: new Date().toISOString(),
+            phase: task.status === 'pending' ? 'retry_scheduled' : 'failed',
+            message: errorMessage,
+            retryCount: task.retryCount,
+            maxRetries
+        };
+        task.checkpoints.push(checkpoint);
+        task.steps.push(checkpoint);
+    });
+}
+
+function resumeRunningTasks() {
+    const resumed = [];
+    const tasks = readTasks().map(task => {
+        if (task.status !== 'running') return task;
+        const normalized = normalizeTask(task);
+        normalized.status = 'pending';
+        const checkpoint = {
+            id: `${normalized.id}-checkpoint-${normalized.checkpoints.length + 1}`,
+            time: new Date().toISOString(),
+            phase: 'resume_after_restart',
+            message: 'Task was running during shutdown and has been re-queued.'
+        };
+        normalized.checkpoints.push(checkpoint);
+        normalized.steps.push(checkpoint);
+        normalized.updatedAt = new Date().toISOString();
+        resumed.push(normalized);
+        return normalized;
+    });
+    writeTasks(tasks);
+    return resumed;
+}
+
 function clearCompletedTasks() {
     const tasks = readTasks();
     const activeTasks = tasks.filter(t => t.status === 'pending' || t.status === 'running');
@@ -88,8 +208,15 @@ function clearCompletedTasks() {
 
 module.exports = {
     addTask,
+    addArtifact,
+    addCheckpoint,
+    addSubtask,
+    failTaskWithRetry,
+    getTask,
     getPendingTask,
+    resumeRunningTasks,
     updateTask,
+    updateSubtask,
     readTasks,
     clearCompletedTasks
 };

package/src/System/tool_registry.js

@@ -41,6 +41,19 @@ const TOOL_REGISTRY = Object.freeze({
         important: true,
         description: 'Run a non-destructive shell command after user approval.'
     },
+    verify: {
+        permission: 'approval',
+        required: [],
+        codeAgentOnly: true,
+        important: true,
+        description: 'Run test/build/lint verification commands after user approval.'
+    },
+    plan: {
+        permission: 'approval',
+        required: ['plan'],
+        codeAgentOnly: true,
+        description: 'Present a multi-file edit plan before changing files.'
+    },
     apply_patch: {
         permission: 'approval',
         required: ['patch'],