snow-ai 0.4.15 → 0.4.17

package/dist/utils/sensitiveCommandManager.js

@@ -1,308 +0,0 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-const CONFIG_DIR = join(homedir(), '.snow');
-const SENSITIVE_COMMANDS_FILE = join(CONFIG_DIR, 'sensitive-commands.json');
-/**
- * 预设的常见敏感指令
- */
-export const PRESET_SENSITIVE_COMMANDS = [
-    {
-        id: 'rm',
-        pattern: 'rm*',
-        description: 'Delete files or directories (rm, rm -rf, etc.)',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'rmdir',
-        pattern: 'rmdir*',
-        description: 'Remove directories',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'mv-to-trash',
-        pattern: 'mv * /tmp*',
-        description: 'Move files to trash/tmp (potential data loss)',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'chmod',
-        pattern: 'chmod*',
-        description: 'Change file permissions',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'chown',
-        pattern: 'chown*',
-        description: 'Change file ownership',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'dd',
-        pattern: 'dd*',
-        description: 'Low-level data copy (disk operations)',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'mkfs',
-        pattern: 'mkfs*',
-        description: 'Format filesystem',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'fdisk',
-        pattern: 'fdisk*',
-        description: 'Disk partition manipulation',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'killall',
-        pattern: 'killall*',
-        description: 'Kill all processes by name',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'pkill',
-        pattern: 'pkill*',
-        description: 'Kill processes by pattern',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'reboot',
-        pattern: 'reboot*',
-        description: 'Reboot the system',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'shutdown',
-        pattern: 'shutdown*',
-        description: 'Shutdown the system',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'sudo',
-        pattern: 'sudo*',
-        description: 'Execute commands with superuser privileges',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'su',
-        pattern: 'su*',
-        description: 'Switch user',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'curl-post',
-        pattern: 'curl*-X POST*',
-        description: 'HTTP POST requests (potential data transmission)',
-        enabled: false,
-        isPreset: true,
-    },
-    {
-        id: 'wget',
-        pattern: 'wget*',
-        description: 'Download files from internet',
-        enabled: false,
-        isPreset: true,
-    },
-    {
-        id: 'git-push',
-        pattern: 'git push*',
-        description: 'Push code to remote repository',
-        enabled: false,
-        isPreset: true,
-    },
-    {
-        id: 'git-force-push',
-        pattern: 'git push*--force*',
-        description: 'Force push to remote repository (destructive)',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'npm-publish',
-        pattern: 'npm publish*',
-        description: 'Publish package to npm registry',
-        enabled: true,
-        isPreset: true,
-    },
-    {
-        id: 'docker-rm',
-        pattern: 'docker rm*',
-        description: 'Remove Docker containers',
-        enabled: false,
-        isPreset: true,
-    },
-    {
-        id: 'docker-rmi',
-        pattern: 'docker rmi*',
-        description: 'Remove Docker images',
-        enabled: false,
-        isPreset: true,
-    },
-];
-/**
- * Ensure config directory exists
- */
-function ensureConfigDirectory() {
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-}
-/**
- * Load sensitive commands configuration
- */
-export function loadSensitiveCommands() {
-    ensureConfigDirectory();
-    if (!existsSync(SENSITIVE_COMMANDS_FILE)) {
-        // 首次加载，使用预设配置
-        const defaultConfig = {
-            commands: [...PRESET_SENSITIVE_COMMANDS],
-        };
-        saveSensitiveCommands(defaultConfig);
-        return defaultConfig;
-    }
-    try {
-        const configData = readFileSync(SENSITIVE_COMMANDS_FILE, 'utf8');
-        const config = JSON.parse(configData);
-        // 合并预设命令（处理新增的预设命令）
-        const existingIds = new Set(config.commands.map(cmd => cmd.id));
-        const newPresets = PRESET_SENSITIVE_COMMANDS.filter(preset => !existingIds.has(preset.id));
-        if (newPresets.length > 0) {
-            config.commands = [...config.commands, ...newPresets];
-            saveSensitiveCommands(config);
-        }
-        return config;
-    }
-    catch (error) {
-        console.error('Failed to load sensitive commands config:', error);
-        return { commands: [...PRESET_SENSITIVE_COMMANDS] };
-    }
-}
-/**
- * Save sensitive commands configuration
- */
-export function saveSensitiveCommands(config) {
-    ensureConfigDirectory();
-    try {
-        const configData = JSON.stringify(config, null, 2);
-        writeFileSync(SENSITIVE_COMMANDS_FILE, configData, 'utf8');
-    }
-    catch (error) {
-        throw new Error(`Failed to save sensitive commands config: ${error}`);
-    }
-}
-/**
- * Add a custom sensitive command
- */
-export function addSensitiveCommand(pattern, description) {
-    const config = loadSensitiveCommands();
-    // 生成唯一ID
-    const id = `custom-${Date.now()}-${Math.random()
-        .toString(36)
-        .substring(2, 9)}`;
-    config.commands.push({
-        id,
-        pattern,
-        description,
-        enabled: true,
-        isPreset: false,
-    });
-    saveSensitiveCommands(config);
-}
-/**
- * Remove a sensitive command
- */
-export function removeSensitiveCommand(id) {
-    const config = loadSensitiveCommands();
-    config.commands = config.commands.filter(cmd => cmd.id !== id);
-    saveSensitiveCommands(config);
-}
-/**
- * Update a sensitive command
- */
-export function updateSensitiveCommand(id, updates) {
-    const config = loadSensitiveCommands();
-    const commandIndex = config.commands.findIndex(cmd => cmd.id === id);
-    if (commandIndex === -1) {
-        throw new Error(`Sensitive command with id "${id}" not found`);
-    }
-    const existingCommand = config.commands[commandIndex];
-    config.commands[commandIndex] = {
-        ...existingCommand,
-        ...updates,
-        id: existingCommand.id,
-        isPreset: existingCommand.isPreset,
-    };
-    saveSensitiveCommands(config);
-}
-/**
- * Toggle a sensitive command enabled state
- */
-export function toggleSensitiveCommand(id) {
-    const config = loadSensitiveCommands();
-    const command = config.commands.find(cmd => cmd.id === id);
-    if (!command) {
-        throw new Error(`Sensitive command with id "${id}" not found`);
-    }
-    command.enabled = !command.enabled;
-    saveSensitiveCommands(config);
-}
-/**
- * 将通配符模式转换为正则表达式
- * 支持 * 通配符
- */
-function patternToRegex(pattern) {
-    // 转义特殊字符，除了 * 和空格
-    const escaped = pattern
-        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '.*');
-    // 使用 ^ 和 $ 确保完整匹配，但允许参数
-    return new RegExp(`^${escaped}`, 'i');
-}
-/**
- * Check if a command matches any enabled sensitive pattern
- */
-export function isSensitiveCommand(command) {
-    const config = loadSensitiveCommands();
-    const enabledCommands = config.commands.filter(cmd => cmd.enabled);
-    // 清理命令，移除多余的空格
-    const cleanCommand = command.trim().replace(/\s+/g, ' ');
-    for (const cmd of enabledCommands) {
-        const regex = patternToRegex(cmd.pattern);
-        if (regex.test(cleanCommand)) {
-            return { isSensitive: true, matchedCommand: cmd };
-        }
-    }
-    return { isSensitive: false };
-}
-/**
- * Get all sensitive commands
- */
-export function getAllSensitiveCommands() {
-    const config = loadSensitiveCommands();
-    return config.commands;
-}
-/**
- * Reset to default preset commands
- */
-export function resetToDefaults() {
-    const config = {
-        commands: [...PRESET_SENSITIVE_COMMANDS],
-    };
-    saveSensitiveCommands(config);
-}

