snow-ai 0.4.16 → 0.4.17

package/dist/utils/resourceMonitor.js

@@ -1,175 +0,0 @@
-/**
- * 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.d.ts

@@ -1,49 +0,0 @@
-/**
- * 重试工具函数
- * 提供统一的重试机制用于所有 AI 请求
- * - 支持5次重试
- * - 延时递增策略 (1s, 2s, 4s, 8s, 16s)
- * - 支持 AbortSignal 中断
- */
-export interface RetryOptions {
-    maxRetries?: number;
-    baseDelay?: number;
-    onRetry?: (error: Error, attempt: number, nextDelay: number) => void;
-    abortSignal?: AbortSignal;
-}
-/**
- * 包装异步函数，提供重试机制
- */
-export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-/**
- * 包装异步生成器函数，提供重试机制
- * 注意：如果生成器已经开始产生数据，则不会重试
- */
-export declare function withRetryGenerator<T>(fn: () => AsyncGenerator<T, void, unknown>, options?: RetryOptions): AsyncGenerator<T, void, unknown>;
-/**
- * JSON 解析结果
- */
-export interface JsonParseResult<T = any> {
-    success: boolean;
-    data?: T;
-    error?: Error;
-    wasFixed?: boolean;
-    originalJson?: string;
-    fixedJson?: string;
-}
-/**
- * 尝试解析 JSON，如果失败则尝试修复常见的 JSON 错误
- * @param jsonString - 要解析的 JSON 字符串
- * @param options - 配置选项
- * @returns 解析结果
- */
-export declare function parseJsonWithFix<T = any>(jsonString: string, options?: {
-    /** 是否在修复成功时记录警告 */
-    logWarning?: boolean;
-    /** 是否在修复失败时记录错误 */
-    logError?: boolean;
-    /** 工具名称（用于日志） */
-    toolName?: string;
-    /** 失败时的回退值 */
-    fallbackValue?: T;
-}): JsonParseResult<T>;

package/dist/utils/retryUtils.js

