@pheem49/mint 1.4.1 → 1.5.0

package/src/CLI/updater.js

@@ -0,0 +1,208 @@
+const { execFile } = require('child_process');
+const pkg = require('../../package.json');
+
+const NPM_COMMAND = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const DEFAULT_AUTO_UPDATE_INTERVAL_HOURS = 24;
+
+function execFilePromise(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, options, (error, stdout, stderr) => {
+            if (error) {
+                error.stdout = stdout;
+                error.stderr = stderr;
+                reject(error);
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+
+function parseVersion(version) {
+    return String(version || '')
+        .trim()
+        .replace(/^v/, '')
+        .split('-')[0]
+        .split('.')
+        .map((part) => Number.parseInt(part, 10) || 0);
+}
+
+function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    const length = Math.max(left.length, right.length, 3);
+
+    for (let i = 0; i < length; i++) {
+        const l = left[i] || 0;
+        const r = right[i] || 0;
+        if (l > r) return 1;
+        if (l < r) return -1;
+    }
+    return 0;
+}
+
+function normalizeNpmVersionOutput(output) {
+    const trimmed = String(output || '').trim();
+    if (!trimmed) return '';
+
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === 'string') return parsed;
+    } catch (err) {
+        // npm may return plain text depending on config/version.
+    }
+
+    return trimmed.replace(/^['"]|['"]$/g, '');
+}
+
+function getAutoUpdateIntervalMs(config = {}) {
+    const hours = Number(config.autoUpdateCheckIntervalHours);
+    const safeHours = Number.isFinite(hours) && hours > 0
+        ? hours
+        : DEFAULT_AUTO_UPDATE_INTERVAL_HOURS;
+    return safeHours * 60 * 60 * 1000;
+}
+
+function shouldRunAutoUpdate(config = {}, now = Date.now()) {
+    if (config.enableAutoUpdate === false) return false;
+
+    const lastCheck = Date.parse(config.lastUpdateCheckAt || '');
+    if (!Number.isFinite(lastCheck)) return true;
+
+    return now - lastCheck >= getAutoUpdateIntervalMs(config);
+}
+
+async function getLatestVersion(packageName = pkg.name) {
+    const { stdout } = await execFilePromise(NPM_COMMAND, ['view', packageName, 'version', '--json'], {
+        maxBuffer: 1024 * 1024
+    });
+    return normalizeNpmVersionOutput(stdout);
+}
+
+async function installLatest(packageName = pkg.name, options = {}) {
+    const args = ['install', '-g', `${packageName}@latest`];
+    if (options.dryRun) {
+        args.push('--dry-run');
+    }
+
+    return await execFilePromise(NPM_COMMAND, args, {
+        maxBuffer: 1024 * 1024 * 8
+    });
+}
+
+function formatUpdateError(error) {
+    const detail = [error.stderr, error.stdout, error.message].filter(Boolean).join('\n').trim();
+    if (/EACCES|permission denied|Access is denied/i.test(detail)) {
+        return [
+            'Update failed because npm does not have permission to modify the global install directory.',
+            `Run manually: npm install -g ${pkg.name}@latest`,
+            'If your npm global packages require sudo, run that command with sudo.'
+        ].join('\n');
+    }
+
+    if (/E404|404 Not Found|not in this registry/i.test(detail)) {
+        return [
+            `Could not find ${pkg.name} on the npm registry.`,
+            'Publish the package first, or update Mint from the source/release channel you installed from.'
+        ].join('\n');
+    }
+
+    return `Update failed: ${detail || 'Unknown npm error'}`;
+}
+
+async function runUpdate(options = {}) {
+    const currentVersion = pkg.version;
+    let latestVersion = '';
+
+    try {
+        latestVersion = await getLatestVersion(pkg.name);
+    } catch (error) {
+        return {
+            status: 'error',
+            currentVersion,
+            latestVersion,
+            message: formatUpdateError(error)
+        };
+    }
+
+    if (!latestVersion) {
+        return {
+            status: 'error',
+            currentVersion,
+            latestVersion: '',
+            message: 'Could not determine the latest Mint version from npm.'
+        };
+    }
+
+    const comparison = compareVersions(currentVersion, latestVersion);
+    if (comparison >= 0) {
+        return {
+            status: 'current',
+            currentVersion,
+            latestVersion,
+            message: `Mint is already up to date (${currentVersion}).`
+        };
+    }
+
+    if (options.checkOnly) {
+        return {
+            status: 'available',
+            currentVersion,
+            latestVersion,
+            message: `Mint ${latestVersion} is available. Current version: ${currentVersion}.`
+        };
+    }
+
+    try {
+        await installLatest(pkg.name, { dryRun: options.dryRun });
+        return {
+            status: options.dryRun ? 'dry-run' : 'updated',
+            currentVersion,
+            latestVersion,
+            message: options.dryRun
+                ? `Dry run complete. Mint would update from ${currentVersion} to ${latestVersion}.`
+                : `Mint updated from ${currentVersion} to ${latestVersion}. Restart mint to use the new version.`
+        };
+    } catch (error) {
+        return {
+            status: 'error',
+            currentVersion,
+            latestVersion,
+            message: formatUpdateError(error)
+        };
+    }
+}
+
+async function runStartupAutoUpdate(config, writeConfig, options = {}) {
+    const now = options.now || Date.now();
+    if (!shouldRunAutoUpdate(config, now)) {
+        return {
+            status: 'skipped',
+            message: 'Auto-update check skipped by cooldown.'
+        };
+    }
+
+    if (typeof writeConfig === 'function') {
+        writeConfig({
+            ...config,
+            lastUpdateCheckAt: new Date(now).toISOString()
+        });
+    }
+
+    return await runUpdate({ checkOnly: false });
+}
+
+module.exports = {
+    compareVersions,
+    getLatestVersion,
+    installLatest,
+    normalizeNpmVersionOutput,
+    runUpdate,
+    runStartupAutoUpdate,
+    shouldRunAutoUpdate,
+    _private: {
+        parseVersion,
+        formatUpdateError,
+        getAutoUpdateIntervalMs
+    }
+};

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