package/dist/utils/sessionConverter.d.ts

@@ -1,7 +0,0 @@
-import type { ChatMessage } from '../api/chat.js';
-import type { Message } from '../ui/components/MessageList.js';
-/**
- * Convert API format session messages to UI format messages
- * Process messages in order to maintain correct sequence
- */
-export declare function convertSessionMessagesToUI(sessionMessages: ChatMessage[]): Message[];

package/dist/utils/sessionConverter.js

@@ -1,306 +0,0 @@
-import { formatToolCallMessage } from './messageFormatter.js';
-import { isToolNeedTwoStepDisplay } from './toolDisplayConfig.js';
-/**
- * Convert API format session messages to UI format messages
- * Process messages in order to maintain correct sequence
- */
-export function convertSessionMessagesToUI(sessionMessages) {
-    const uiMessages = [];
-    // Track which tool_calls have been processed
-    const processedToolCalls = new Set();
-    for (let i = 0; i < sessionMessages.length; i++) {
-        const msg = sessionMessages[i];
-        if (!msg)
-            continue;
-        // Skip system messages
-        if (msg.role === 'system')
-            continue;
-        // Handle sub-agent internal tool call messages
-        if (msg.subAgentInternal && msg.role === 'assistant' && msg.tool_calls) {
-            for (const toolCall of msg.tool_calls) {
-                // 只有耗时工具才创建"进行中"消息
-                if (isToolNeedTwoStepDisplay(toolCall.function.name)) {
-                    const toolDisplay = formatToolCallMessage(toolCall);
-                    let toolArgs;
-                    try {
-                        toolArgs = JSON.parse(toolCall.function.arguments);
-                    }
-                    catch (e) {
-                        toolArgs = {};
-                    }
-                    uiMessages.push({
-                        role: 'subagent',
-                        content: `\x1b[38;2;184;122;206m⚇⚡ ${toolDisplay.toolName}\x1b[0m`,
-                        streaming: false,
-                        toolCall: {
-                            name: toolCall.function.name,
-                            arguments: toolArgs,
-                        },
-                        // Don't include toolDisplay for sub-agent tools to avoid showing parameters
-                        toolCallId: toolCall.id,
-                        toolPending: false,
-                        subAgentInternal: true,
-                    });
-                }
-                processedToolCalls.add(toolCall.id);
-            }
-            continue;
-        }
-        // Handle sub-agent internal tool result messages
-        if (msg.subAgentInternal && msg.role === 'tool' && msg.tool_call_id) {
-            const isError = msg.content.startsWith('Error:');
-            const statusIcon = isError ? '✗' : '✓';
-            const statusText = isError ? `\n  └─ ${msg.content}` : '';
-            // Find tool name from previous assistant message
-            let toolName = 'tool';
-            let terminalResultData;
-            for (let j = i - 1; j >= 0; j--) {
-                const prevMsg = sessionMessages[j];
-                if (!prevMsg)
-                    continue;
-                if (prevMsg.role === 'assistant' &&
-                    prevMsg.tool_calls &&
-                    prevMsg.subAgentInternal) {
-                    const tc = prevMsg.tool_calls.find(t => t.id === msg.tool_call_id);
-                    if (tc) {
-                        toolName = tc.function.name;
-                        if (toolName === 'terminal-execute' && !isError) {
-                            try {
-                                const resultData = JSON.parse(msg.content);
-                                if (resultData.stdout !== undefined ||
-                                    resultData.stderr !== undefined) {
-                                    terminalResultData = {
-                                        stdout: resultData.stdout,
-                                        stderr: resultData.stderr,
-                                        exitCode: resultData.exitCode,
-                                        command: resultData.command,
-                                    };
-                                }
-                            }
-                            catch (e) {
-                                // Ignore parse errors
-                            }
-                        }
-                        break;
-                    }
-                }
-            }
-            uiMessages.push({
-                role: 'subagent',
-                content: `\x1b[38;2;0;186;255m⚇${statusIcon} ${toolName}\x1b[0m${statusText}`,
-                streaming: false,
-                toolResult: !isError ? msg.content : undefined,
-                terminalResult: terminalResultData,
-                toolCall: terminalResultData
-                    ? {
-                        name: toolName,
-                        arguments: terminalResultData,
-                    }
-                    : undefined,
-                subAgentInternal: true,
-            });
-            continue;
-        }
-        // Handle regular assistant messages with tool_calls
-        if (msg.role === 'assistant' &&
-            msg.tool_calls &&
-            msg.tool_calls.length > 0 &&
-            !msg.subAgentInternal) {
-            // Generate parallel group ID for non-time-consuming tools
-            const hasMultipleTools = msg.tool_calls.length > 1;
-            const hasNonTimeConsumingTool = msg.tool_calls.some(tc => !isToolNeedTwoStepDisplay(tc.function.name));
-            const parallelGroupId = hasMultipleTools && hasNonTimeConsumingTool
-                ? `parallel-${i}-${Math.random()}`
-                : undefined;
-            for (const toolCall of msg.tool_calls) {
-                // Skip if already processed
-                if (processedToolCalls.has(toolCall.id))
-                    continue;
-                const toolDisplay = formatToolCallMessage(toolCall);
-                let toolArgs;
-                try {
-                    toolArgs = JSON.parse(toolCall.function.arguments);
-                }
-                catch (e) {
-                    toolArgs = {};
-                }
-                // Only add "in progress" message for tools that need two-step display
-                const needTwoSteps = isToolNeedTwoStepDisplay(toolCall.function.name);
-                if (needTwoSteps) {
-                    // Add tool call message (in progress)
-                    uiMessages.push({
-                        role: 'assistant',
-                        content: `⚡ ${toolDisplay.toolName}`,
-                        streaming: false,
-                        toolCall: {
-                            name: toolCall.function.name,
-                            arguments: toolArgs,
-                        },
-                        toolDisplay,
-                    });
-                }
-                // Store parallel group info for this tool call
-                if (parallelGroupId && !needTwoSteps) {
-                    processedToolCalls.add(toolCall.id);
-                    // Mark this tool call with parallel group (will be used when processing tool results)
-                    toolCall.parallelGroupId = parallelGroupId;
-                }
-                else {
-                    processedToolCalls.add(toolCall.id);
-                }
-            }
-            continue;
-        }
-        // Handle regular tool result messages (non-subagent)
-        if (msg.role === 'tool' && msg.tool_call_id && !msg.subAgentInternal) {
-            const isError = msg.content.startsWith('Error:');
-            const isRejectedWithReply = msg.content.includes('Tool execution rejected by user:');
-            const statusIcon = isError || isRejectedWithReply ? '✗' : '✓';
-            let statusText = '';
-            if (isError) {
-                statusText = `\n  └─ ${msg.content}`;
-            }
-            else if (isRejectedWithReply) {
-                // Extract rejection reason
-                const reason = msg.content.split('Tool execution rejected by user:')[1]?.trim() ||
-                    '';
-                statusText = reason ? `\n  └─ Rejection reason: ${reason}` : '';
-            }
-            // Find tool name and args from previous assistant message
-            let toolName = 'tool';
-            let toolArgs = {};
-            let editDiffData;
-            let terminalResultData;
-            for (let j = i - 1; j >= 0; j--) {
-                const prevMsg = sessionMessages[j];
-                if (!prevMsg)
-                    continue;
-                if (prevMsg.role === 'assistant' &&
-                    prevMsg.tool_calls &&
-                    !prevMsg.subAgentInternal) {
-                    const tc = prevMsg.tool_calls.find(t => t.id === msg.tool_call_id);
-                    if (tc) {
-                        toolName = tc.function.name;
-                        try {
-                            toolArgs = JSON.parse(tc.function.arguments);
-                        }
-                        catch (e) {
-                            toolArgs = {};
-                        }
-                        // Extract edit diff data
-                        if ((toolName === 'filesystem-edit' ||
-                            toolName === 'filesystem-edit_search') &&
-                            !isError) {
-                            try {
-                                const resultData = JSON.parse(msg.content);
-                                // Handle single file edit
-                                if (resultData.oldContent && resultData.newContent) {
-                                    editDiffData = {
-                                        oldContent: resultData.oldContent,
-                                        newContent: resultData.newContent,
-                                        filename: toolArgs.filePath,
-                                        completeOldContent: resultData.completeOldContent,
-                                        completeNewContent: resultData.completeNewContent,
-                                        contextStartLine: resultData.contextStartLine,
-                                    };
-                                    toolArgs.oldContent = resultData.oldContent;
-                                    toolArgs.newContent = resultData.newContent;
-                                    toolArgs.completeOldContent = resultData.completeOldContent;
-                                    toolArgs.completeNewContent = resultData.completeNewContent;
-                                    toolArgs.contextStartLine = resultData.contextStartLine;
-                                }
-                                // Handle batch edit
-                                else if (resultData.results &&
-                                    Array.isArray(resultData.results)) {
-                                    editDiffData = {
-                                        batchResults: resultData.results,
-                                        isBatch: true,
-                                    };
-                                    toolArgs.batchResults = resultData.results;
-                                    toolArgs.isBatch = true;
-                                }
-                            }
-                            catch (e) {
-                                // Ignore parse errors
-                            }
-                        }
-                        // Extract terminal result data
-                        if (toolName === 'terminal-execute' && !isError) {
-                            try {
-                                const resultData = JSON.parse(msg.content);
-                                if (resultData.stdout !== undefined ||
-                                    resultData.stderr !== undefined) {
-                                    terminalResultData = {
-                                        stdout: resultData.stdout,
-                                        stderr: resultData.stderr,
-                                        exitCode: resultData.exitCode,
-                                        command: toolArgs.command,
-                                    };
-                                }
-                            }
-                            catch (e) {
-                                // Ignore parse errors
-                            }
-                        }
-                        break;
-                    }
-                }
-            }
-            // Check if this tool result is part of a parallel group
-            let parallelGroupId;
-            for (let j = i - 1; j >= 0; j--) {
-                const prevMsg = sessionMessages[j];
-                if (!prevMsg)
-                    continue;
-                if (prevMsg.role === 'assistant' &&
-                    prevMsg.tool_calls &&
-                    !prevMsg.subAgentInternal) {
-                    const tc = prevMsg.tool_calls.find(t => t.id === msg.tool_call_id);
-                    if (tc) {
-                        parallelGroupId = tc.parallelGroupId;
-                        break;
-                    }
-                }
-            }
-            const isNonTimeConsuming = !isToolNeedTwoStepDisplay(toolName);
-            uiMessages.push({
-                role: 'assistant',
-                content: `${statusIcon} ${toolName}${statusText}`,
-                streaming: false,
-                toolResult: !isError ? msg.content : undefined,
-                toolCall: editDiffData || terminalResultData
-                    ? {
-                        name: toolName,
-                        arguments: toolArgs,
-                    }
-                    : undefined,
-                terminalResult: terminalResultData,
-                // Add toolDisplay for non-time-consuming tools
-                toolDisplay: isNonTimeConsuming && !editDiffData
-                    ? formatToolCallMessage({
-                        id: msg.tool_call_id || '',
-                        type: 'function',
-                        function: {
-                            name: toolName,
-                            arguments: JSON.stringify(toolArgs),
-                        },
-                    })
-                    : undefined,
-                // Mark parallel group for non-time-consuming tools
-                parallelGroup: isNonTimeConsuming && parallelGroupId ? parallelGroupId : undefined,
-            });
-            continue;
-        }
-        // Handle regular user and assistant messages
-        if (msg.role === 'user' || msg.role === 'assistant') {
-            uiMessages.push({
-                role: msg.role,
-                content: msg.content,
-                streaming: false,
-                images: msg.images,
-            });
-            continue;
-        }
-    }
-    return uiMessages;
-}