@@ -1,303 +0,0 @@
-/**
- * 重试工具函数
- * 提供统一的重试机制用于所有 AI 请求
- * - 支持5次重试
- * - 延时递增策略 (1s, 2s, 4s, 8s, 16s)
- * - 支持 AbortSignal 中断
- */
-import { logger } from './logger.js';
-/**
- * 延时函数，支持 AbortSignal 中断
- */
-async function delay(ms, abortSignal) {
-    return new Promise((resolve, reject) => {
-        if (abortSignal?.aborted) {
-            reject(new Error('Aborted'));
-            return;
-        }
-        const timer = setTimeout(() => {
-            cleanup();
-            resolve();
-        }, ms);
-        const abortHandler = () => {
-            cleanup();
-            reject(new Error('Aborted'));
-        };
-        const cleanup = () => {
-            clearTimeout(timer);
-            abortSignal?.removeEventListener('abort', abortHandler);
-        };
-        abortSignal?.addEventListener('abort', abortHandler);
-    });
-}
-/**
- * 判断错误是否可重试
- */
-function isRetriableError(error) {
-    const errorMessage = error.message.toLowerCase();
-    // 网络错误
-    if (errorMessage.includes('network') ||
-        errorMessage.includes('econnrefused') ||
-        errorMessage.includes('econnreset') ||
-        errorMessage.includes('etimedout') ||
-        errorMessage.includes('timeout')) {
-        return true;
-    }
-    // Rate limit errors
-    if (errorMessage.includes('rate limit') ||
-        errorMessage.includes('too many requests') ||
-        errorMessage.includes('429')) {
-        return true;
-    }
-    // Server errors
-    if (errorMessage.includes('400') ||
-        errorMessage.includes('403') ||
-        errorMessage.includes('405') ||
-        errorMessage.includes('500') ||
-        errorMessage.includes('502') ||
-        errorMessage.includes('503') ||
-        errorMessage.includes('504') ||
-        errorMessage.includes('internal server error') ||
-        errorMessage.includes('bad gateway') ||
-        errorMessage.includes('service unavailable') ||
-        errorMessage.includes('gateway timeout')) {
-        return true;
-    }
-    // Temporary service unavailable
-    if (errorMessage.includes('overloaded') ||
-        errorMessage.includes('unavailable')) {
-        return true;
-    }
-    // Connection terminated by server
-    if (errorMessage.includes('terminated') ||
-        errorMessage.includes('connection reset') ||
-        errorMessage.includes('socket hang up')) {
-        return true;
-    }
-    // JSON parsing errors from streaming (incomplete or malformed tool calls)
-    if (errorMessage.includes('invalid tool call json') ||
-        errorMessage.includes('incomplete tool call json')) {
-        return true;
-    }
-    return false;
-}
-/**
- * 包装异步函数，提供重试机制
- */
-export async function withRetry(fn, options = {}) {
-    const { maxRetries = 5, baseDelay = 1000, onRetry, abortSignal } = options;
-    let lastError = null;
-    let attempt = 0;
-    while (attempt <= maxRetries) {
-        // 检查是否已中断
-        if (abortSignal?.aborted) {
-            throw new Error('Request aborted');
-        }
-        try {
-            // 尝试执行函数
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            // 如果是 AbortError，立即退出
-            if (lastError.name === 'AbortError' || lastError.message === 'Aborted') {
-                throw lastError;
-            }
-            // 如果已达到最大重试次数，抛出错误
-            if (attempt >= maxRetries) {
-                throw lastError;
-            }
-            // 检查错误是否可重试
-            if (!isRetriableError(lastError)) {
-                throw lastError;
-            }
-            // 计算下次重试的延时（指数退避：1s, 2s, 4s, 8s, 16s）
-            const nextDelay = baseDelay * Math.pow(2, attempt);
-            // 调用重试回调
-            if (onRetry) {
-                onRetry(lastError, attempt + 1, nextDelay);
-            }
-            // 等待后重试
-            try {
-                await delay(nextDelay, abortSignal);
-            }
-            catch (delayError) {
-                // 延时过程中被中断
-                throw new Error('Request aborted');
-            }
-            attempt++;
-        }
-    }
-    // 不应该到达这里
-    throw lastError || new Error('Retry failed');
-}
-/**
- * 包装异步生成器函数，提供重试机制
- * 注意：如果生成器已经开始产生数据，则不会重试
- */
-export async function* withRetryGenerator(fn, options = {}) {
-    const { maxRetries = 5, baseDelay = 1000, onRetry, abortSignal } = options;
-    let lastError = null;
-    let attempt = 0;
-    let hasYielded = false; // 标记是否已经产生过数据
-    while (attempt <= maxRetries) {
-        // 检查是否已中断
-        if (abortSignal?.aborted) {
-            throw new Error('Request aborted');
-        }
-        try {
-            // 尝试执行生成器
-            const generator = fn();
-            for await (const chunk of generator) {
-                hasYielded = true; // 标记已产生数据
-                yield chunk;
-            }
-            // 成功完成
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            // 如果是 AbortError，立即退出
-            if (lastError.name === 'AbortError' || lastError.message === 'Aborted') {
-                throw lastError;
-            }
-            // 如果已经产生过数据，不再重试（避免重复数据）
-            if (hasYielded) {
-                throw lastError;
-            }
-            // 如果已达到最大重试次数，抛出错误
-            if (attempt >= maxRetries) {
-                throw lastError;
-            }
-            // 检查错误是否可重试
-            if (!isRetriableError(lastError)) {
-                throw lastError;
-            }
-            // 计算下次重试的延时（指数退避：1s, 2s, 4s, 8s, 16s）
-            const nextDelay = baseDelay * Math.pow(2, attempt);
-            // 调用重试回调
-            if (onRetry) {
-                onRetry(lastError, attempt + 1, nextDelay);
-            }
-            // 等待后重试
-            try {
-                await delay(nextDelay, abortSignal);
-            }
-            catch (delayError) {
-                // 延时过程中被中断
-                throw new Error('Request aborted');
-            }
-            attempt++;
-        }
-    }
-    // 不应该到达这里
-    throw lastError || new Error('Retry failed');
-}
-/**
- * 尝试解析 JSON，如果失败则尝试修复常见的 JSON 错误
- * @param jsonString - 要解析的 JSON 字符串
- * @param options - 配置选项
- * @returns 解析结果
- */
-export function parseJsonWithFix(jsonString, options = {}) {
-    const { logWarning = true, logError = true, toolName = 'unknown', fallbackValue, } = options;
-    // 首先尝试直接解析
-    try {
-        const data = JSON.parse(jsonString);
-        return { success: true, data };
-    }
-    catch (originalError) {
-        // 解析失败，尝试修复
-        let fixedJson = jsonString;
-        let wasFixed = false;
-        // Fix 1: 移除格式错误的模式，如 "endLine":685 ": ""
-        // 处理值后面有额外冒号和引号的情况
-        const malformedPattern = /(\"[\w]+\"\s*:\s*[^,}\]]+)\s*\":\s*\"[^\"]*\"/g;
-        if (malformedPattern.test(fixedJson)) {
-            fixedJson = fixedJson.replace(malformedPattern, '$1');
-            wasFixed = true;
-        }
-        // Fix 2: 移除闭合括号前的尾随逗号
-        if (/,(\s*[}\]])/.test(fixedJson)) {
-            fixedJson = fixedJson.replace(/,(\s*[}\]])/g, '$1');
-            wasFixed = true;
-        }
-        // Fix 3: 修复属性名缺少引号的问题
-        if (/{\s*\w+\s*:/.test(fixedJson)) {
-            fixedJson = fixedJson.replace(/{\s*(\w+)\s*:/g, '{"$1":');
-            fixedJson = fixedJson.replace(/,\s*(\w+)\s*:/g, ',"$1":');
-            wasFixed = true;
-        }
-        // Fix 4: 添加缺失的闭合括号
-        const openBraces = (fixedJson.match(/{/g) || []).length;
-        const closeBraces = (fixedJson.match(/}/g) || []).length;
-        const openBrackets = (fixedJson.match(/\[/g) || []).length;
-        const closeBrackets = (fixedJson.match(/\]/g) || []).length;
-        if (openBraces > closeBraces) {
-            fixedJson += '}'.repeat(openBraces - closeBraces);
-            wasFixed = true;
-        }
-        if (openBrackets > closeBrackets) {
-            fixedJson += ']'.repeat(openBrackets - closeBrackets);
-            wasFixed = true;
-        }
-        // Fix 5: 移除多余的闭合括号
-        if (closeBraces > openBraces) {
-            const extraBraces = closeBraces - openBraces;
-            for (let i = 0; i < extraBraces; i++) {
-                fixedJson = fixedJson.replace(/}([^}]*)$/, '$1');
-            }
-            wasFixed = true;
-        }
-        if (closeBrackets > openBrackets) {
-            const extraBrackets = closeBrackets - openBrackets;
-            for (let i = 0; i < extraBrackets; i++) {
-                fixedJson = fixedJson.replace(/\]([^\]]*)$/, '$1');
-            }
-            wasFixed = true;
-        }
-        // 尝试解析修复后的 JSON
-        try {
-            const data = JSON.parse(fixedJson);
-            if (wasFixed && logWarning) {
-                logger.warn(`Warning: Fixed malformed JSON for ${toolName}`);
-            }
-            return {
-                success: true,
-                data,
-                wasFixed,
-                originalJson: jsonString,
-                fixedJson,
-            };
-        }
-        catch (fixError) {
-            // 修复失败
-            if (logError) {
-                logger.error(`Error: Failed to parse JSON for ${toolName}`);
-                logger.error(`Original: ${jsonString}`);
-                if (wasFixed) {
-                    logger.error(`After fixes: ${fixedJson}`);
-                }
-                logger.error(`Parse error: ${fixError instanceof Error ? fixError.message : 'Unknown'}`);
-            }
-            // 如果提供了回退值，使用回退值
-            if (fallbackValue !== undefined) {
-                return {
-                    success: false,
-                    data: fallbackValue,
-                    error: fixError instanceof Error ? fixError : new Error(String(fixError)),
-                    wasFixed,
-                    originalJson: jsonString,
-                    fixedJson: wasFixed ? fixedJson : undefined,
-                };
-            }
-            return {
-                success: false,
-                error: fixError instanceof Error ? fixError : new Error(String(fixError)),
-                wasFixed,
-                originalJson: jsonString,
-                fixedJson: wasFixed ? fixedJson : undefined,
-            };
-        }
-    }
-}

