snow-ai 0.4.3 → 0.4.5

package/dist/api/anthropic.d.ts

@@ -41,7 +41,4 @@ export interface AnthropicMessageParam {
     content: string | Array<any>;
 }
 export declare function resetAnthropicClient(): void;
-/**
- * Create streaming chat completion using Anthropic API
- */
 export declare function createStreamingAnthropicCompletion(options: AnthropicOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<AnthropicStreamChunk, void, unknown>;

package/dist/api/anthropic.js

@@ -5,6 +5,7 @@ import { withRetryGenerator, parseJsonWithFix } from '../utils/retryUtils.js';
 import { logger } from '../utils/logger.js';
 import { addProxyToFetchOptions } from '../utils/proxyUtils.js';
 import { saveUsageToFile } from '../utils/usageLogger.js';
+import { isDevMode, getDevUserId } from '../utils/devMode.js';
 let anthropicConfig = null;
 // Persistent userId that remains the same until application restart
 let persistentUserId = null;
@@ -35,8 +36,16 @@ export function resetAnthropicClient() {
  * Generate a persistent user_id that remains the same until application restart
  * Format: user_<hash>_account__session_<uuid>
  * This matches Anthropic's expected format for tracking and caching
+ *
+ * In dev mode (--dev flag), uses a persistent userId from ~/.snow/dev-user-id
+ * instead of generating a new one each session
  */
 function getPersistentUserId() {
+    // Check if dev mode is enabled
+    if (isDevMode()) {
+        return getDevUserId();
+    }
+    // Normal mode: generate userId per session
     if (!persistentUserId) {
         const sessionId = randomUUID();
         const hash = createHash('sha256')
@@ -251,43 +260,58 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
 async function* parseSSEStream(reader) {
     const decoder = new TextDecoder();
     let buffer = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith(':'))
-                continue;
-            if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
-                return;
-            }
-            // Handle both "event: " and "event:" formats
-            if (trimmed.startsWith('event:')) {
-                // Event type, will be followed by data
-                continue;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                // ✅ 关键修复：检查buffer是否有残留数据
+                if (buffer.trim()) {
+                    // 连接异常中断，抛出明确错误
+                    throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                }
+                break; // 正常结束
             }
-            // Handle both "data: " and "data:" formats
-            if (trimmed.startsWith('data:')) {
-                const data = trimmed.startsWith('data: ')
-                    ? trimmed.slice(6)
-                    : trimmed.slice(5);
-                try {
-                    yield JSON.parse(data);
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith(':'))
+                    continue;
+                if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
+                    return;
+                }
+                // Handle both "event: " and "event:" formats
+                if (trimmed.startsWith('event:')) {
+                    // Event type, will be followed by data
+                    continue;
                 }
-                catch (e) {
-                    logger.error('Failed to parse SSE data:', data);
+                // Handle both "data: " and "data:" formats
+                if (trimmed.startsWith('data:')) {
+                    const data = trimmed.startsWith('data: ')
+                        ? trimmed.slice(6)
+                        : trimmed.slice(5);
+                    const parseResult = parseJsonWithFix(data, {
+                        toolName: 'SSE stream',
+                        logWarning: false,
+                        logError: true,
+                    });
+                    if (parseResult.success) {
+                        yield parseResult.data;
+                    }
                 }
             }
         }
     }
+    catch (error) {
+        const { logger } = await import('../utils/logger.js');
+        logger.error('SSE stream parsing error:', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            remainingBuffer: buffer.substring(0, 200),
+        });
+        throw error;
+    }
 }