package/dist/utils/sessionManager.d.ts

@@ -1,53 +0,0 @@
-import type { ChatMessage as APIChatMessage } from '../api/chat.js';
-export interface ChatMessage extends APIChatMessage {
-    timestamp: number;
-    originalContent?: string;
-}
-export interface Session {
-    id: string;
-    title: string;
-    summary: string;
-    createdAt: number;
-    updatedAt: number;
-    messages: ChatMessage[];
-    messageCount: number;
-}
-export interface SessionListItem {
-    id: string;
-    title: string;
-    summary: string;
-    createdAt: number;
-    updatedAt: number;
-    messageCount: number;
-}
-declare class SessionManager {
-    private readonly sessionsDir;
-    private currentSession;
-    constructor();
-    private ensureSessionsDir;
-    private getSessionPath;
-    private formatDateForFolder;
-    /**
-     * Clean title by removing newlines and extra spaces
-     */
-    private cleanTitle;
-    createNewSession(): Promise<Session>;
-    saveSession(session: Session): Promise<void>;
-    loadSession(sessionId: string): Promise<Session | null>;
-    private findSessionInDateFolders;
-    listSessions(): Promise<SessionListItem[]>;
-    private readSessionsFromDir;
-    addMessage(message: ChatMessage): Promise<void>;
-    /**
-     * Generate AI-powered summary for the first conversation exchange
-     * This runs in the background without blocking the main flow
-     */
-    private generateAndUpdateSummary;
-    getCurrentSession(): Session | null;
-    setCurrentSession(session: Session): void;
-    clearCurrentSession(): void;
-    deleteSession(sessionId: string): Promise<boolean>;
-    truncateMessages(messageCount: number): Promise<void>;
-}
-export declare const sessionManager: SessionManager;
-export {};