package/dist/utils/sensitiveCommandManager.d.ts

@@ -1,53 +0,0 @@
-export interface SensitiveCommand {
-    id: string;
-    pattern: string;
-    description: string;
-    enabled: boolean;
-    isPreset: boolean;
-}
-export interface SensitiveCommandsConfig {
-    commands: SensitiveCommand[];
-}
-/**
- * 预设的常见敏感指令
- */
-export declare const PRESET_SENSITIVE_COMMANDS: SensitiveCommand[];
-/**
- * Load sensitive commands configuration
- */
-export declare function loadSensitiveCommands(): SensitiveCommandsConfig;
-/**
- * Save sensitive commands configuration
- */
-export declare function saveSensitiveCommands(config: SensitiveCommandsConfig): void;
-/**
- * Add a custom sensitive command
- */
-export declare function addSensitiveCommand(pattern: string, description: string): void;
-/**
- * Remove a sensitive command
- */
-export declare function removeSensitiveCommand(id: string): void;
-/**
- * Update a sensitive command
- */
-export declare function updateSensitiveCommand(id: string, updates: Partial<Omit<SensitiveCommand, 'id' | 'isPreset'>>): void;
-/**
- * Toggle a sensitive command enabled state
- */
-export declare function toggleSensitiveCommand(id: string): void;
-/**
- * Check if a command matches any enabled sensitive pattern
- */
-export declare function isSensitiveCommand(command: string): {
-    isSensitive: boolean;
-    matchedCommand?: SensitiveCommand;
-};
-/**
- * Get all sensitive commands
- */
-export declare function getAllSensitiveCommands(): SensitiveCommand[];
-/**
- * Reset to default preset commands
- */
-export declare function resetToDefaults(): void;