@pheem49/mint 1.5.1 → 1.5.3

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/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

@@ -39,6 +39,9 @@ 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',
@@ -187,4 +190,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

@@ -17,6 +17,8 @@ function registerIpcHandlers({
         getWeather,
         readConfig,
         writeConfig,
+        saveChatImages,
+        listSavedPictures,
         parseCommand,
         executeAction,
         getGoogleTtsUrls,
@@ -25,6 +27,10 @@ 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);
 
@@ -79,6 +85,10 @@ function registerIpcHandlers({
 
     ipcMain.handle('get-chat-history', () => getChatTranscript());
 
+    ipcMain.handle('list-saved-pictures', () => {
+        return listSavedPictures ? listSavedPictures() : [];
+    });
+
     ipcMain.handle('open-settings', () => {
         windowManager.createSettingsWindow();
     });

package/src/System/optional_require.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * Helper: ลอง require package แบบ dynamic
+ * ถ้าหาไม่เจอให้ throw Error พร้อม install guide
+ */
+function requireOptional(pkg, installHint) {
+    try {
+        return require(pkg);
+    } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const hint = installHint || `npm install ${pkg}`;
+            throw new Error(
+                `[Mint] Optional package "${pkg}" is not installed.\n` +
+                `To use this feature, run: ${hint}\n` +
+                `(This package is not bundled by default to keep Mint lightweight.)`
+            );
+        }
+        throw e;
+    }
+}
+
+module.exports = { requireOptional };

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/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'],