minovative-mind-cli 2.2.5 → 2.3.1

package/dist/services/proxyClient.js

@@ -1,4 +1,61 @@
 import { debugLog } from '../utils/logger.js';
+/**
+ * ============================================================================
+ *                               PROXY CLIENT SERVICE
+ * ============================================================================
+ * Facilitates stream-based communication with the secure, Firebase-authenticated
+ * serverless Gemini content generation proxy.
+ *
+ * Core Capabilities:
+ * - Server-Sent Events (SSE) parsing for thoughts, text, and function calls.
+ * - Secure Authentication handling (Firebase ID Tokens).
+ * - Real-time stream-callback piping for instant responses.
+ * - Accurate token usage, credit consumption, and grounding metadata parsing.
+ * ============================================================================
+ */
+/**
+ * Helper to pause execution for a specified duration, respecting abort signals.
+ */
+async function delay(ms, abortSignal) {
+    return new Promise((resolve, reject) => {
+        let timeout;
+        const abortHandler = () => {
+            clearTimeout(timeout);
+            reject(new Error('Operation aborted'));
+        };
+        if (abortSignal?.aborted) {
+            return abortHandler();
+        }
+        abortSignal?.addEventListener('abort', abortHandler);
+        timeout = setTimeout(() => {
+            abortSignal?.removeEventListener('abort', abortHandler);
+            resolve();
+        }, ms);
+    });
+}
+let globalSessionAccumulatedUsage = {
+    promptTokens: 0,
+    candidatesTokens: 0,
+    cachedTokens: 0,
+    totalTokenCount: 0,
+    creditsUsed: 0,
+    remainingBalance: undefined
+};
+export function getAndResetTurnUsage() {
+    const current = { ...globalSessionAccumulatedUsage };
+    globalSessionAccumulatedUsage = {
+        promptTokens: 0,
+        candidatesTokens: 0,
+        cachedTokens: 0,
+        totalTokenCount: 0,
+        creditsUsed: 0,
+        remainingBalance: undefined
+    };
+    return current;
+}
+export function peekTurnUsage() {
+    return { ...globalSessionAccumulatedUsage };
+}
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.
@@ -22,123 +79,162 @@ export class ProxyClient {
      * @throws {Error} If authentication fails (401), credits are insufficient (402), or network/proxy errors occur.
      */
     async generateFunctionCallViaProxy(idToken, modelName, contents, tools, toolConfig, systemInstruction, generationConfig, streamCallbacks, abortSignal) {
-        const response = await fetch(this.PROXY_URL, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'X-Firebase-Auth': `Bearer ${idToken}`,
-            },
-            body: JSON.stringify({
-                model: modelName,
-                contents,
-                tools,
-                toolConfig,
-                systemInstruction,
-                generationConfig,
-            }),
-            signal: abortSignal,
-        });
-        debugLog(`Proxy Request to ${modelName} complete. Status: ${response.status} ${response.statusText}`);
-        if (response.status === 401) {
-            let details = '';
-            try {
-                const text = await response.text();
+        const MAX_RETRIES = 5;
+        const BASE_DELAY_MS = 2000;
+        const MAX_DELAY_MS = 30000;
+        let attempt = 0;
+        retryLoop: while (true) {
+            const response = await fetch(this.PROXY_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Firebase-Auth': `Bearer ${idToken}`,
+                },
+                body: JSON.stringify({
+                    model: modelName,
+                    contents,
+                    tools,
+                    toolConfig,
+                    systemInstruction,
+                    generationConfig,
+                }),
+                signal: abortSignal,
+            });
+            debugLog(`Proxy Request to ${modelName} complete. Status: ${response.status} ${response.statusText}`);
+            if ((response.status === 429 || response.status === 503) && attempt < MAX_RETRIES) {
+                const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
+                const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                console.warn(`Rate limit or service unavailable hit (${response.status}). Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
+                await delay(delayTime, abortSignal);
+                attempt++;
+                continue;
+            }
+            if (response.status === 401) {
+                let details = '';
                 try {
-                    const errorData = JSON.parse(text);
-                    details = errorData.details || errorData.error || text;
+                    const text = await response.text();
+                    try {
+                        const errorData = JSON.parse(text);
+                        details = errorData.details || errorData.error || text;
+                    }
+                    catch (e) {
+                        details = text;
+                    }
                 }
                 catch (e) {
-                    details = text;
+                    details = 'Unknown error reading body';
                 }
+                throw new Error(`Authentication failed: ${details}. Please login again.`);
             }
-            catch (e) {
-                details = 'Unknown error reading body';
+            if (response.status === 402) {
+                throw new Error('Insufficient credits. Please visit minovativemind.dev to purchase more credits.');
             }
-            throw new Error(`Authentication failed: ${details}. Please login again.`);
-        }
-        if (response.status === 402) {
-            throw new Error('Insufficient credits. Please visit minovativemind.dev to purchase more credits.');
-        }
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(`Proxy error ${response.status}: ${errorData.error || response.statusText}`);
-        }
-        if (!response.body) {
-            throw new Error('No response body received from proxy');
-        }
-        // Node 18+ fetch body is a ReadableStream which is async iterable but type might mismatch.
-        // Let's read chunks manually
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        let functionCall = null;
-        const functionCalls = [];
-        let thought = '';
-        let parts = undefined;
-        let usageMetadata = undefined;
-        let groundingMetadata = undefined;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (!line.startsWith('data: '))
-                        continue;
-                    const dataStr = line.slice(6);
-                    try {
-                        const data = JSON.parse(dataStr);
-                        if (data.type === 'functionCall' && data.functionCall) {
-                            functionCall = data.functionCall;
-                            functionCalls.push(data.functionCall);
-                        }
-                        else if (data.type === 'thought' && data.thought) {
-                            thought += data.thought;
-                            if (streamCallbacks?.onChunk)
-                                streamCallbacks.onChunk(data.thought);
-                        }
-                        else if (data.type === 'chunk' && data.text) {
-                            thought += data.text;
-                            if (streamCallbacks?.onChunk)
-                                streamCallbacks.onChunk(data.text);
-                        }
-                        else if (data.type === 'parts' && data.parts) {
-                            parts = data.parts;
-                        }
-                        else if (data.type === 'done') {
-                            if (data.usage) {
-                                usageMetadata = data.usage;
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(`Proxy error ${response.status}: ${errorData.error || response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('No response body received from proxy');
+            }
+            // Node 18+ fetch body is a ReadableStream which is async iterable but type might mismatch.
+            // Let's read chunks manually
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let functionCall = null;
+            const functionCalls = [];
+            let thought = '';
+            let parts = undefined;
+            let usageMetadata = undefined;
+            let groundingMetadata = undefined;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const dataStr = line.slice(6);
+                        try {
+                            const data = JSON.parse(dataStr);
+                            if (data.type === 'functionCall' && data.functionCall) {
+                                functionCall = data.functionCall;
+                                functionCalls.push(data.functionCall);
+                            }
+                            else if (data.type === 'thought' && data.thought) {
+                                thought += data.thought;
+                                if (streamCallbacks?.onChunk)
+                                    streamCallbacks.onChunk(data.thought);
+                            }
+                            else if (data.type === 'chunk' && data.text) {
+                                thought += data.text;
+                                if (streamCallbacks?.onChunk)
+                                    streamCallbacks.onChunk(data.text);
                             }
-                            if (data.groundingMetadata) {
-                                groundingMetadata = data.groundingMetadata;
+                            else if (data.type === 'parts' && data.parts) {
+                                parts = data.parts;
+                            }
+                            else if (data.type === 'done') {
+                                if (data.usage) {
+                                    usageMetadata = data.usage;
+                                    globalSessionAccumulatedUsage.promptTokens += data.usage.promptTokens || 0;
+                                    globalSessionAccumulatedUsage.candidatesTokens += data.usage.candidatesTokens || 0;
+                                    globalSessionAccumulatedUsage.cachedTokens += data.usage.cachedTokens || 0;
+                                    globalSessionAccumulatedUsage.creditsUsed += data.usage.creditsUsed || 0;
+                                    globalSessionAccumulatedUsage.totalTokenCount +=
+                                        (data.usage.promptTokens || 0) + (data.usage.cachedTokens || 0) + (data.usage.candidatesTokens || 0);
+                                    if (data.usage.remainingBalance !== undefined) {
+                                        globalSessionAccumulatedUsage.remainingBalance = data.usage.remainingBalance;
+                                    }
+                                }
+                                if (data.groundingMetadata) {
+                                    groundingMetadata = data.groundingMetadata;
+                                }
+                            }
+                            else if (data.type === 'error') {
+                                throw new Error(`Proxy generation error: ${data.message}`);
                             }
                         }
-                        else if (data.type === 'error') {
-                            throw new Error(`Proxy generation error: ${data.message}`);
+                        catch (parseError) {
+                            if (parseError.message && parseError.message.startsWith('Proxy generation error:')) {
+                                throw parseError;
+                            }
+                            debugLog(`Failed to parse SSE data: ${dataStr} - Error: ${parseError.message || parseError}`);
                         }
                     }
-                    catch (parseError) {
-                        if (parseError.message && parseError.message.startsWith('Proxy generation error:')) {
-                            throw parseError;
-                        }
-                        debugLog(`Failed to parse SSE data: ${dataStr} - Error: ${parseError.message || parseError}`);
+                }
+            }
+            catch (streamError) {
+                if (streamError.message?.includes('429') ||
+                    streamError.message?.includes('503') ||
+                    streamError.message?.includes('RESOURCE_EXHAUSTED') ||
+                    streamError.message?.includes('Too Many Requests')) {
+                    if (attempt < MAX_RETRIES) {
+                        const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
+                        const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                        console.warn(`Rate limit or service unavailable hit during stream. Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
+                        await delay(delayTime, abortSignal);
+                        attempt++;
+                        continue retryLoop;
                     }
                 }
+                throw streamError;
             }
+            finally {
+                reader.releaseLock();
+            }
+            return {
+                functionCall,
+                functionCalls,
+                thought: thought.trim(),
+                parts,
+                usageMetadata,
+                groundingMetadata,
+            };
         }
-        finally {
-            reader.releaseLock();
-        }
-        return {
-            functionCall,
-            functionCalls,
-            thought: thought.trim(),
-            parts,
-            usageMetadata,
-            groundingMetadata,
-        };
     }
 }

package/dist/utils/analysisRunner.js

@@ -70,8 +70,8 @@ function truncateOutput(text, max) {
  * @returns Captured stdout, stderr, and exit code.
  */
 export async function runEphemeralScript(workspaceRoot, language, code, options) {
-    const timeoutMs = options?.timeoutMs ?? 10_000;
-    const maxOutputChars = options?.maxOutputChars ?? 30_000;
+    const timeoutMs = options?.timeoutMs ?? 60_000;
+    const maxOutputChars = options?.maxOutputChars ?? 100_000;
     const ext = LANGUAGE_EXTENSIONS[language.toLowerCase()];
     if (!ext) {
         return {

package/dist/utils/config.d.ts

@@ -14,9 +14,9 @@ export declare const GITHUB_CLIENT_ID = "Ov23linFYFfjO3JILG7r";
  * Supported Gemini AI models.
  */
 export declare const GEMINI_MODELS: {
-    readonly PRO_3_1: "gemini-3.1-pro-preview";
-    readonly FLASH_3_5: "gemini-3.5-flash";
-    readonly FLASH_LITE_3_1: "gemini-3.1-flash-lite";
+    readonly PRO: "gemini-3.1-pro-preview";
+    readonly FLASH: "gemini-3.6-flash";
+    readonly FLASH_LITE: "gemini-3.5-flash-lite";
     readonly AUTO: "auto";
 };
 /** Default Gemini model for the coding agent. */

package/dist/utils/config.js

@@ -14,9 +14,9 @@ export const GITHUB_CLIENT_ID = 'Ov23linFYFfjO3JILG7r';
  * Supported Gemini AI models.
  */
 export const GEMINI_MODELS = {
-    PRO_3_1: 'gemini-3.1-pro-preview',
-    FLASH_3_5: 'gemini-3.5-flash',
-    FLASH_LITE_3_1: 'gemini-3.1-flash-lite',
+    PRO: 'gemini-3.1-pro-preview',
+    FLASH: 'gemini-3.6-flash',
+    FLASH_LITE: 'gemini-3.5-flash-lite',
     AUTO: 'auto',
 };
 /** Default Gemini model for the coding agent. */

package/dist/utils/credentialStore.d.ts

@@ -0,0 +1,30 @@
+/** Legacy plaintext file path (for migration). */
+export declare const LEGACY_CONFIG_FILE: string;
+export interface StoredCredentials {
+    idToken?: string;
+    refreshToken?: string;
+    idTokenExpiry?: number;
+}
+/**
+ * Persists authentication credentials to the most secure available store.
+ *
+ * Strategy (tried in order):
+ * 1. macOS Keychain (`security` CLI)
+ * 2. Linux libsecret (`secret-tool` CLI)
+ * 3. Windows DPAPI (PowerShell)
+ * 4. AES-256-GCM encrypted file with 0600 permissions
+ */
+export declare function saveCredentials(data: StoredCredentials): Promise<void>;
+/**
+ * Loads authentication credentials from the secure store.
+ * Returns an empty object if no credentials are found.
+ *
+ * On first run after upgrade, silently migrates any legacy plaintext
+ * `~/.minovative-mind-cli.json` into the secure store and deletes the old file.
+ */
+export declare function loadCredentials(): Promise<StoredCredentials>;
+/**
+ * Removes all stored credentials from the secure store.
+ * Also cleans up any legacy plaintext file if it still exists.
+ */
+export declare function clearCredentials(): Promise<void>;