snow-ai 0.2.23 → 0.2.25

package/dist/utils/resourceMonitor.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Resource Monitor - Track memory usage and potential leaks
+ */
+interface ResourceStats {
+    timestamp: number;
+    memoryUsage: NodeJS.MemoryUsage;
+    activeEncoders: number;
+    activeMCPConnections: number;
+}
+declare class ResourceMonitor {
+    private stats;
+    private readonly maxStatsHistory;
+    private activeEncoders;
+    private activeMCPConnections;
+    private monitoringInterval;
+    /**
+     * Start monitoring resources
+     */
+    startMonitoring(intervalMs?: number): void;
+    /**
+     * Stop monitoring resources
+     */
+    stopMonitoring(): void;
+    /**
+     * Collect current resource stats
+     */
+    private collectStats;
+    /**
+     * Track encoder creation
+     */
+    trackEncoderCreated(): void;
+    /**
+     * Track encoder freed
+     */
+    trackEncoderFreed(): void;
+    /**
+     * Track MCP connection opened
+     */
+    trackMCPConnectionOpened(serviceName: string): void;
+    /**
+     * Track MCP connection closed
+     */
+    trackMCPConnectionClosed(serviceName: string): void;
+    /**
+     * Get current stats
+     */
+    getCurrentStats(): ResourceStats | null;
+    /**
+     * Get stats history
+     */
+    getStatsHistory(): ResourceStats[];
+    /**
+     * Check if there are potential memory leaks
+     */
+    checkForLeaks(): {
+        hasLeak: boolean;
+        reasons: string[];
+    };
+    /**
+     * Force garbage collection if available
+     */
+    forceGC(): void;
+}
+export declare const resourceMonitor: ResourceMonitor;
+export {};

package/dist/utils/resourceMonitor.js

@@ -0,0 +1,175 @@
+/**
+ * Resource Monitor - Track memory usage and potential leaks
+ */
+import { logger } from './logger.js';
+class ResourceMonitor {
+    constructor() {
+        Object.defineProperty(this, "stats", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "maxStatsHistory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 100
+        });
+        Object.defineProperty(this, "activeEncoders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "activeMCPConnections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "monitoringInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * Start monitoring resources
+     */
+    startMonitoring(intervalMs = 30000) {
+        if (this.monitoringInterval) {
+            return; // Already monitoring
+        }
+        this.monitoringInterval = setInterval(() => {
+            this.collectStats();
+        }, intervalMs);
+        logger.info('Resource monitoring started');
+    }
+    /**
+     * Stop monitoring resources
+     */
+    stopMonitoring() {
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+            this.monitoringInterval = null;
+            logger.info('Resource monitoring stopped');
+        }
+    }
+    /**
+     * Collect current resource stats
+     */
+    collectStats() {
+        const stats = {
+            timestamp: Date.now(),
+            memoryUsage: process.memoryUsage(),
+            activeEncoders: this.activeEncoders,
+            activeMCPConnections: this.activeMCPConnections,
+        };
+        this.stats.push(stats);
+        // Keep only recent history
+        if (this.stats.length > this.maxStatsHistory) {
+            this.stats.shift();
+        }
+        // Log warning if memory usage is high
+        const heapUsedMB = stats.memoryUsage.heapUsed / 1024 / 1024;
+        if (heapUsedMB > 500) {
+            logger.warn(`High memory usage detected: ${heapUsedMB.toFixed(2)} MB heap used`);
+        }
+        // Log debug info periodically (every 5 minutes)
+        if (this.stats.length % 10 === 0) {
+            logger.info(`Resource stats: Heap ${heapUsedMB.toFixed(2)} MB, Encoders: ${this.activeEncoders}, MCP: ${this.activeMCPConnections}`);
+        }
+    }
+    /**
+     * Track encoder creation
+     */
+    trackEncoderCreated() {
+        this.activeEncoders++;
+        logger.info(`Encoder created (total: ${this.activeEncoders})`);
+    }
+    /**
+     * Track encoder freed
+     */
+    trackEncoderFreed() {
+        this.activeEncoders--;
+        if (this.activeEncoders < 0) {
+            logger.warn('Encoder count went negative - possible double-free');
+            this.activeEncoders = 0;
+        }
+        logger.info(`Encoder freed (remaining: ${this.activeEncoders})`);
+    }
+    /**
+     * Track MCP connection opened
+     */
+    trackMCPConnectionOpened(serviceName) {
+        this.activeMCPConnections++;
+        logger.info(`MCP connection opened: ${serviceName} (total: ${this.activeMCPConnections})`);
+    }
+    /**
+     * Track MCP connection closed
+     */
+    trackMCPConnectionClosed(serviceName) {
+        this.activeMCPConnections--;
+        if (this.activeMCPConnections < 0) {
+            logger.warn('MCP connection count went negative - possible double-close');
+            this.activeMCPConnections = 0;
+        }
+        logger.info(`MCP connection closed: ${serviceName} (remaining: ${this.activeMCPConnections})`);
+    }
+    /**
+     * Get current stats
+     */
+    getCurrentStats() {
+        return this.stats.length > 0 ? this.stats[this.stats.length - 1] : null;
+    }
+    /**
+     * Get stats history
+     */
+    getStatsHistory() {
+        return [...this.stats];
+    }
+    /**
+     * Check if there are potential memory leaks
+     */
+    checkForLeaks() {
+        const reasons = [];
+        // Check encoder leak
+        if (this.activeEncoders > 3) {
+            reasons.push(`High encoder count: ${this.activeEncoders} (expected <= 3)`);
+        }
+        // Check MCP connection leak
+        if (this.activeMCPConnections > 5) {
+            reasons.push(`High MCP connection count: ${this.activeMCPConnections} (expected <= 5)`);
+        }
+        // Check memory growth
+        if (this.stats.length >= 10) {
+            const recent = this.stats.slice(-10);
+            const first = recent[0];
+            const last = recent[recent.length - 1];
+            const growthMB = (last.memoryUsage.heapUsed - first.memoryUsage.heapUsed) / 1024 / 1024;
+            if (growthMB > 100) {
+                reasons.push(`Memory grew by ${growthMB.toFixed(2)} MB in last 10 samples`);
+            }
+        }
+        return {
+            hasLeak: reasons.length > 0,
+            reasons,
+        };
+    }
+    /**
+     * Force garbage collection if available
+     */
+    forceGC() {
+        if (global.gc) {
+            logger.info('Forcing garbage collection');
+            global.gc();
+        }
+        else {
+            logger.warn('GC not available - run with --expose-gc flag for manual GC');
+        }
+    }
+}
+// Singleton instance
+export const resourceMonitor = new ResourceMonitor();

