snow-ai 0.2.15 → 0.2.17

package/dist/ui/pages/CustomHeadersScreen.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    onBack: () => void;
+    onSave: () => void;
+};
+export default function CustomHeadersScreen({ onBack }: Props): null;
+export {};

package/dist/ui/pages/CustomHeadersScreen.js

@@ -0,0 +1,104 @@
+import { useEffect } from 'react';
+import { useApp } from 'ink';
+import { spawn } from 'child_process';
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform } from 'os';
+const CONFIG_DIR = join(homedir(), '.snow');
+const CUSTOM_HEADERS_FILE = join(CONFIG_DIR, 'custom-headers.json');
+function getSystemEditor() {
+    if (platform() === 'win32') {
+        return 'notepad';
+    }
+    return process.env['EDITOR'] || 'vim';
+}
+function ensureConfigDirectory() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+const DEFAULT_HEADERS_TEMPLATE = `{
+  "X-Custom-Header": "custom-value",
+  "User-Agent": "MyApp/1.0"
+}`;
+export default function CustomHeadersScreen({ onBack }) {
+    const { exit } = useApp();
+    useEffect(() => {
+        const openEditor = async () => {
+            ensureConfigDirectory();
+            // Read existing custom headers, or use template if not exists
+            let currentHeaders = DEFAULT_HEADERS_TEMPLATE;
+            if (existsSync(CUSTOM_HEADERS_FILE)) {
+                try {
+                    currentHeaders = readFileSync(CUSTOM_HEADERS_FILE, 'utf8');
+                }
+                catch {
+                    // Read failed, use template
+                    currentHeaders = DEFAULT_HEADERS_TEMPLATE;
+                }
+            }
+            // Write to file for editing
+            writeFileSync(CUSTOM_HEADERS_FILE, currentHeaders, 'utf8');
+            const editor = getSystemEditor();
+            exit();
+            const child = spawn(editor, [CUSTOM_HEADERS_FILE], {
+                stdio: 'inherit'
+            });
+            child.on('close', () => {
+                // Read edited content
+                if (existsSync(CUSTOM_HEADERS_FILE)) {
+                    try {
+                        const editedContent = readFileSync(CUSTOM_HEADERS_FILE, 'utf8');
+                        const trimmedContent = editedContent.trim();
+                        // Validate JSON format
+                        if (trimmedContent === '' || trimmedContent === '{}') {
+                            // Empty or empty object, delete file to reset
+                            try {
+                                const fs = require('fs');
+                                fs.unlinkSync(CUSTOM_HEADERS_FILE);
+                                console.log('Custom headers cleared. Please use `snow` to restart!');
+                            }
+                            catch {
+                                // Delete failed, save empty object
+                                writeFileSync(CUSTOM_HEADERS_FILE, '{}', 'utf8');
+                                console.log('Custom headers cleared. Please use `snow` to restart!');
+                            }
+                        }
+                        else {
+                            // Validate JSON
+                            try {
+                                const headers = JSON.parse(trimmedContent);
+                                if (typeof headers !== 'object' || headers === null || Array.isArray(headers)) {
+                                    throw new Error('Headers must be a JSON object');
+                                }
+                                // Validate all values are strings
+                                for (const [key, value] of Object.entries(headers)) {
+                                    if (typeof value !== 'string') {
+                                        throw new Error(`Header value for "${key}" must be a string`);
+                                    }
+                                }
+                                // Save valid headers
+                                writeFileSync(CUSTOM_HEADERS_FILE, JSON.stringify(headers, null, 2), 'utf8');
+                                console.log('Custom headers saved successfully! Please use `snow` to restart!');
+                            }
+                            catch (error) {
+                                console.error('Invalid JSON format:', error instanceof Error ? error.message : 'Unknown error');
+                                console.error('Custom headers were NOT saved. Please fix the JSON format and try again.');
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error('Failed to save custom headers:', error instanceof Error ? error.message : 'Unknown error');
+                    }
+                }
+                process.exit(0);
+            });
+            child.on('error', (error) => {
+                console.error('Failed to open editor:', error.message);
+                process.exit(1);
+            });
+        };
+        openEditor();
+    }, [exit, onBack]);
+    return null;
+}

package/dist/ui/pages/WelcomeScreen.js

@@ -27,6 +27,11 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
             value: 'systemprompt',
             infoText: 'Configure custom system prompt (overrides default)',
         },
+        {
+            label: 'Custom Headers Settings',
+            value: 'customheaders',
+            infoText: 'Configure custom HTTP headers for API requests',
+        },
         {
             label: 'MCP Settings',
             value: 'mcp',

package/dist/utils/apiConfig.d.ts

@@ -42,3 +42,13 @@ export declare function validateMCPConfig(config: Partial<MCPConfig>): string[];
  * 否则返回 undefined (使用默认系统提示词)
  */
 export declare function getCustomSystemPrompt(): string | undefined;
+/**
+ * 读取自定义请求头配置
+ * 如果 custom-headers.json 文件存在且有效，返回其内容
+ * 否则返回空对象
+ */
+export declare function getCustomHeaders(): Record<string, string>;
+/**
+ * 保存自定义请求头配置
+ */
+export declare function saveCustomHeaders(headers: Record<string, string>): void;

package/dist/utils/apiConfig.js

@@ -18,6 +18,7 @@ const DEFAULT_MCP_CONFIG = {
 };
 const CONFIG_DIR = join(homedir(), '.snow');
 const SYSTEM_PROMPT_FILE = join(CONFIG_DIR, 'system-prompt.txt');
+const CUSTOM_HEADERS_FILE = join(CONFIG_DIR, 'custom-headers.json');
 function normalizeRequestMethod(method) {
     if (method === 'chat' || method === 'responses' || method === 'gemini' || method === 'anthropic') {
         return method;
@@ -216,3 +217,53 @@ export function getCustomSystemPrompt() {
         return undefined;
     }
 }
+/**
+ * 读取自定义请求头配置
+ * 如果 custom-headers.json 文件存在且有效，返回其内容
+ * 否则返回空对象
+ */
+export function getCustomHeaders() {
+    ensureConfigDirectory();
+    if (!existsSync(CUSTOM_HEADERS_FILE)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(CUSTOM_HEADERS_FILE, 'utf8');
+        const headers = JSON.parse(content);
+        // 验证格式：必须是对象，且所有值都是字符串
+        if (typeof headers !== 'object' || headers === null || Array.isArray(headers)) {
+            return {};
+        }
+        // 过滤掉非字符串的值
+        const validHeaders = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (typeof value === 'string') {
+                validHeaders[key] = value;
+            }
+        }
+        return validHeaders;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * 保存自定义请求头配置
+ */
+export function saveCustomHeaders(headers) {
+    ensureConfigDirectory();
+    try {
+        // 过滤掉空键值对
+        const filteredHeaders = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (key.trim() && value.trim()) {
+                filteredHeaders[key.trim()] = value.trim();
+            }
+        }
+        const content = JSON.stringify(filteredHeaders, null, 2);
+        writeFileSync(CUSTOM_HEADERS_FILE, content, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save custom headers: ${error}`);
+    }
+}

package/dist/utils/incrementalSnapshot.d.ts

@@ -60,6 +60,14 @@ declare class IncrementalSnapshotManager {
      * Rollback to a specific snapshot
      */
     rollbackToSnapshot(sessionId: string, messageIndex: number): Promise<boolean>;
+    /**
+     * Rollback all snapshots after a specific message index
+     * This is used when user selects to rollback to a specific message
+     * @param sessionId Session ID
+     * @param targetMessageIndex The message index to rollback to (inclusive)
+     * @returns Number of files rolled back
+     */
+    rollbackToMessageIndex(sessionId: string, targetMessageIndex: number): Promise<number>;
     /**
      * Clear all snapshots for a session
      */

package/dist/utils/incrementalSnapshot.js

@@ -157,6 +157,69 @@ class IncrementalSnapshotManager {
             return false;
         }
     }
+    /**
+     * Rollback all snapshots after a specific message index
+     * This is used when user selects to rollback to a specific message
+     * @param sessionId Session ID
+     * @param targetMessageIndex The message index to rollback to (inclusive)
+     * @returns Number of files rolled back
+     */
+    async rollbackToMessageIndex(sessionId, targetMessageIndex) {
+        await this.ensureSnapshotsDir();
+        try {
+            const files = await fs.readdir(this.snapshotsDir);
+            const snapshots = [];
+            // Load all snapshots for this session
+            for (const file of files) {
+                if (file.startsWith(sessionId) && file.endsWith('.json')) {
+                    const snapshotPath = path.join(this.snapshotsDir, file);
+                    const content = await fs.readFile(snapshotPath, 'utf-8');
+                    const metadata = JSON.parse(content);
+                    snapshots.push({
+                        messageIndex: metadata.messageIndex,
+                        path: snapshotPath,
+                        metadata
+                    });
+                }
+            }
+            // Filter snapshots that are >= targetMessageIndex and sort in descending order
+            // We rollback from newest to oldest to ensure correct restoration
+            const snapshotsToRollback = snapshots
+                .filter(s => s.messageIndex >= targetMessageIndex)
+                .sort((a, b) => b.messageIndex - a.messageIndex);
+            let totalFilesRolledBack = 0;
+            // Rollback each snapshot in reverse chronological order
+            for (const snapshot of snapshotsToRollback) {
+                for (const backup of snapshot.metadata.backups) {
+                    try {
+                        if (backup.existed && backup.content !== null) {
+                            // Restore original file content
+                            await fs.writeFile(backup.path, backup.content, 'utf-8');
+                            totalFilesRolledBack++;
+                        }
+                        else if (!backup.existed) {
+                            // Delete file that was created
+                            try {
+                                await fs.unlink(backup.path);
+                                totalFilesRolledBack++;
+                            }
+                            catch (error) {
+                                // File may not exist, ignore
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Failed to restore file ${backup.path}:`, error);
+                    }
+                }
+            }
+            return totalFilesRolledBack;
+        }
+        catch (error) {
+            console.error('Failed to rollback to message index:', error);
+            return 0;
+        }
+    }
     /**
      * Clear all snapshots for a session
      */

