@pheem49/mint 1.4.2 → 1.5.0

package/src/CLI/code_agent.js

@@ -6,11 +6,43 @@ const { GoogleGenAI } = require('@google/genai');
 const axios = require('axios');
 const cheerio = require('cheerio');
 const { readConfig, getAvailableProviders } = require('../System/config_manager');
+const safetyManager = require('../System/safety_manager');
 const { readWorkspaceSession, writeWorkspaceSession } = require('./code_session_memory');
 const { executeAction } = require('../../mint-cli-logic');
 
-async function webSearch(query) {
+async function webSearch(query, onProgress = () => {}) {
     if (!query) throw new Error('Search query required.');
+    const config = readConfig();
+
+    // 1. Try Google Search API if configured
+    if (config.googleSearchApiKey && config.googleSearchCx) {
+        try {
+            const GoogleSearch = require('../Channels/google_search_bridge');
+            const google = new GoogleSearch({ apiKey: config.googleSearchApiKey, cx: config.googleSearchCx });
+            const results = await google.search(query);
+            if (results.length > 0) {
+                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+            }
+        } catch (e) { 
+            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        }
+    }
+
+    // 2. Try Brave Search API if configured
+    if (config.braveSearchApiKey) {
+        try {
+            const BraveSearch = require('../Channels/brave_search_bridge');
+            const brave = new BraveSearch({ apiKey: config.braveSearchApiKey });
+            const results = await brave.search(query);
+            if (results.length > 0) {
+                return results.map(r => `Title: ${r.title}\nSnippet: ${r.snippet}\nURL: ${r.link}`).join('\n\n');
+            }
+        } catch (e) { 
+            onProgress({ phase: 'error', action: 'web_search', message: e.message });
+        }
+    }
+
+    // 3. Fallback to DuckDuckGo Scraping
     try {
         const response = await axios.get(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
             headers: {
@@ -28,8 +60,14 @@ async function webSearch(query) {
                 results.push(`Title: ${title}\nSnippet: ${snippet}\nURL: ${link}`);
             }
         });
+
+        if (results.length === 0) {
+             onProgress({ phase: 'error', action: 'web_search', message: 'DuckDuckGo scraping returned no results. It might be blocking us.' });
+        }
+
         return results.length > 0 ? results.join('\n\n') : 'No results found.';
     } catch (e) {
+        onProgress({ phase: 'error', action: 'web_search', message: `DuckDuckGo fallback failed: ${e.message}` });
         return `Search failed: ${e.message}`;
     }
 }
@@ -48,6 +86,10 @@ You work in an inspect -> plan -> act -> verify loop.
 PERSONALITY & TONE:
 - Gender: Female.
 - Persona: Friendly, energetic, polite, and slightly playful.
+- Language routing is mandatory and based on the user's latest message:
+  - If the latest user message contains Thai characters, respond in Thai.
+  - If the latest user message is English, ASCII-only, or a short English greeting such as "hi", "hello", "ok", or "thanks", respond in English.
+  - Do not use Thai just because your persona mentions Mint/มิ้นท์, previous history was Thai, or app settings use th-TH.
 - Politeness: 
   - **WHEN RESPONDING IN THAI:** ALWAYS use female polite particles such as "ค่ะ", "นะคะ", "นะค๊า", "จ้า". Refer to yourself as "มิ้นท์" or "หนู".
   - **WHEN RESPONDING IN ENGLISH:** Use a cheerful, polite, and bubbly tone.
@@ -127,20 +169,40 @@ function extractJson(text) {
     }
 }
 