package/dist/utils/retryUtils.js

@@ -64,6 +64,12 @@ function isRetriableError(error) {
         errorMessage.includes('unavailable')) {
         return true;
     }
+    // Connection terminated by server
+    if (errorMessage.includes('terminated') ||
+        errorMessage.includes('connection reset') ||
+        errorMessage.includes('socket hang up')) {
+        return true;
+    }
     return false;
 }
 /**

package/dist/utils/sessionManager.d.ts

@@ -34,6 +34,7 @@ declare class SessionManager {
     setCurrentSession(session: Session): void;
     clearCurrentSession(): void;
     deleteSession(sessionId: string): Promise<boolean>;
+    truncateMessages(messageCount: number): Promise<void>;
 }
 export declare const sessionManager: SessionManager;
 export {};

package/dist/utils/sessionManager.js

@@ -168,5 +168,15 @@ class SessionManager {
             return false;
         }
     }
+    async truncateMessages(messageCount) {
+        if (!this.currentSession) {
+            return;
+        }
+        // Truncate messages array to specified count
+        this.currentSession.messages = this.currentSession.messages.slice(0, messageCount);
+        this.currentSession.messageCount = this.currentSession.messages.length;
+        this.currentSession.updatedAt = Date.now();
+        await this.saveSession(this.currentSession);
+    }
 }
 export const sessionManager = new SessionManager();

package/dist/utils/textBuffer.js

@@ -8,10 +8,15 @@ function sanitizeInput(str) {
         .replace(/\r\n/g, '\n') // Normalize line endings
         .replace(/\r/g, '\n') // Convert remaining \r to \n
         .replace(/\t/g, '  ') // Convert tabs to spaces
-        // Remove focus events - only the complete escape sequences
-        // ESC[I and ESC[O are focus events, don't confuse with user input like "[I"
+        // Remove focus events - complete escape sequences and standalone patterns
+        // ESC[I and ESC[O are focus events from terminal focus in/out
         .replace(/\x1b\[I/g, '')
         .replace(/\x1b\[O/g, '')
+        // Also remove standalone [I and [O if they appear at word boundaries
+        // This catches cases where escape sequences arrive fragmented
+        // But we preserve legitimate text like "FOO[I]BAR" or "[Inside]"
+        .replace(/(?:^|\s)\[I(?:\s|$)/g, ' ')
+        .replace(/(?:^|\s)\[O(?:\s|$)/g, ' ')
         // Remove control characters except newlines
         .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
 }

package/dist/utils/toolExecutor.d.ts

@@ -14,8 +14,8 @@ export interface ToolResult {
 /**
  * Execute a single tool call and return the result
  */