package/dist/utils/mcpToolsManager.js

@@ -382,7 +382,12 @@ export async function executeMCPTool(toolName, args) {
             case 'create':
                 return await filesystemService.createFile(args.filePath, args.content, args.createDirectories);
             case 'delete':
-                return await filesystemService.deleteFile(args.filePath);
+                // Support both filePath (legacy) and filePaths (new) parameters
+                const pathsToDelete = args.filePaths || args.filePath;
+                if (!pathsToDelete) {
+                    throw new Error('Missing required parameter: filePath or filePaths');
+                }
+                return await filesystemService.deleteFile(pathsToDelete);
             case 'list':
                 return await filesystemService.listFiles(args.dirPath);
             case 'exists':

package/dist/utils/retryUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 重试工具函数
+ * 提供统一的重试机制用于所有 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>;

package/dist/utils/retryUtils.js

@@ -0,0 +1,180 @@
+/**
+ * 重试工具函数
+ * 提供统一的重试机制用于所有 AI 请求
+ * - 支持5次重试
+ * - 延时递增策略 (1s, 2s, 4s, 8s, 16s)
+ * - 支持 AbortSignal 中断
+ */
+/**
+ * 延时函数，支持 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 (5xx)
+    if (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;
+    }
+    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');
+}

package/dist/utils/sessionConverter.js

@@ -4,33 +4,31 @@ import { formatToolCallMessage } from './messageFormatter.js';
  */
 export function convertSessionMessagesToUI(sessionMessages) {
     const uiMessages = [];
+    // First pass: build a map of tool_call_id to tool results
+    const toolResultsMap = new Map();
+    for (const msg of sessionMessages) {
+        if (msg.role === 'tool' && msg.tool_call_id) {
+            toolResultsMap.set(msg.tool_call_id, msg.content);
+        }
+    }
     for (const msg of sessionMessages) {
         // Skip system messages
         if (msg.role === 'system')
             continue;
-        // Handle tool role messages (tool execution results)
-        if (msg.role === 'tool') {
-            const isError = msg.content.startsWith('Error:');
-            const statusIcon = isError ? '✗' : '✓';
-            const statusText = isError ? `\n  └─ ${msg.content}` : '';
-            const toolName = msg.tool_call_id || 'unknown-tool';
-            uiMessages.push({
-                role: 'assistant',
-                content: `${statusIcon} ${toolName}${statusText}`,
-                streaming: false,
-                toolResult: !isError ? msg.content : undefined
-            });
+        // Skip tool role messages (we'll attach them to tool calls)
+        if (msg.role === 'tool')
             continue;
-        }
         // Handle user and assistant messages
         const uiMessage = {
             role: msg.role,
             content: msg.content,
             streaming: false,
-            images: msg.images
+            images: msg.images,
         };
         // If assistant message has tool_calls, expand to show each tool call
-        if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+        if (msg.role === 'assistant' &&
+            msg.tool_calls &&
+            msg.tool_calls.length > 0) {
             for (const toolCall of msg.tool_calls) {
                 const toolDisplay = formatToolCallMessage(toolCall);
                 let toolArgs;
@@ -40,16 +38,81 @@ export function convertSessionMessagesToUI(sessionMessages) {
                 catch (e) {
                     toolArgs = {};
                 }
+                // Get the tool result for this tool call
+                const toolResult = toolResultsMap.get(toolCall.id);
+                const isError = toolResult?.startsWith('Error:') || false;
+                // For filesystem-edit, try to extract diff data from result
+                let editDiffData;
+                if (toolCall.function.name === 'filesystem-edit' &&
+                    toolResult &&
+                    !isError) {
+                    try {
+                        const resultData = JSON.parse(toolResult);
+                        if (resultData.oldContent && resultData.newContent) {
+                            editDiffData = {
+                                oldContent: resultData.oldContent,
+                                newContent: resultData.newContent,
+                                filename: toolArgs.filePath,
+                            };
+                            // Merge diff data into toolArgs for DiffViewer
+                            toolArgs.oldContent = resultData.oldContent;
+                            toolArgs.newContent = resultData.newContent;
+                        }
+                    }
+                    catch (e) {
+                        // If parsing fails, just show regular result
+                    }
+                }
+                // For terminal-execute, try to extract terminal result data
+                let terminalResultData;
+                if (toolCall.function.name === 'terminal-execute' &&
+                    toolResult &&
+                    !isError) {
+                    try {
+                        const resultData = JSON.parse(toolResult);
+                        if (resultData.stdout !== undefined ||
+                            resultData.stderr !== undefined) {
+                            terminalResultData = {
+                                stdout: resultData.stdout,
+                                stderr: resultData.stderr,
+                                exitCode: resultData.exitCode,
+                                command: toolArgs.command,
+                            };
+                        }
+                    }
+                    catch (e) {
+                        // If parsing fails, just show regular result
+                    }
+                }
+                // Create tool call message
                 uiMessages.push({
                     role: 'assistant',
                     content: `⚡ ${toolDisplay.toolName}`,
                     streaming: false,
                     toolCall: {
                         name: toolCall.function.name,
-                        arguments: toolArgs
+                        arguments: toolArgs,
                     },
-                    toolDisplay
+                    toolDisplay,
                 });
+                // Create tool result message
+                if (toolResult) {
+                    const statusIcon = isError ? '✗' : '✓';
+                    const statusText = isError ? `\n  └─ ${toolResult}` : '';
+                    uiMessages.push({
+                        role: 'assistant',
+                        content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                        streaming: false,
+                        toolResult: !isError ? toolResult : undefined,
+                        toolCall: editDiffData || terminalResultData
+                            ? {
+                                name: toolCall.function.name,
+                                arguments: toolArgs,
+                            }
+                            : undefined,
+                        terminalResult: terminalResultData,
+                    });
+                }
             }
         }
         else {