-/**
- * Create streaming chat completion using Anthropic API
- */
 export async function* createStreamingAnthropicCompletion(options, abortSignal, onRetry) {
     yield* withRetryGenerator(async function* () {
         const config = getAnthropicConfig();

package/dist/api/chat.js

@@ -126,41 +126,57 @@ export function resetOpenAIClient() {
 async function* parseSSEStream(reader) {
     const decoder = new TextDecoder();
     let buffer = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith(':'))
-                continue;
-            if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
-                return;
-            }
-            // Handle both "event: " and "event:" formats
-            if (trimmed.startsWith('event:')) {
-                // Event type, will be followed by data
-                continue;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                // ✅ 关键修复：检查buffer是否有残留数据
+                if (buffer.trim()) {
+                    // 连接异常中断，抛出明确错误
+                    throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                }
+                break; // 正常结束
             }
-            // Handle both "data: " and "data:" formats
-            if (trimmed.startsWith('data:')) {
-                const data = trimmed.startsWith('data: ')
-                    ? trimmed.slice(6)
-                    : trimmed.slice(5);
-                const parseResult = parseJsonWithFix(data, {
-                    toolName: 'SSE stream',
-                    logWarning: false,
-                    logError: true,
-                });
-                if (parseResult.success) {
-                    yield parseResult.data;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith(':'))
+                    continue;
+                if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
+                    return;
+                }
+                // Handle both "event: " and "event:" formats
+                if (trimmed.startsWith('event:')) {
+                    // Event type, will be followed by data
+                    continue;
+                }
+                // Handle both "data: " and "data:" formats
+                if (trimmed.startsWith('data:')) {
+                    const data = trimmed.startsWith('data: ')
+                        ? trimmed.slice(6)
+                        : trimmed.slice(5);
+                    const parseResult = parseJsonWithFix(data, {
+                        toolName: 'SSE stream',
+                        logWarning: false,
+                        logError: true,
+                    });
+                    if (parseResult.success) {
+                        yield parseResult.data;
+                    }
                 }
             }
         }
     }
