@pheem49/mint 1.4.2 → 1.5.0

package/src/CLI/onboarding.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { readConfig, writeConfig } = require('../System/config_manager');
 const { installDaemon } = require('../System/daemon_manager');
+const { runGmailAuth } = require('./gmail_auth');
 
 /**
  * Onboarding Wizard for Mint CLI
@@ -12,84 +13,335 @@ async function runOnboarding(options = {}) {
     
     console.log('\nWelcome to Mint Onboarding! Let\'s get you set up.\n');
 
-    const config = readConfig();
+    let config = readConfig();
 
-    const questions = [
+    // 1. Basic Setup (Gemini is mandatory for core features)
+    const basicAnswers = await inquirer.prompt([
         {
             type: 'input',
             name: 'apiKey',
-            message: 'Enter your Google Gemini API Key (Required for basic features):',
+            message: 'Enter your Google Gemini API Key:',
             default: config.apiKey || undefined,
             validate: (input) => input.trim().length > 0 ? true : 'API Key is required.'
         },
         {
             type: 'list',
-            name: 'geminiModelChoice',
-            message: 'Select the primary Gemini model to use:',
+            name: 'geminiModel',
+            message: 'Select primary Gemini model:',
             choices: [
                 'gemini-2.5-flash',
-                'gemini-2.0-pro-exp-02-05',
                 'gemini-3.1-flash-lite-preview',
-                'gemini-3.1-flash-lite',
-                'Custom model name'
+                'gemini-1.5-pro'
             ],
             default: config.geminiModel || 'gemini-2.5-flash'
-        },
-        {
-            type: 'input',
-            name: 'customGeminiModel',
-            message: 'Enter your custom Gemini model name:',
-            when: (answers) => answers.geminiModelChoice === 'Custom model name',
-            validate: (input) => input.trim().length > 0 ? true : 'Please enter a valid model name.'
-        },
-        {
-            type: 'input',
-            name: 'anthropicApiKey',
-            message: 'Enter your Anthropic API Key (Optional, press Enter to skip):',
-            default: config.anthropicApiKey || ''
-        },
-        {
-            type: 'input',
-            name: 'openaiApiKey',
-            message: 'Enter your OpenAI API Key (Optional, press Enter to skip):',
-            default: config.openaiApiKey || ''
-        },
-        {
-            type: 'input',
-            name: 'hfApiKey',
-            message: 'Enter your Hugging Face API Key (Optional, press Enter to skip):',
-            default: config.hfApiKey || ''
-        },
-        {
-            type: 'input',
-            name: 'localApiBaseUrl',
-            message: 'Enter your Local AI (LM Studio/OpenAI Compatible) Base URL (Optional, press Enter to skip):',
-            default: config.localApiBaseUrl || ''
-        },
+        }
+    ]);
+
+    config = { ...config, ...basicAnswers };
+
+    // 2. Interactive Channel/Provider Selection (QuickStart Style)
+    const { selections } = await inquirer.prompt([
         {
-            type: 'input',
-            name: 'localModelName',
-            message: 'Enter your Local Model Name (Optional, press Enter to skip):',
-            default: config.localModelName || ''
+            type: 'checkbox',
+            name: 'selections',
+            message: 'Select channels/providers to configure (QuickStart):',
+            pageSize: 20,
+            choices: [
+                { name: 'Telegram (Bot API)', value: 'telegram', checked: config.enableTelegramBridge },
+                { name: 'WhatsApp (QR link)', value: 'whatsapp', checked: config.enableWhatsappBridge },
+                { name: 'Discord (Bot API)', value: 'discord', checked: config.enableDiscordBridge },
+                { name: 'Slack (Socket Mode)', value: 'slack', checked: config.enableSlackBridge },
+                { name: 'LINE (Messaging API)', value: 'line', checked: config.enableLineBridge },
+                { name: 'Google Calendar API', value: 'google_calendar', checked: config.pluginCalendarEnabled },
+                { name: 'Gmail API', value: 'gmail', checked: config.pluginGmailEnabled },
+                { name: 'Notion API', value: 'notion', checked: config.pluginNotionEnabled },
+                new inquirer.Separator(),
+                { name: 'Anthropic (Claude)', value: 'anthropic', checked: config.aiProvider === 'anthropic' || !!config.anthropicApiKey },
+                { name: 'OpenAI (GPT-4o)', value: 'openai', checked: config.aiProvider === 'openai' || !!config.openaiApiKey },
+                { name: 'Hugging Face', value: 'hf', checked: config.aiProvider === 'huggingface' || !!config.hfApiKey },
+                { name: 'Local AI (LM Studio/Ollama)', value: 'local', checked: config.aiProvider === 'local_openai' || (!!config.localApiBaseUrl && config.localApiBaseUrl.length > 0) },
+                new inquirer.Separator(),
+                { name: 'Google Search API', value: 'google_search', checked: !!config.googleSearchApiKey },
+                { name: 'Brave Search API', value: 'brave_search', checked: !!config.braveSearchApiKey },
+                new inquirer.Separator(),
+                { name: 'Skip for now', value: 'skip' }
+            ]
         }
-    ];
+    ]);
 
-    const answers = await inquirer.prompt(questions);
+    // 3. Configure selected items
+    const dynamicQuestions = [];
     
-    // Resolve custom gemini model if selected
-    const geminiModel = answers.geminiModelChoice === 'Custom model name' 
-        ? answers.customGeminiModel 
-        : answers.geminiModelChoice;
+    // Reset enabled flags if we are not skipping
+    if (!selections.includes('skip')) {
+        config.enableTelegramBridge = selections.includes('telegram');
+        config.enableWhatsappBridge = selections.includes('whatsapp');
+        config.enableDiscordBridge = selections.includes('discord');
+        config.enableSlackBridge = selections.includes('slack');
+        config.enableLineBridge = selections.includes('line');
+    }
+
+    // If "Skip for now" is selected or nothing is selected, we move to save
+    if (selections.includes('skip')) {
+        console.log('\n⏩ Skipping optional configuration...');
+    } else {
+        if (selections.includes('google_search')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'googleSearchApiKey',
+                message: 'Enter Google Search API Key:',
+                default: config.googleSearchApiKey
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'googleSearchCx',
+                message: 'Enter Google Search CX (Engine ID):',
+                default: config.googleSearchCx
+            });
+        }
 
-    // Remove temporary choice fields before saving
-    delete answers.geminiModelChoice;
-    delete answers.customGeminiModel;
+        if (selections.includes('brave_search')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'braveSearchApiKey',
+                message: 'Enter Brave Search API Key:',
+                default: config.braveSearchApiKey
+            });
+        }
+        if (selections.includes('discord')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'discordBotToken',
+                message: 'Enter Discord Bot Token:',
+                default: config.discordBotToken
+            });
+        }
+
+        if (selections.includes('telegram')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'telegramBotToken',
+                message: 'Enter Telegram Bot Token:',
+                default: config.telegramBotToken
+            });
+        }
+
+        if (selections.includes('slack')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'slackBotToken',
+                message: 'Enter Slack Bot Token (xoxb-...):',
+                default: config.slackBotToken
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'slackAppToken',
+                message: 'Enter Slack App Token (xapp-...):',
+                default: config.slackAppToken
+            });
+        }
+
+        if (selections.includes('line')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'lineChannelAccessToken',
+                message: 'Enter LINE Channel Access Token:',
+                default: config.lineChannelAccessToken
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'lineChannelSecret',
+                message: 'Enter LINE Channel Secret:',
+                default: config.lineChannelSecret
+            });
+            dynamicQuestions.push({
+                type: 'number',
+                name: 'lineWebhookPort',
+                message: 'Enter LINE Webhook Port (Local):',
+                default: config.lineWebhookPort || 3000
+            });
+        }
+
+        if (selections.includes('google_calendar')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'googleCalendarClientId',
+                message: 'Enter Google Calendar OAuth Client ID:',
+                default: config.googleCalendarClientId
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'googleCalendarClientSecret',
+                message: 'Enter Google Calendar OAuth Client Secret:',
+                default: config.googleCalendarClientSecret
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'googleCalendarRefreshToken',
+                message: 'Enter Google Calendar Refresh Token:',
+                default: config.googleCalendarRefreshToken
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'googleCalendarId',
+                message: 'Enter Google Calendar ID:',
+                default: config.googleCalendarId || 'primary'
+            });
+            config.pluginCalendarEnabled = true;
+        } else {
+            config.pluginCalendarEnabled = false;
+        }
+
+        if (selections.includes('gmail')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'gmailClientId',
+                message: 'Enter Gmail OAuth Client ID:',
+                default: config.gmailClientId
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'gmailClientSecret',
+                message: 'Enter Gmail OAuth Client Secret:',
+                default: config.gmailClientSecret
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'gmailRefreshToken',
+                message: 'Enter Gmail Refresh Token:',
+                default: config.gmailRefreshToken
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'gmailUserId',
+                message: 'Enter Gmail User ID:',
+                default: config.gmailUserId || 'me'
+            });
+            config.pluginGmailEnabled = true;
+        } else {
+            config.pluginGmailEnabled = false;
+        }
+
+        if (selections.includes('notion')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'notionApiKey',
+                message: 'Enter Notion Internal Integration Secret:',
+                default: config.notionApiKey
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'notionDatabaseId',
+                message: 'Enter default Notion Database ID (optional):',
+                default: config.notionDatabaseId
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'notionPageId',
+                message: 'Enter default Notion Page ID (optional):',
+                default: config.notionPageId
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'notionTitleProperty',
+                message: 'Enter database title property name:',
+                default: config.notionTitleProperty || 'Name'
+            });
+            config.pluginNotionEnabled = true;
+        } else {
+            config.pluginNotionEnabled = false;
+        }
+
+        if (selections.includes('anthropic')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'anthropicApiKey',
+                message: 'Enter Anthropic API Key:',
+                default: config.anthropicApiKey
+            });
+        }
+
+        if (selections.includes('openai')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'openaiApiKey',
+                message: 'Enter OpenAI API Key:',
+                default: config.openaiApiKey
+            });
+        }
+
+        if (selections.includes('hf')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'hfApiKey',
+                message: 'Enter Hugging Face API Key:',
+                default: config.hfApiKey
+            });
+        }
+
+        if (selections.includes('local')) {
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'localApiBaseUrl',
+                message: 'Enter Local AI Base URL:',
+                default: config.localApiBaseUrl || 'http://localhost:1234/v1'
+            });
+            dynamicQuestions.push({
+                type: 'input',
+                name: 'localModelName',
+                message: 'Enter Local Model Name:',
+                default: config.localModelName || 'local-model'
+            });
+        }
+    }
+
+    if (dynamicQuestions.length > 0) {
+        const extraAnswers = await inquirer.prompt(dynamicQuestions);
+        config = { ...config, ...extraAnswers };
+        
+    }
+
+    // Ensure aiProvider reflects the selected primary AI. If no optional AI
+    // provider is selected, keep Gemini as the safe default from basic setup.
+    if (!selections.includes('skip')) {
+        if (selections.includes('anthropic')) config.aiProvider = 'anthropic';
+        else if (selections.includes('openai')) config.aiProvider = 'openai';
+        else if (selections.includes('hf')) config.aiProvider = 'huggingface';
+        else if (selections.includes('local')) config.aiProvider = 'local_openai';
+        else config.aiProvider = 'gemini';
+    }
 
     // Save configuration
-    const newConfig = { ...config, ...answers, geminiModel };
-    writeConfig(newConfig);
+    writeConfig(config);
     console.log('\n✅ Configuration saved successfully!');
 
+    if (!selections.includes('skip') && selections.includes('gmail') && !config.gmailRefreshToken) {
+        const { runGmailAuthNow } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'runGmailAuthNow',
+                message: 'Gmail Refresh Token is empty. Start Gmail OAuth now?',
+                default: true
+            }
+        ]);
+
+        if (runGmailAuthNow) {
+            console.log('\n🔐 Starting Gmail OAuth. Open the link below, sign in, and approve access.');
+            try {
+                const result = await runGmailAuth({
+                    logger: console,
+                    openBrowser: false
+                });
+                console.log(`✅ Gmail connected for ${result.userId}. Refresh token saved.`);
+            } catch (err) {
+                console.error(`❌ Gmail OAuth failed: ${err.message}`);
+                console.log('You can retry later with: mint gmail auth');
+            }
+        } else {
+            console.log('You can connect Gmail later with: mint gmail auth');
+        }
+    }
+
     // Install Daemon if requested
     if (options.installDaemon) {
         console.log('\n🚀 Installing Mint Background Agent (Daemon)...');

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;