-function selectSupportedCodeProvider(config, availableProviders = getAvailableProviders(config || {})) {
-    const requestedProvider = (config && config.aiProvider) || 'gemini';
+function getSupportedCodeProviderOrder(config, availableProviders = getAvailableProviders(config || {}), requestedOverride = null) {
+    const requestedProvider = requestedOverride || (config && config.aiProvider) || 'gemini';
+    const priority = ['anthropic', 'openai', 'gemini', 'local_openai'];
+    const ordered = [];
+
     if (SUPPORTED_CODE_PROVIDERS.includes(requestedProvider) && availableProviders.includes(requestedProvider)) {
-        return requestedProvider;
+        ordered.push(requestedProvider);
     }
 
-    const priority = ['anthropic', 'openai', 'gemini', 'local_openai'];
     for (const provider of priority) {
-        if (availableProviders.includes(provider)) {
-            return provider;
+        if (availableProviders.includes(provider) && !ordered.includes(provider)) {
+            ordered.push(provider);
         }
     }
 
-    return 'gemini';
+    return ordered.length > 0 ? ordered : ['gemini'];
+}
+
+function selectSupportedCodeProvider(config, availableProviders = getAvailableProviders(config || {})) {
+    return getSupportedCodeProviderOrder(config, availableProviders)[0];
+}
+
+function getCodeProviderModel(provider, config = {}) {
+    switch (provider) {
+        case 'anthropic':
+            return config.anthropicModel || 'claude-3-5-sonnet-latest';
+        case 'openai':
+            return config.openaiModel || 'gpt-4o';
+        case 'local_openai':
+            return config.localModelName || 'local-model';
+        case 'gemini':
+        default:
+            return config.geminiModel || DEFAULT_GEMINI_MODEL;
+    }
 }
 
 function resolveWorkspacePath(workspaceRoot, targetPath = '.') {
@@ -301,21 +363,7 @@ async function findPaths(workspaceRoot, query, type = 'any') {
 }
 
 function assertSafeShell(command) {
-    const blockedPatterns = [
-        /\brm\s+-rf\b/,
-        /\bgit\s+reset\s+--hard\b/,
-        /\bgit\s+checkout\s+--\b/,
-        /\bmkfs\b/,
-        /\bshutdown\b/,
-        /\breboot\b/,
-        />\s*\/dev\//,
-        /\bcurl\b.*\|\s*(sh|bash)\b/,
-        /\bwget\b.*\|\s*(sh|bash)\b/
-    ];
-
-    if (blockedPatterns.some(pattern => pattern.test(command))) {
-        throw new Error(`Blocked unsafe command: ${command}`);
-    }
+    return safetyManager.assertShellCommandAllowed(command);
 }
 
 async function runShell(workspaceRoot, command) {
@@ -386,27 +434,44 @@ function writeFile(workspaceRoot, targetPath, content) {
 }
 
 class UnifiedAgentClient {
-    constructor(provider, config) {
+    constructor(provider, config, providerOrder = [provider]) {
         this.provider = SUPPORTED_CODE_PROVIDERS.includes(provider) ? provider : 'gemini';
+        this.providerOrder = providerOrder.length > 0 ? providerOrder : [this.provider];
         this.config = config;
         this.history = [];
         this.systemInstruction = CODE_AGENT_PROMPT;
+        this.lastSuccessfulProvider = null;
     }
 
     async sendMessage(observation) {
         this.history.push({ role: 'user', content: observation });
 
-        let responseText = '';
-        if (this.provider === 'anthropic') {
-            responseText = await this._callAnthropic();
-        } else if (this.provider === 'openai' || this.provider === 'local_openai') {
-            responseText = await this._callOpenAI();
-        } else {
-            responseText = await this._callGemini();
+        const failures = [];
+        for (const provider of this.providerOrder) {
+            this.provider = SUPPORTED_CODE_PROVIDERS.includes(provider) ? provider : 'gemini';
+            try {
+                let responseText = '';
+                if (this.provider === 'anthropic') {
+                    responseText = await this._callAnthropic();
+                } else if (this.provider === 'openai' || this.provider === 'local_openai') {
+                    responseText = await this._callOpenAI();
+                } else {
+                    responseText = await this._callGemini();
+                }
+
+                this.history.push({ role: 'assistant', content: responseText });
+                this.lastSuccessfulProvider = this.provider;
+                return responseText;
+            } catch (error) {
+                const message = error.message || error.code || 'unknown error';
+                failures.push(`${this.provider}: ${message}`);
+                if (process.env.MINT_DEBUG === '1') {
+                    console.error(`[Code Agent Fallback] Provider '${this.provider}' failed: ${message}`);
+                }
+            }
         }
 
-        this.history.push({ role: 'assistant', content: responseText });
-        return responseText;
+        throw new Error(`All code agent providers failed. ${failures.join(' | ')}`);
     }
 
     async _callAnthropic() {
@@ -571,7 +636,7 @@ async function buildInitialObservation(task, workspaceRoot, history = []) {
         session.summary || '(none)',
         `Previous task: ${session.lastTask || '(none)'}`,
         `Previous verification: ${session.lastVerification || '(none)'}`,
-        'Start by inspecting the workspace before making edits unless the task is trivial.'
+        'If the task is conversational or trivial, finish directly without inspecting the workspace. For code/workspace tasks, inspect before making edits.'
     ].join('\n');
 }
 
@@ -586,8 +651,10 @@ async function executeCodeTask(task, options = {}) {
         ? options.askUser
         : async (q) => `User didn't answer: ${q}`;
     const config = readConfig();
-    const provider = options.provider || selectSupportedCodeProvider(config);
-    const client = new UnifiedAgentClient(provider, config);
+    const availableProviders = getAvailableProviders(config);
+    const providerOrder = getSupportedCodeProviderOrder(config, availableProviders, options.provider);
+    const provider = providerOrder[0];
+    const client = new UnifiedAgentClient(provider, config, providerOrder);
 
     let observation = await buildInitialObservation(task, workspaceRoot, history);
 
@@ -627,7 +694,7 @@ async function executeCodeTask(task, options = {}) {
         try {
             switch (action) {
                 case 'web_search':
-                    toolResult = await webSearch(input.query);
+                    toolResult = await webSearch(input.query, onProgress);
                     break;
                 case 'list_files':
                     toolResult = await listFiles(workspaceRoot, input.path || '.');
@@ -640,6 +707,13 @@ async function executeCodeTask(task, options = {}) {
                     break;
                 case 'find_path':
                     toolResult = await findPaths(workspaceRoot, input.query, input.type);
+                    if (input.openAfter === true) {
+                        const result = JSON.parse(toolResult);
+                        if (result.success && result.matches.length === 1) {
+                            await executeAction({ type: 'open_folder', target: result.matches[0].path });
+                            toolResult = `Found and opened: ${result.matches[0].path}`;
+                        }
+                    }
                     break;
                 case 'run_shell': {
                     const approved = await requestApproval({
@@ -651,6 +725,12 @@ async function executeCodeTask(task, options = {}) {
                         toolResult = `User denied shell command: ${input.command}`;
                         break;
                     }
+                    safetyManager.appendActionLog({
+                        source: 'code_agent',
+                        action: 'run_shell',
+                        command: input.command,
+                        approved
+                    });
                     toolResult = await runShell(workspaceRoot, input.command);
                     break;
                 }
@@ -665,6 +745,12 @@ async function executeCodeTask(task, options = {}) {
                         toolResult = `User denied patch for ${patchInput.path}`;
                         break;
                     }
+                    safetyManager.appendActionLog({
+                        source: 'code_agent',
+                        action: 'apply_patch',
+                        path: patchInput.path,
+                        approved
+                    });
                     toolResult = applyPatch(workspaceRoot, patchInput);
                     break;
                 }
@@ -678,6 +764,12 @@ async function executeCodeTask(task, options = {}) {
                         toolResult = `User denied full file write for ${input.path}`;
                         break;
                     }
+                    safetyManager.appendActionLog({
+                        source: 'code_agent',
+                        action: 'write_file',
+                        path: input.path,
+                        approved
+                    });
                     toolResult = writeFile(workspaceRoot, input.path, input.content);
                     break;
                 }
@@ -696,7 +788,7 @@ async function executeCodeTask(task, options = {}) {
                     // Delegate to existing automation logic
                     toolResult = await executeAction({
                         type: action,
-                        target: input.target
+                        target: input.target || input.path || input.query // Handle all possible input fields
                     });
                     break;
                 }                default:
@@ -718,8 +810,7 @@ async function executeCodeTask(task, options = {}) {
             step,
             phase: 'finished',
             action,
-            target: (input.path || input.command || input.query || '') + resultSummary,
-            thought: decision.thought
+            target: (input.path || input.command || input.query || '') + resultSummary
         });
 
         // Format tool result to be more readable and structured for the agent
@@ -767,10 +858,15 @@ async function executeCodeTask(task, options = {}) {
     }
 
     if (finalSummary) {
+        const answeredProvider = client.lastSuccessfulProvider || client.provider || provider;
         return {
             summary: finalSummary,
             verification: finalVerification,
-            steps: executedSteps
+            steps: executedSteps,
+            providerInfo: {
+                provider: answeredProvider,
+                model: getCodeProviderModel(answeredProvider, config)
+            }
         };
     }
 
@@ -780,10 +876,15 @@ async function executeCodeTask(task, options = {}) {
         lastVerification: 'Agent limit reached before explicit completion.'
     });
 
+    const answeredProvider = client.lastSuccessfulProvider || client.provider || provider;
     return {
         summary: 'Stopped after reaching the maximum number of agent steps.',
         verification: 'Agent limit reached before explicit completion.',
-        steps: executedSteps || MAX_AGENT_STEPS
+        steps: executedSteps || MAX_AGENT_STEPS,
+        providerInfo: {
+            provider: answeredProvider,
+            model: getCodeProviderModel(answeredProvider, config)
+        }
     };
 }
 
@@ -792,6 +893,7 @@ module.exports = {
     _helpers: {
         extractJson,
         selectSupportedCodeProvider,
+        getSupportedCodeProviderOrder,
         findPaths,
         listFiles,
         searchCode,

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,8 +22,10 @@ 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' }