+    catch (error) {
+        const { logger } = await import('../utils/logger.js');
+        logger.error('SSE stream parsing error:', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            remainingBuffer: buffer.substring(0, 200),
+        });
+        throw error;
+    }
 }
 /**
  * Simple streaming chat completion - only handles OpenAI interaction

package/dist/api/gemini.js

@@ -280,97 +280,113 @@ export async function* createStreamingGeminiCompletion(options, abortSignal, onR
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            if (abortSignal?.aborted) {
-                return;
-            }
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith(':'))
-                    continue;
-                if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
-                    break;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    // ✅ 关键修复：检查buffer是否有残留数据
+                    if (buffer.trim()) {
+                        // 连接异常中断，抛出明确错误
+                        throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                    }
+                    break; // 正常结束
                 }
-                // Handle both "event: " and "event:" formats
-                if (trimmed.startsWith('event:')) {
-                    // Event type, will be followed by data
-                    continue;
+                if (abortSignal?.aborted) {
+                    return;
                 }
-                // Handle both "data: " and "data:" formats
-                if (trimmed.startsWith('data:')) {
-                    const data = trimmed.startsWith('data: ')
-                        ? trimmed.slice(6)
-                        : trimmed.slice(5);
-                    const parseResult = parseJsonWithFix(data, {
-                        toolName: 'Gemini SSE stream',
-                        logWarning: false,
-                        logError: true,
-                    });
-                    if (parseResult.success) {
-                        const chunk = parseResult.data;
-                        // Process candidates
-                        if (chunk.candidates && chunk.candidates.length > 0) {
-                            const candidate = chunk.candidates[0];
-                            if (candidate.content && candidate.content.parts) {
-                                for (const part of candidate.content.parts) {
-                                    // Process thought content (Gemini thinking)
-                                    // When part.thought === true, the text field contains thinking content
-                                    if (part.thought === true && part.text) {
-                                        thinkingTextBuffer += part.text;
-                                        yield {
-                                            type: 'reasoning_delta',
-                                            delta: part.text,
-                                        };
-                                    }
-                                    // Process regular text content (when thought is not true)
-                                    else if (part.text) {
-                                        contentBuffer += part.text;
-                                        yield {
-                                            type: 'content',
-                                            content: part.text,
-                                        };
-                                    }
-                                    // Process function calls
-                                    if (part.functionCall) {
-                                        hasToolCalls = true;
-                                        const fc = part.functionCall;
-                                        const toolCall = {
-                                            id: `call_${toolCallIndex++}`,
-                                            type: 'function',
-                                            function: {
-                                                name: fc.name,
-                                                arguments: JSON.stringify(fc.args || {}),
-                                            },
-                                        };
-                                        toolCallsBuffer.push(toolCall);
-                                        // Yield delta for token counting
-                                        const deltaText = fc.name + JSON.stringify(fc.args || {});
-                                        yield {
-                                            type: 'tool_call_delta',
-                                            delta: deltaText,
-                                        };
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith(':'))
+                        continue;
+                    if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
+                        break;
+                    }
+                    // Handle both "event: " and "event:" formats
+                    if (trimmed.startsWith('event:')) {
+                        // Event type, will be followed by data
+                        continue;
+                    }
+                    // Handle both "data: " and "data:" formats
+                    if (trimmed.startsWith('data:')) {
+                        const data = trimmed.startsWith('data: ')
+                            ? trimmed.slice(6)
+                            : trimmed.slice(5);
+                        const parseResult = parseJsonWithFix(data, {
+                            toolName: 'Gemini SSE stream',
+                            logWarning: false,
+                            logError: true,
+                        });
+                        if (parseResult.success) {
+                            const chunk = parseResult.data;
+                            // Process candidates
+                            if (chunk.candidates && chunk.candidates.length > 0) {
+                                const candidate = chunk.candidates[0];
+                                if (candidate.content && candidate.content.parts) {
+                                    for (const part of candidate.content.parts) {
+                                        // Process thought content (Gemini thinking)
+                                        // When part.thought === true, the text field contains thinking content
+                                        if (part.thought === true && part.text) {
+                                            thinkingTextBuffer += part.text;
+                                            yield {
+                                                type: 'reasoning_delta',
+                                                delta: part.text,
+                                            };
+                                        }
+                                        // Process regular text content (when thought is not true)
+                                        else if (part.text) {
+                                            contentBuffer += part.text;
+                                            yield {
+                                                type: 'content',
+                                                content: part.text,
+                                            };
+                                        }
+                                        // Process function calls
+                                        if (part.functionCall) {
+                                            hasToolCalls = true;
+                                            const fc = part.functionCall;
+                                            const toolCall = {
+                                                id: `call_${toolCallIndex++}`,
+                                                type: 'function',
+                                                function: {
+                                                    name: fc.name,
+                                                    arguments: JSON.stringify(fc.args || {}),
+                                                },
+                                            };
+                                            toolCallsBuffer.push(toolCall);
+                                            // Yield delta for token counting
+                                            const deltaText = fc.name + JSON.stringify(fc.args || {});
+                                            yield {
+                                                type: 'tool_call_delta',
+                                                delta: deltaText,
+                                            };
+                                        }
                                     }
                                 }
                             }
-                        }
-                        // Track usage info
-                        if (chunk.usageMetadata) {
-                            totalTokens = {
-                                prompt: chunk.usageMetadata.promptTokenCount || 0,
-                                completion: chunk.usageMetadata.candidatesTokenCount || 0,
-                                total: chunk.usageMetadata.totalTokenCount || 0,
-                            };
+                            // Track usage info
+                            if (chunk.usageMetadata) {
+                                totalTokens = {
+                                    prompt: chunk.usageMetadata.promptTokenCount || 0,
+                                    completion: chunk.usageMetadata.candidatesTokenCount || 0,
+                                    total: chunk.usageMetadata.totalTokenCount || 0,
+                                };
+                            }
                         }
                     }
                 }
             }
         }
+        catch (error) {
+            const { logger } = await import('../utils/logger.js');
+            logger.error('Gemini SSE stream parsing error:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                remainingBuffer: buffer.substring(0, 200),
+            });
+            throw error;
+        }
         // Yield tool calls if any
         if (hasToolCalls && toolCallsBuffer.length > 0) {
             yield {

package/dist/api/responses.js

@@ -207,41 +207,57 @@ function convertToResponseInput(messages, includeBuiltinSystemPrompt = true) {
 async function* parseSSEStream(reader) {
     const decoder = new TextDecoder();
     let buffer = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith(':'))
-                continue;
-            if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
-                return;
-            }
-            // Handle both "event: " and "event:" formats
-            if (trimmed.startsWith('event:')) {
-                // Event type, will be followed by data
-                continue;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                // ✅ 关键修复：检查buffer是否有残留数据
+                if (buffer.trim()) {
+                    // 连接异常中断，抛出明确错误
+                    throw new Error(`Stream terminated unexpectedly with incomplete data: ${buffer.substring(0, 100)}...`);
+                }
+                break; // 正常结束
             }
-            // Handle both "data: " and "data:" formats
-            if (trimmed.startsWith('data:')) {
-                const data = trimmed.startsWith('data: ')
-                    ? trimmed.slice(6)
-                    : trimmed.slice(5);
-                const parseResult = parseJsonWithFix(data, {
-                    toolName: 'Responses API SSE stream',
-                    logWarning: false,
-                    logError: true,
-                });
-                if (parseResult.success) {
-                    yield parseResult.data;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith(':'))
+                    continue;
+                if (trimmed === 'data: [DONE]' || trimmed === 'data:[DONE]') {
+                    return;
+                }
+                // Handle both "event: " and "event:" formats
+                if (trimmed.startsWith('event:')) {
+                    // Event type, will be followed by data
+                    continue;
+                }
+                // Handle both "data: " and "data:" formats
+                if (trimmed.startsWith('data:')) {
+                    const data = trimmed.startsWith('data: ')
+                        ? trimmed.slice(6)
+                        : trimmed.slice(5);
+                    const parseResult = parseJsonWithFix(data, {
+                        toolName: 'Responses API SSE stream',
+                        logWarning: false,
+                        logError: true,
+                    });
+                    if (parseResult.success) {
+                        yield parseResult.data;
+                    }
                 }
             }
         }
     }
+    catch (error) {
+        const { logger } = await import('../utils/logger.js');
+        logger.error('Responses API SSE stream parsing error:', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            remainingBuffer: buffer.substring(0, 200),
+        });
+        throw error;
+    }
 }
 /**
  * 使用 Responses API 创建流式响应（带自动工具调用）

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import './utils/patch-highlight.js';
+export {};

package/dist/cli.js

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
-// CRITICAL: Patch cli-highlight BEFORE any other imports
-// This must be the first import to ensure the patch is applied before cli-markdown loads
-import './utils/patch-highlight.js';
 import React from 'react';
 import { render, Text, Box } from 'ink';
 import Spinner from 'ink-spinner';
@@ -13,6 +10,7 @@ import { vscodeConnection } from './utils/vscodeConnection.js';
 import { resourceMonitor } from './utils/resourceMonitor.js';
 import { initializeProfiles } from './utils/configManager.js';
 import { processManager } from './utils/processManager.js';
+import { enableDevMode, getDevUserId } from './utils/devMode.js';
 const execAsync = promisify(exec);
 // Check for updates asynchronously
 async function checkForUpdates(currentVersion) {
@@ -43,6 +41,7 @@ Options
 		--update   Update to latest version
 		-c         Skip welcome screen and resume last conversation
 		--ask      Quick question mode (headless mode with single prompt)
+		--dev      Enable developer mode with persistent userId for testing
 `, {
     importMeta: import.meta,
     flags: {
@@ -57,6 +56,10 @@ Options
         ask: {
             type: 'string',
         },
+        dev: {
+            type: 'boolean',
+            default: false,
+        },
     },
 });
 // Handle update flag
@@ -72,6 +75,14 @@ if (cli.flags.update) {
         process.exit(1);
     }
 }
+// Handle dev mode flag
+if (cli.flags.dev) {
+    enableDevMode();
+    const userId = getDevUserId();
+    console.log('🔧 Developer mode enabled');
+    console.log(`📝 Using persistent userId: ${userId}`);
+    console.log(`📂 Stored in: ~/.snow/dev-user-id\n`);
+}
 // Start resource monitoring in development/debug mode
 if (process.env['NODE_ENV'] === 'development' || process.env['DEBUG']) {
     resourceMonitor.startMonitoring(30000); // Monitor every 30 seconds

package/dist/hooks/useConversation.js

@@ -1041,9 +1041,12 @@ export async function handleConversationWithTools(options) {
         freeEncoder();
     }
     catch (error) {
-        freeEncoder();
         throw error;
     }
+    finally {
+        // ✅ 确保总是释放encoder资源，避免资源泄漏
+        freeEncoder();
+    }
     // Return the accumulated usage data
     return { usage: accumulatedUsage };
 }

package/dist/ui/components/MarkdownRenderer.js

@@ -1,23 +1,70 @@
 import React from 'react';
 import { Text, Box } from 'ink';
-// @ts-expect-error - cli-markdown doesn't have TypeScript definitions
-import cliMarkdown from 'cli-markdown';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
 import logger from '../../utils/logger.js';
+// Configure marked to use terminal renderer
+marked.setOptions({
+    // @ts-expect-error - marked-terminal types mismatch with marked v15
+    renderer: new TerminalRenderer({
+        reflowText: true,
+        width: 80,
+        emoji: false,
+        tab: 2,
+    }),
+});
+/**
+ * Sanitize markdown content to prevent number-to-alphabet errors
+ * Fixes invalid ordered list start attributes (0 or negative values)
+ */
+function sanitizeMarkdownContent(content) {
+    // Replace <ol start="0">, <ol start="-1">, etc. with <ol start="1">
+    return content.replace(/<ol\s+start=["']?(0|-\d+)["']?>/gi, '<ol start="1">');
+}
+/**
+ * Fallback renderer for when cli-markdown fails
+ * Renders content as plain text to ensure visibility
+ */
+function renderFallback(content) {
+    const lines = content.split('\n');
+    return (React.createElement(Box, { flexDirection: "column" }, lines.map((line, index) => (React.createElement(Text, { key: index }, line)))));
+}
 export default function MarkdownRenderer({ content }) {
-    // Use cli-markdown for elegant markdown rendering with syntax highlighting
-    // The patched highlight function will gracefully handle unknown languages
-    const rendered = cliMarkdown(content);
-    // Split into lines and render each separately
-    // This prevents Ink's Text component from creating mysterious whitespace
-    // when handling multi-line content with \n characters
-    const lines = rendered.split('\n');
-    // Safety check: prevent rendering issues with excessively long output
-    if (lines.length > 500) {
-        logger.warn('[MarkdownRenderer] Rendered output has too many lines', {
-            totalLines: lines.length,
-            truncatedTo: 500,
+    // Use marked + marked-terminal for elegant markdown rendering with syntax highlighting
+    // marked provides better stability and cross-platform support
+    try {
+        // Stage 1: Sanitize content to prevent invalid list numbering
+        const sanitizedContent = sanitizeMarkdownContent(content);
+        // Stage 2: Render with marked
+        const rendered = marked.parse(sanitizedContent);
+        // Split into lines and render each separately
+        // This prevents Ink's Text component from creating mysterious whitespace
+        // when handling multi-line content with \n characters
+        const lines = rendered.split('\n');
+        // Safety check: prevent rendering issues with excessively long output
+        if (lines.length > 500) {
+            logger.warn('[MarkdownRenderer] Rendered output has too many lines', {
+                totalLines: lines.length,
+                truncatedTo: 500,
+            });
+            return (React.createElement(Box, { flexDirection: "column" }, lines.slice(0, 500).map((line, index) => (React.createElement(Text, { key: index }, line)))));
+        }
+        return (React.createElement(Box, { flexDirection: "column" }, lines.map((line, index) => (React.createElement(Text, { key: index }, line)))));
+    }
+    catch (error) {
+        // Stage 3: Error handling - catch number-to-alphabet errors
+        if (error?.message?.includes('Number must be >')) {
+            logger.warn('[MarkdownRenderer] Invalid list numbering detected, falling back to plain text', {
+                error: error.message,
+            });
+            return renderFallback(content);
+        }
+        // Re-throw other errors for debugging
+        logger.error('[MarkdownRenderer] Unexpected error during markdown rendering', {
+            error: error.message,
+            stack: error.stack,
         });
-        return (React.createElement(Box, { flexDirection: "column" }, lines.slice(0, 500).map((line, index) => (React.createElement(Text, { key: index }, line)))));
+        // Still provide fallback to prevent crash
+        return renderFallback(content);
     }
-    return (React.createElement(Box, { flexDirection: "column" }, lines.map((line, index) => (React.createElement(Text, { key: index }, line)))));
 }

package/dist/utils/devMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get or create persistent dev userId
+ * The userId is stored in ~/.snow/dev-user-id and persists across sessions
+ */
+export declare function getDevUserId(): string;
+/**
+ * Check if dev mode is enabled
+ */
+export declare function isDevMode(): boolean;
+/**
+ * Enable dev mode by setting environment variable
+ */
+export declare function enableDevMode(): void;

package/dist/utils/devMode.js

@@ -0,0 +1,54 @@
+import { createHash, randomUUID } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const SNOW_DIR = join(homedir(), '.snow');
+const DEV_USER_ID_FILE = join(SNOW_DIR, 'dev-user-id');
+/**
+ * Ensure .snow directory exists
+ */
+function ensureSnowDir() {
+    if (!existsSync(SNOW_DIR)) {
+        mkdirSync(SNOW_DIR, { recursive: true });
+    }
+}
+/**
+ * Generate a persistent dev userId following Anthropic's format
+ * Format: user_<hash>_account__session_<uuid>
+ */
+function generateDevUserId() {
+    const sessionId = randomUUID();
+    const hash = createHash('sha256')
+        .update(`anthropic_dev_user_${sessionId}`)
+        .digest('hex');
+    return `user_${hash}_account__session_${sessionId}`;
+}
+/**
+ * Get or create persistent dev userId
+ * The userId is stored in ~/.snow/dev-user-id and persists across sessions
+ */
+export function getDevUserId() {
+    ensureSnowDir();
+    if (existsSync(DEV_USER_ID_FILE)) {
+        const userId = readFileSync(DEV_USER_ID_FILE, 'utf-8').trim();
+        if (userId) {
+            return userId;
+        }
+    }
+    // Generate new userId if file doesn't exist or is empty
+    const userId = generateDevUserId();
+    writeFileSync(DEV_USER_ID_FILE, userId, 'utf-8');
+    return userId;
+}
+/**
+ * Check if dev mode is enabled
+ */
+export function isDevMode() {
+    return process.env['SNOW_DEV_MODE'] === 'true';
+}
+/**
+ * Enable dev mode by setting environment variable
+ */
+export function enableDevMode() {
+    process.env['SNOW_DEV_MODE'] = 'true';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.4.3",
+	"version": "0.4.5",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -44,8 +44,9 @@
 		"@types/better-sqlite3": "^7.6.13",
 		"better-sqlite3": "^12.4.1",
 		"cli-highlight": "^2.1.11",
-		"cli-markdown": "^3.5.1",
 		"diff": "^8.0.2",
+		"marked": "^15.0.6",
+		"marked-terminal": "^7.3.0",
 		"fzf": "^0.5.2",
 		"http-proxy-agent": "^7.0.2",
 		"https-proxy-agent": "^7.0.6",
@@ -66,6 +67,7 @@
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "^3.0.1",
 		"@types/diff": "^7.0.2",
+		"@types/marked-terminal": "^6.1.1",
 		"@types/prettier": "^2.7.3",
 		"@types/react": "^18.0.32",
 		"@types/ws": "^8.5.8",