-export declare function executeToolCall(toolCall: ToolCall): Promise<ToolResult>;
+export declare function executeToolCall(toolCall: ToolCall, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void): Promise<ToolResult>;
 /**
  * Execute multiple tool calls in parallel
  */
-export declare function executeToolCalls(toolCalls: ToolCall[]): Promise<ToolResult[]>;
+export declare function executeToolCalls(toolCalls: ToolCall[], abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void): Promise<ToolResult[]>;

package/dist/utils/toolExecutor.js

@@ -2,10 +2,10 @@ import { executeMCPTool } from './mcpToolsManager.js';
 /**
  * Execute a single tool call and return the result
  */
-export async function executeToolCall(toolCall) {
+export async function executeToolCall(toolCall, abortSignal, onTokenUpdate) {
     try {
         const args = JSON.parse(toolCall.function.arguments);
-        const result = await executeMCPTool(toolCall.function.name, args);
+        const result = await executeMCPTool(toolCall.function.name, args, abortSignal, onTokenUpdate);
         return {
             tool_call_id: toolCall.id,
             role: 'tool',
@@ -23,6 +23,6 @@ export async function executeToolCall(toolCall) {
 /**
  * Execute multiple tool calls in parallel
  */
-export async function executeToolCalls(toolCalls) {
-    return Promise.all(toolCalls.map(tc => executeToolCall(tc)));
+export async function executeToolCalls(toolCalls, abortSignal, onTokenUpdate) {
+    return Promise.all(toolCalls.map(tc => executeToolCall(tc, abortSignal, onTokenUpdate)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.23",
+	"version": "0.2.25",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -47,6 +47,7 @@
 		"cli-highlight": "^2.1.11",
 		"diff": "^8.0.2",
 		"figlet": "^1.8.2",
+		"https-proxy-agent": "^7.0.6",
 		"ink": "^5.2.1",
 		"ink-gradient": "^3.0.0",
 		"ink-markdown": "^1.0.4",
@@ -54,8 +55,10 @@
 		"ink-spinner": "^5.0.0",
 		"ink-text-input": "^6.0.0",
 		"ink-tree-select": "^2.3.1",
+		"jsdom": "^27.0.0",
 		"meow": "^11.0.0",
 		"openai": "^6.1.0",
+		"puppeteer-core": "^24.25.0",
 		"react": "^18.2.0",
 		"string-width": "^7.2.0",
 		"tiktoken": "^1.0.22",
@@ -66,6 +69,7 @@
 		"@types/diff": "^7.0.2",
 		"@types/figlet": "^1.7.0",
 		"@types/glob": "^8.1.0",
+		"@types/jsdom": "^27.0.0",
 		"@types/react": "^18.0.32",
 		"@types/ws": "^8.5.8",
 		"@vdemedes/prettier-config": "^2.0.1",

package/dist/ui/pages/ApiConfigScreen.js

@@ -1,161 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
-import Gradient from 'ink-gradient';
-import { Select, Alert } from '@inkjs/ui';
-import TextInput from 'ink-text-input';
-import { getOpenAiConfig, updateOpenAiConfig, validateApiConfig, } from '../../utils/apiConfig.js';
-export default function ApiConfigScreen({ onBack, onSave, inlineMode = false }) {
-    const [baseUrl, setBaseUrl] = useState('');
-    const [apiKey, setApiKey] = useState('');
-    const [requestMethod, setRequestMethod] = useState('chat');
-    const [anthropicBeta, setAnthropicBeta] = useState(false);
-    const [currentField, setCurrentField] = useState('baseUrl');
-    const [errors, setErrors] = useState([]);
-    const [isEditing, setIsEditing] = useState(false);
-    const requestMethodOptions = [
-        {
-            label: 'Chat Completions - Modern chat API (GPT-4, GPT-3.5-turbo)',
-            value: 'chat',
-        },
-        {
-            label: 'Responses - New responses API (2025, with built-in tools)',
-            value: 'responses',
-        },
-        {
-            label: 'Gemini - Google Gemini API',
-            value: 'gemini',
-        },
-        {
-            label: 'Anthropic - Claude API',
-            value: 'anthropic',
-        },
-    ];
-    useEffect(() => {
-        const config = getOpenAiConfig();
-        setBaseUrl(config.baseUrl);
-        setApiKey(config.apiKey);
-        setRequestMethod(config.requestMethod || 'chat');
-        setAnthropicBeta(config.anthropicBeta || false);
-    }, []);
-    useInput((input, key) => {
-        // Allow Escape key to exit Select component without changes
-        if (isEditing && currentField === 'requestMethod' && key.escape) {
-            setIsEditing(false);
-            return;
-        }
-        // Don't handle other input when Select component is active
-        if (isEditing && currentField === 'requestMethod') {
-            return;
-        }
-        // Handle save/exit globally
-        if (input === 's' && (key.ctrl || key.meta)) {
-            const validationErrors = validateApiConfig({ baseUrl, apiKey, requestMethod });
-            if (validationErrors.length === 0) {
-                updateOpenAiConfig({ baseUrl, apiKey, requestMethod, anthropicBeta });
-                setErrors([]);
-                onSave();
-            }
-            else {
-                setErrors(validationErrors);
-            }
-        }
-        else if (key.escape) {
-            const validationErrors = validateApiConfig({ baseUrl, apiKey, requestMethod });
-            if (validationErrors.length === 0) {
-                updateOpenAiConfig({ baseUrl, apiKey, requestMethod, anthropicBeta });
-                setErrors([]);
-            }
-            onBack();
-        }
-        else if (key.return) {
-            if (isEditing) {
-                // Exit edit mode, return to navigation
-                setIsEditing(false);
-            }
-            else {
-                // Enter edit mode for current field (toggle for checkbox)
-                if (currentField === 'anthropicBeta') {
-                    setAnthropicBeta(!anthropicBeta);
-                }
-                else {
-                    setIsEditing(true);
-                }
-            }
-        }
-        else if (!isEditing && key.upArrow) {
-            if (currentField === 'apiKey') {
-                setCurrentField('baseUrl');
-            }
-            else if (currentField === 'requestMethod') {
-                setCurrentField('apiKey');
-            }
-            else if (currentField === 'anthropicBeta') {
-                setCurrentField('requestMethod');
-            }
-        }
-        else if (!isEditing && key.downArrow) {
-            if (currentField === 'baseUrl') {
-                setCurrentField('apiKey');
-            }
-            else if (currentField === 'apiKey') {
-                setCurrentField('requestMethod');
-            }
-            else if (currentField === 'requestMethod') {
-                setCurrentField('anthropicBeta');
-            }
-        }
-    });
-    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-        !inlineMode && (React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Gradient, { name: "rainbow" }, "OpenAI API Configuration"),
-                React.createElement(Text, { color: "gray", dimColor: true }, "Configure your OpenAI API settings")))),
-        React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'baseUrl' ? 'green' : 'white' },
-                        currentField === 'baseUrl' ? '❯ ' : '  ',
-                        "Base URL:"),
-                    currentField === 'baseUrl' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(TextInput, { value: baseUrl, onChange: setBaseUrl, placeholder: "https://api.openai.com/v1" }))),
-                    (!isEditing || currentField !== 'baseUrl') && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" }, baseUrl || 'Not set'))))),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'apiKey' ? 'green' : 'white' },
-                        currentField === 'apiKey' ? '❯ ' : '  ',
-                        "API Key:"),
-                    currentField === 'apiKey' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(TextInput, { value: apiKey, onChange: setApiKey, placeholder: "sk-...", mask: "*" }))),
-                    (!isEditing || currentField !== 'apiKey') && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" }, apiKey ? '*'.repeat(Math.min(apiKey.length, 20)) : 'Not set'))))),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'requestMethod' ? 'green' : 'white' },
-                        currentField === 'requestMethod' ? '❯ ' : '  ',
-                        "Request Method:"),
-                    currentField === 'requestMethod' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Select, { options: requestMethodOptions, defaultValue: requestMethod, onChange: (value) => {
-                                setRequestMethod(value);
-                                setIsEditing(false); // Auto exit edit mode after selection
-                            } }))),
-                    (!isEditing || currentField !== 'requestMethod') && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" }, requestMethodOptions.find(opt => opt.value === requestMethod)?.label || 'Not set'))))),
-            React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Text, { color: currentField === 'anthropicBeta' ? 'green' : 'white' },
-                        currentField === 'anthropicBeta' ? '❯ ' : '  ',
-                        "Anthropic Beta (for Claude API):"),
-                    React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" },
-                            anthropicBeta ? '☑ Enabled' : '☐ Disabled',
-                            " (Press Enter to toggle)"))))),
-        errors.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
-            React.createElement(Text, { color: "red", bold: true }, "Errors:"),
-            errors.map((error, index) => (React.createElement(Text, { key: index, color: "red" },
-                "\u2022 ",
-                error))))),
-        React.createElement(Box, { flexDirection: "column" }, isEditing ? (React.createElement(React.Fragment, null,
-            React.createElement(Alert, { variant: "info" }, "Editing mode: Press Enter to save and exit editing (Make your changes and press Enter when done)"))) : (React.createElement(React.Fragment, null,
-            React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate between fields, press Enter to edit, and press Ctrl+S or Esc to save and return"))))));
-}