@pheem49/mint 1.4.2 → 1.5.1

package/src/Channels/brave_search_bridge.js

@@ -0,0 +1,35 @@
+const axios = require('axios');
+
+class BraveSearchBridge {
+    constructor(credentials) {
+        this.apiKey = credentials.apiKey;
+    }
+
+    async search(query) {
+        if (!this.apiKey) {
+            throw new Error('Brave Search API Key is required.');
+        }
+
+        try {
+            const response = await axios.get('https://api.search.brave.com/res/v1/web/search', {
+                params: { q: query, count: 5 },
+                headers: {
+                    'Accept': 'application/json',
+                    'Accept-Encoding': 'gzip',
+                    'X-Subscription-Token': this.apiKey
+                }
+            });
+
+            const results = response.data.web ? response.data.web.results : [];
+            return results.map(item => ({
+                title: item.title,
+                snippet: item.description,
+                link: item.url
+            }));
+        } catch (err) {
+            throw new Error(`Brave Search Failed: ${err.message}`);
+        }
+    }
+}
+
+module.exports = BraveSearchBridge;

package/src/Channels/discord_bridge.js

@@ -0,0 +1,68 @@
+const { Client, GatewayIntentBits, Partials } = require('discord.js');
+const { handleChat } = require('../AI_Brain/Gemini_API');
+
+class DiscordBridge {
+    constructor(token) {
+        this.token = token;
+        this.client = new Client({
+            intents: [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.MessageContent,
+                GatewayIntentBits.DirectMessages
+            ],
+            partials: [Partials.Channel]
+        });
+    }
+
+    async connect() {
+        this.client.on('ready', () => {
+            console.log(`[Discord Bridge] Logged in as ${this.client.user.tag}!`);
+        });
+
+        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();
+                    }
+
+                    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);
+                    }
+                } catch (err) {
+                    console.error('[Discord Bridge] Error processing message:', err);
+                    await message.reply('ขออภัยค่ะ เกิดข้อผิดพลาดบางอย่างในการประมวลผลข้อความ');
+                }
+            }
+        });
+
+        await this.client.login(this.token);
+    }
+
+    async disconnect() {
+        if (this.client) {
+            await this.client.destroy();
+        }
+    }
+}
+
+module.exports = DiscordBridge;

package/src/Channels/google_search_bridge.js

@@ -0,0 +1,38 @@
+const axios = require('axios');
+
+class GoogleSearchBridge {
+    constructor(credentials) {
+        this.apiKey = credentials.apiKey;
+        this.cx = credentials.cx; // Custom Search Engine ID
+    }
+
+    async search(query) {
+        if (!this.apiKey || !this.cx) {
+            throw new Error('Google Search API Key and CX are required.');
+        }
+
+        try {
+            const response = await axios.get('https://www.googleapis.com/customsearch/v1', {
+                params: {
+                    key: this.apiKey,
+                    cx: this.cx,
+                    q: query,
+                    num: 5
+                }
+            });
+
+            const items = response.data.items || [];
+            return items.map(item => ({
+                title: item.title,
+                snippet: item.snippet,
+                link: item.link
+            }));
+        } catch (err) {
+            throw new Error(err.response && err.response.data && err.response.data.error 
+                ? `Google Search API Error: ${err.response.data.error.message}` 
+                : `Google Search Failed: ${err.message}`);
+        }
+    }
+}
+
+module.exports = GoogleSearchBridge;

package/src/Channels/line_bridge.js

