@pheem49/mint 1.4.1 → 1.5.0

package/src/CLI/gmail_auth.js

@@ -0,0 +1,210 @@
+const http = require('http');
+const { execFile } = require('child_process');
+const crypto = require('crypto');
+const axios = require('axios');
+const { readConfig, writeConfig } = require('../System/config_manager');
+
+const TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
+const DEFAULT_SCOPES = [
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.compose'
+];
+
+function buildRedirectUri(port) {
+    return `http://127.0.0.1:${port}/oauth2callback`;
+}
+
+function buildAuthUrl({ clientId, redirectUri, state, scopes = DEFAULT_SCOPES }) {
+    const params = new URLSearchParams({
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        response_type: 'code',
+        scope: scopes.join(' '),
+        access_type: 'offline',
+        prompt: 'consent',
+        state
+    });
+
+    return `${AUTH_URL}?${params.toString()}`;
+}
+
+function openBrowser(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'cmd'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+
+    return new Promise((resolve, reject) => {
+        execFile(command, args, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+
+async function exchangeCodeForToken({ clientId, clientSecret, code, redirectUri }) {
+    const params = new URLSearchParams({
+        client_id: clientId,
+        client_secret: clientSecret,
+        code,
+        redirect_uri: redirectUri,
+        grant_type: 'authorization_code'
+    });
+
+    const response = await axios.post(TOKEN_URL, params.toString(), {
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+    });
+
+    return response.data;
+}
+
+function waitForOAuthCode({ port = 0, state, timeoutMs = 180000 }) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timer = null;
+
+        const finish = (error, value) => {
+            if (settled) return;
+            settled = true;
+            if (timer) clearTimeout(timer);
+            server.close(() => {
+                if (error) reject(error);
+                else resolve(value);
+            });
+        };
+
+        const server = http.createServer((req, res) => {
+            try {
+                const url = new URL(req.url, 'http://127.0.0.1');
+                if (url.pathname !== '/oauth2callback') {
+                    res.writeHead(404, { 'Content-Type': 'text/plain' });
+                    res.end('Not found');
+                    return;
+                }
+
+                const returnedState = url.searchParams.get('state');
+                const error = url.searchParams.get('error');
+                const code = url.searchParams.get('code');
+
+                if (error) {
+                    res.writeHead(400, { 'Content-Type': 'text/plain' });
+                    res.end(`Gmail authorization failed: ${error}`);
+                    finish(new Error(`Gmail authorization failed: ${error}`));
+                    return;
+                }
+
+                if (!code || returnedState !== state) {
+                    res.writeHead(400, { 'Content-Type': 'text/plain' });
+                    res.end('Invalid Gmail authorization response.');
+                    finish(new Error('Invalid Gmail authorization response.'));
+                    return;
+                }
+
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end('<h1>Gmail connected</h1><p>You can close this window and return to Mint.</p>');
+                finish(null, code);
+            } catch (err) {
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+                res.end('Internal error.');
+                finish(err);
+            }
+        });
+
+        server.on('error', finish);
+        server.listen(port, '127.0.0.1', () => {
+            timer = setTimeout(() => {
+                finish(new Error('Timed out waiting for Gmail authorization callback.'));
+            }, timeoutMs);
+        });
+    });
+}
+
+async function runGmailAuth(options = {}) {
+    const logger = options.logger || console;
+    const config = options.readConfig ? options.readConfig() : readConfig();
+    const clientId = (config.gmailClientId || '').trim();
+    const clientSecret = (config.gmailClientSecret || '').trim();
+    const userId = (config.gmailUserId || 'me').trim() || 'me';
+
+    if (!clientId || !clientSecret) {
+        throw new Error('Missing Gmail OAuth Client ID or Client Secret. Run `mint onboard` and fill Gmail API credentials first.');
+    }
+
+    const state = crypto.randomBytes(16).toString('hex');
+    const actualPort = options.getAuthorizationCode ? Number(options.port || 8787) : await reserveLocalPort(Number(options.port || 0));
+    const redirectUri = buildRedirectUri(actualPort);
+    const codePromise = options.getAuthorizationCode
+        ? null
+        : waitForOAuthCode({
+            port: actualPort,
+            state,
+            timeoutMs: options.timeoutMs || 180000
+        });
+    const authUrl = buildAuthUrl({ clientId, redirectUri, state, scopes: options.scopes || DEFAULT_SCOPES });
+
+    logger.log(`Open this Google OAuth consent link for Gmail (${userId}):\n${authUrl}\n`);
+
+    if (options.openBrowser !== false) {
+        const browserOpener = options.openBrowser || openBrowser;
+        await browserOpener(authUrl);
+    }
+
+    const code = options.getAuthorizationCode
+        ? await options.getAuthorizationCode({ authUrl, state, redirectUri })
+        : await codePromise;
+    const token = await exchangeCodeForToken({
+        clientId,
+        clientSecret,
+        code,
+        redirectUri
+    });
+
+    if (!token.refresh_token) {
+        throw new Error('Google did not return a refresh token. Re-run `mint gmail auth`; the flow uses prompt=consent to request one.');
+    }
+
+    const nextConfig = {
+        ...config,
+        gmailRefreshToken: token.refresh_token,
+        gmailUserId: userId,
+        pluginGmailEnabled: true
+    };
+
+    const writeResult = options.writeConfig ? options.writeConfig(nextConfig) : writeConfig(nextConfig);
+    if (writeResult && writeResult.success === false) {
+        throw new Error(writeResult.message || 'Failed to save Gmail refresh token.');
+    }
+
+    return {
+        success: true,
+        userId,
+        scopes: options.scopes || DEFAULT_SCOPES
+    };
+}
+
+function reserveLocalPort(port = 0) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer();
+        server.on('error', reject);
+        server.listen(port, '127.0.0.1', () => {
+            const actualPort = server.address().port;
+            server.close(() => resolve(actualPort));
+        });
+    });
+}
+
+module.exports = {
+    DEFAULT_SCOPES,
+    buildRedirectUri,
+    buildAuthUrl,
+    exchangeCodeForToken,
+    waitForOAuthCode,
+    reserveLocalPort,
+    runGmailAuth
+};

package/src/CLI/list_features.js

@@ -22,11 +22,15 @@ function displayFeatures() {
     const commands = [
         { cmd: 'mint', desc: 'Start interactive chat session (Default)' },
         { cmd: 'mint code "<task>"', desc: 'Run workspace-aware coding agent in current directory' },
+        { cmd: 'mint gmail auth', desc: 'Connect Gmail OAuth and save refresh token' },
+        { cmd: 'mint mcp', desc: 'Manage Model Context Protocol (MCP) servers' },
+        { cmd: 'mint task "<task>"', desc: 'Queue an autonomous task for the background agent' },
+        { cmd: 'mint update', desc: 'Check for and install the latest Mint CLI version' },
         { cmd: 'mint onboard', desc: 'Run setup wizard (API Key, Model, Daemon)' },
         { cmd: 'mint agent', desc: 'Run Mint as a background agent (Headless)' },
         { cmd: 'mint list', desc: 'Show this features & commands list' }
     ];
-    commands.forEach(c => console.log(`  - ${colors.cyan}${c.cmd.padEnd(15)}${colors.reset} : ${c.desc}`));
+    commands.forEach(c => console.log(`  - ${colors.cyan}${c.cmd.padEnd(18)}${colors.reset} : ${c.desc}`));
 
     console.log(`\n${colors.bright}AI Core Actions (Automation):${colors.reset}`);
     const actions = [

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)...');