@@ -0,0 +1,60 @@
+const line = require('@line/bot-sdk');
+const express = require('express');
+const { handleChat } = require('../AI_Brain/Gemini_API');
+
+class LineBridge {
+    constructor(credentials) {
+        this.config = {
+            channelAccessToken: credentials.accessToken,
+            channelSecret: credentials.secret,
+        };
+        this.port = credentials.port || 3000;
+        this.client = new line.messagingApi.MessagingApiClient({
+            channelAccessToken: credentials.accessToken
+        });
+        this.app = express();
+    }
+
+    async connect() {
+        this.app.post('/callback', line.middleware(this.config), (req, res) => {
+            Promise
+                .all(req.body.events.map(event => this.handleEvent(event)))
+                .then((result) => res.json(result))
+                .catch((err) => {
+                    console.error('[LINE Bridge] Error:', err);
+                    res.status(500).end();
+                });
+        });
+
+        this.server = this.app.listen(this.port, () => {
+            console.log(`[LINE Bridge] Listening for webhooks on port ${this.port}`);
+            console.log(`[LINE Bridge] Webhook URL should be: <YOUR_PUBLIC_URL>/callback`);
+        });
+    }
+
+    async handleEvent(event) {
+        if (event.type !== 'message' || event.message.type !== 'text') {
+            return Promise.resolve(null);
+        }
+
+        try {
+            const result = await handleChat(event.message.text);
+            if (result && result.response) {
+                return this.client.replyMessage({
+                    replyToken: event.replyToken,
+                    messages: [{ type: 'text', text: result.response }],
+                });
+            }
+        } catch (err) {
+            console.error('[LINE Bridge] Error processing event:', err);
+        }
+    }
+
+    async disconnect() {
+        if (this.server) {
+            this.server.close();
+        }
+    }
+}
+
+module.exports = LineBridge;

package/src/Channels/slack_bridge.js

@@ -0,0 +1,53 @@
+const { App } = require('@slack/bolt');
+const { handleChat } = require('../AI_Brain/Gemini_API');
+
+class SlackBridge {
+    constructor(credentials) {
+        this.app = new App({
+            token: credentials.botToken,
+            appToken: credentials.appToken,
+            socketMode: true
+        });
+    }
+
+    async connect() {
+        this.app.event('app_mention', async ({ event, say }) => {
+            try {
+                const text = event.text.replace(/<@.*?>/g, '').trim();
+                if (!text) return;
+
+                const result = await handleChat(text);
+                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);
+                    }
+                } catch (err) {
+                    console.error('[Slack Bridge] Error processing message:', err);
+                }
+            }
+        });
+
+        await this.app.start();
+        console.log('[Slack Bridge] App started in Socket Mode!');
+    }
+
+    async disconnect() {
+        if (this.app) {
+            await this.app.stop();
+        }
+    }
+}
+
+module.exports = SlackBridge;

package/src/Channels/telegram_bridge.js

@@ -0,0 +1,49 @@
+const { Telegraf } = require('telegraf');
+const { handleChat } = require('../AI_Brain/Gemini_API');
+
+class TelegramBridge {
+    constructor(token) {
+        this.token = token;
+        this.bot = new Telegraf(token);
+    }
+
+    async connect() {
+        this.bot.start((ctx) => ctx.reply('สวัสดีค่ะ! มิ้นท์พร้อมช่วยเหลือคุณใน Telegram แล้วนะคะ ✨'));
+
+        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);
+                }
+            } catch (err) {
+                console.error('[Telegram Bridge] Error processing message:', err);
+                await ctx.reply('ขออภัยค่ะ เกิดข้อผิดพลาดบางอย่างในการประมวลผลข้อความ');
+            }
+        });
+
+        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();
+        }
+    }
+}
+
+module.exports = TelegramBridge;

package/src/Channels/whatsapp_bridge.js

@@ -0,0 +1,55 @@
+const { Client, LocalAuth } = require('whatsapp-web.js');
+const qrcode = require('qrcode-terminal');
+const { handleChat } = require('../AI_Brain/Gemini_API');
+
+class WhatsappBridge {
+    constructor() {
+        this.client = new Client({
+            authStrategy: new LocalAuth({
+                dataPath: require('path').join(require('os').homedir(), '.config', 'mint', 'whatsapp-session')
+            }),
+            puppeteer: {
+                args: ['--no-sandbox']
+            }
+        });
+    }
+
+    async connect() {
+        this.client.on('qr', (qr) => {
+            console.log('[WhatsApp Bridge] Scan this QR code to login:');
+            qrcode.generate(qr, { small: true });
+        });
+
+        this.client.on('ready', () => {
+            console.log('[WhatsApp Bridge] Client is ready!');
+        });
+
+        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;
+                }
+
+                const result = await handleChat(msg.body);
+                if (result && result.response) {
+                    await msg.reply(result.response);
+                }
+            } catch (err) {
+                console.error('[WhatsApp Bridge] Error processing message:', err);
+            }
+        });
+
+        await this.client.initialize();
+    }
+
+    async disconnect() {
+        if (this.client) {
+            await this.client.destroy();
+        }
+    }
+}
+
+module.exports = WhatsappBridge;

package/src/Command_Parser/parser.js

@@ -1,6 +1,8 @@
 function parseCommand(aiResponse) {
     let action = { type: 'none', target: '' };
     let responseText = '';
+    let timestamp = null;
+    let providerInfo = null;
 
     if (typeof aiResponse === 'string') {
         // Attempt to parse string to JSON
@@ -8,6 +10,8 @@ function parseCommand(aiResponse) {
             const parsed = JSON.parse(aiResponse);
             action = parsed.action || action;
             responseText = parsed.response || '';
+            timestamp = parsed.timestamp || null;
+            providerInfo = parsed.providerInfo || null;
         } catch (e) {
             // Fallback for markdown
             const jsonMatch = aiResponse.match(/```json\n([\s\S]*?)\n```/) || aiResponse.match(/\{[\s\S]*\}/);
@@ -16,6 +20,8 @@ function parseCommand(aiResponse) {
                     const parsed = JSON.parse(jsonMatch[jsonMatch.length > 1 ? 1 : 0]);
                     action = parsed.action || action;
                     responseText = parsed.response || '';
+                    timestamp = parsed.timestamp || null;
+                    providerInfo = parsed.providerInfo || null;
                 } catch (err) {
                     responseText = aiResponse;
                 }
@@ -26,9 +32,14 @@ function parseCommand(aiResponse) {
     } else if (typeof aiResponse === 'object') {
         action = aiResponse.action || action;
         responseText = aiResponse.response || '';
+        timestamp = aiResponse.timestamp || null;
+        providerInfo = aiResponse.providerInfo || null;
     }
 
-    return { response: responseText, action };
+    const parsedResponse = { response: responseText, action };
+    if (timestamp) parsedResponse.timestamp = timestamp;
+    if (providerInfo) parsedResponse.providerInfo = providerInfo;
+    return parsedResponse;
 }
 
 module.exports = { parseCommand };

package/src/Plugins/gmail.js

@@ -0,0 +1,251 @@
+const axios = require('axios');
+const { readConfig } = require('../System/config_manager');
+
+const TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const GMAIL_API_BASE = 'https://gmail.googleapis.com/gmail/v1';
+
+function hasGmailConfig(config) {
+    return Boolean(config.gmailClientId && config.gmailClientSecret && config.gmailRefreshToken);
+}
+
+function parseInstruction(instruction) {
+    const raw = (instruction || '').trim();
+    if (!raw) return { action: 'help' };
+
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') {
+            return {
+                action: normalizeAction(parsed.action || 'search'),
+                ...parsed
+            };
+        }
+    } catch {
+        // Plain text searches Gmail.
+    }
+
+    const lower = raw.toLowerCase();
+    if (lower === 'help') return { action: 'help' };
+    if (lower === 'unread') return { action: 'search', query: 'is:unread' };
+    if (lower === 'inbox') return { action: 'search', query: 'in:inbox' };
+    if (lower.startsWith('read ')) return { action: 'read', id: raw.slice(5).trim() };
+    if (lower.startsWith('draft ')) return { action: 'draft', body: raw.slice(6).trim() };
+    if (lower.startsWith('search ')) return { action: 'search', query: raw.slice(7).trim() };
+
+    return { action: 'search', query: raw };
+}
+
+function normalizeAction(action) {
+    const normalized = String(action || '').toLowerCase();
+    if (['list', 'search', 'inbox', 'unread'].includes(normalized)) return 'search';
+    if (['get', 'read', 'read_email', 'message'].includes(normalized)) return 'read';
+    if (['draft', 'create_draft', 'compose', 'write'].includes(normalized)) return 'draft';
+    return normalized;
+}
+
+function gmailUserId(config) {
+    return encodeURIComponent(config.gmailUserId || 'me');
+}
+
+async function getAccessToken(config) {
+    const params = new URLSearchParams({
+        client_id: config.gmailClientId,
+        client_secret: config.gmailClientSecret,
+        refresh_token: config.gmailRefreshToken,
+        grant_type: 'refresh_token'
+    });
+
+    const response = await axios.post(TOKEN_URL, params.toString(), {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+
+    return response.data.access_token;
+}
+
+function gmailHeaders(accessToken) {
+    return {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json'
+    };
+}
+
+function decodeBase64Url(data = '') {
+    const normalized = String(data).replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized.padEnd(normalized.length + ((4 - normalized.length % 4) % 4), '=');
+    return Buffer.from(padded, 'base64').toString('utf8');
+}
+
+function encodeBase64Url(data = '') {
+    return Buffer.from(String(data), 'utf8')
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/g, '');
+}
+
+function getHeader(message, name) {
+    const headers = message.payload?.headers || [];
+    const found = headers.find(header => header.name && header.name.toLowerCase() === name.toLowerCase());
+    return found ? found.value : '';
+}
+
+function findTextPart(payload) {
+    if (!payload) return '';
+    if (payload.mimeType === 'text/plain' && payload.body?.data) {
+        return decodeBase64Url(payload.body.data);
+    }
+    if (payload.mimeType === 'text/html' && payload.body?.data) {
+        return decodeBase64Url(payload.body.data).replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+    }
+    for (const part of payload.parts || []) {
+        const text = findTextPart(part);
+        if (text) return text;
+    }
+    return payload.body?.data ? decodeBase64Url(payload.body.data) : '';
+}
+
+function formatMessageSummary(message) {
+    const subject = getHeader(message, 'Subject') || '(No subject)';
+    const from = getHeader(message, 'From') || '(Unknown sender)';
+    const date = getHeader(message, 'Date');
+    const snippet = message.snippet || '';
+    return [
+        `ID: ${message.id}`,
+        `From: ${from}`,
+        `Subject: ${subject}`,
+        date ? `Date: ${date}` : '',
+        snippet ? `Snippet: ${snippet}` : ''
+    ].filter(Boolean).join('\n');
+}
+
+async function fetchMessage(config, accessToken, id, format = 'metadata') {
+    const response = await axios.get(`${GMAIL_API_BASE}/users/${gmailUserId(config)}/messages/${encodeURIComponent(id)}`, {
+        headers: gmailHeaders(accessToken),
+        params: {
+            format,
+            metadataHeaders: ['From', 'To', 'Subject', 'Date']
+        }
+    });
+    return response.data;
+}
+
+async function searchMessages(config, input, accessToken) {
+    const query = input.query || input.q || 'in:inbox';
+    const maxResults = Number(input.maxResults || input.limit || 10);
+    const response = await axios.get(`${GMAIL_API_BASE}/users/${gmailUserId(config)}/messages`, {
+        headers: gmailHeaders(accessToken),
+        params: {
+            q: query,
+            maxResults
+        }
+    });
+
+    const messages = response.data.messages || [];
+    if (messages.length === 0) return `No Gmail messages found for query: ${query}`;
+
+    const detailed = [];
+    for (const message of messages.slice(0, maxResults)) {
+        const full = await fetchMessage(config, accessToken, message.id, 'metadata');
+        detailed.push(formatMessageSummary(full));
+    }
+
+    return `Gmail search results for "${query}":\n\n${detailed.join('\n\n')}`;
+}
+
+async function readMessage(config, input, accessToken) {
+    const id = input.id || input.messageId;
+    if (!id) throw new Error('Missing Gmail message id.');
+
+    const message = await fetchMessage(config, accessToken, id, 'full');
+    const body = findTextPart(message.payload);
+    return [
+        formatMessageSummary(message),
+        '',
+        body ? `Body:\n${body.slice(0, Number(input.maxChars || 4000))}` : 'Body: (No readable text body found)'
+    ].join('\n');
+}
+
+function sanitizeHeader(value = '') {
+    return String(value).replace(/[\r\n]+/g, ' ').trim();
+}
+
+function buildRawEmail(input) {
+    const to = sanitizeHeader(input.to || input.recipient || '');
+    if (!to) throw new Error('Missing email recipient.');
+
+    const cc = sanitizeHeader(input.cc || '');
+    const bcc = sanitizeHeader(input.bcc || '');
+    const subject = sanitizeHeader(input.subject || '(No subject)');
+    const body = String(input.body || input.content || input.text || '');
+
+    const headers = [
+        `To: ${to}`,
+        cc ? `Cc: ${cc}` : '',
+        bcc ? `Bcc: ${bcc}` : '',
+        `Subject: ${subject}`,
+        'MIME-Version: 1.0',
+        'Content-Type: text/plain; charset="UTF-8"'
+    ].filter(Boolean);
+
+    return encodeBase64Url(`${headers.join('\r\n')}\r\n\r\n${body}`);
+}
+
+async function createDraft(config, input, accessToken) {
+    const raw = buildRawEmail(input);
+    const response = await axios.post(`${GMAIL_API_BASE}/users/${gmailUserId(config)}/drafts`, {
+        message: { raw }
+    }, {
+        headers: gmailHeaders(accessToken)
+    });
+
+    const draft = response.data || {};
+    return `Created Gmail draft${draft.id ? ` ${draft.id}` : ''} for ${sanitizeHeader(input.to || input.recipient)}. Review it in Gmail before sending.`;
+}
+
+function helpText() {
+    return [
+        'Gmail plugin commands:',
+        '- Search inbox: {"action":"search","query":"in:inbox newer_than:7d","limit":5}',
+        '- Read message: {"action":"read","id":"MESSAGE_ID"}',
+        '- Create draft: {"action":"draft","to":"person@example.com","subject":"Hello","body":"Draft body"}',
+        'For safety, this plugin creates drafts only. It does not send email automatically.'
+    ].join('\n');
+}
+
+module.exports = {
+    name: 'gmail',
+    description: 'Manage Gmail safely. Target can be JSON: {"action":"search","query":"in:inbox is:unread","limit":10}, {"action":"read","id":"MESSAGE_ID"}, or {"action":"draft","to":"person@example.com","subject":"Subject","body":"Body"}. This plugin creates drafts only and does not send email.',
+
+    async execute(instruction) {
+        const config = readConfig();
+        const input = parseInstruction(instruction);
+
+        if (input.action === 'help') return helpText();
+        if (!hasGmailConfig(config)) {
+            return 'Gmail API is not configured. Add Gmail OAuth credentials with `mint onboard`. Use scopes for gmail.readonly and gmail.compose.';
+        }
+
+        const accessToken = await getAccessToken(config);
+
+        switch (input.action) {
+            case 'search':
+                return await searchMessages(config, input, accessToken);
+            case 'read':
+                return await readMessage(config, input, accessToken);
+            case 'draft':
+                return await createDraft(config, input, accessToken);
+            default:
+                throw new Error(`Unsupported Gmail action: ${input.action}`);
+        }
+    },
+
+    _helpers: {
+        parseInstruction,
+        buildRawEmail,
+        decodeBase64Url,
+        encodeBase64Url,
+        findTextPart,
+        formatMessageSummary,
+        hasGmailConfig
+    }
+};