snow-ai 0.3.22 → 0.3.24

package/dist/ui/pages/SensitiveCommandConfigScreen.js

@@ -0,0 +1,262 @@
+import React, { useState, useCallback, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { Alert } from '@inkjs/ui';
+import { getAllSensitiveCommands, toggleSensitiveCommand, addSensitiveCommand, removeSensitiveCommand, resetToDefaults, } from '../../utils/sensitiveCommandManager.js';
+// Focus event handling
+const focusEventTokenRegex = /(?:\x1b)?\[[0-9;]*[IO]/g;
+const isFocusEventInput = (value) => {
+    if (!value)
+        return false;
+    if (value === '\x1b[I' ||
+        value === '\x1b[O' ||
+        value === '[I' ||
+        value === '[O') {
+        return true;
+    }
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    const tokens = trimmed.match(focusEventTokenRegex);
+    if (!tokens)
+        return false;
+    const normalized = trimmed.replace(/\s+/g, '');
+    const tokensCombined = tokens.join('');
+    return tokensCombined === normalized;
+};
+const stripFocusArtifacts = (value) => {
+    if (!value)
+        return '';
+    return value
+        .replace(/\x1b\[[0-9;]*[IO]/g, '')
+        .replace(/\[[0-9;]*[IO]/g, '')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+};
+export default function SensitiveCommandConfigScreen({ onBack, inlineMode = false, }) {
+    const [commands, setCommands] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [viewMode, setViewMode] = useState('list');
+    const [showSuccess, setShowSuccess] = useState(false);
+    const [successMessage, setSuccessMessage] = useState('');
+    // Confirmation states
+    const [confirmDelete, setConfirmDelete] = useState(false);
+    const [confirmReset, setConfirmReset] = useState(false);
+    // Add custom command fields
+    const [customPattern, setCustomPattern] = useState('');
+    const [customDescription, setCustomDescription] = useState('');
+    const [addField, setAddField] = useState('pattern');
+    // Load commands
+    const loadCommands = useCallback(() => {
+        const allCommands = getAllSensitiveCommands();
+        setCommands(allCommands);
+    }, []);
+    useEffect(() => {
+        loadCommands();
+    }, [loadCommands]);
+    // Handle list view input
+    const handleListInput = useCallback((input, key) => {
+        if (key.escape) {
+            // Cancel any pending confirmations
+            if (confirmDelete || confirmReset) {
+                setConfirmDelete(false);
+                setConfirmReset(false);
+                return;
+            }
+            onBack();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+            // Clear confirmations when navigating
+            setConfirmDelete(false);
+            setConfirmReset(false);
+        }
+        else if (key.downArrow) {
+            setSelectedIndex(prev => Math.min(commands.length - 1, prev + 1));
+            // Clear confirmations when navigating
+            setConfirmDelete(false);
+            setConfirmReset(false);
+        }
+        else if (input === ' ') {
+            // Toggle command
+            const cmd = commands[selectedIndex];
+            if (cmd) {
+                toggleSensitiveCommand(cmd.id);
+                loadCommands();
+                setSuccessMessage(cmd.enabled
+                    ? `Disabled: ${cmd.pattern}`
+                    : `Enabled: ${cmd.pattern}`);
+                setShowSuccess(true);
+                setTimeout(() => setShowSuccess(false), 2000);
+            }
+        }
+        else if (input === 'a' || input === 'A') {
+            // Add custom command
+            setViewMode('add');
+            setCustomPattern('');
+            setCustomDescription('');
+            setAddField('pattern');
+        }
+        else if (input === 'd' || input === 'D') {
+            // Delete custom command - requires confirmation
+            const cmd = commands[selectedIndex];
+            if (cmd && !cmd.isPreset) {
+                if (!confirmDelete) {
+                    // First press - ask for confirmation
+                    setConfirmDelete(true);
+                    setConfirmReset(false);
+                }
+                else {
+                    // Second press - execute delete
+                    removeSensitiveCommand(cmd.id);
+                    loadCommands();
+                    setSelectedIndex(prev => Math.min(prev, commands.length - 2));
+                    setSuccessMessage(`Deleted: ${cmd.pattern}`);
+                    setShowSuccess(true);
+                    setTimeout(() => setShowSuccess(false), 2000);
+                    setConfirmDelete(false);
+                }
+            }
+        }
+        else if (input === 'r' || input === 'R') {
+            // Reset to defaults - requires confirmation
+            if (!confirmReset) {
+                // First press - ask for confirmation
+                setConfirmReset(true);
+                setConfirmDelete(false);
+            }
+            else {
+                // Second press - execute reset
+                resetToDefaults();
+                loadCommands();
+                setSelectedIndex(0);
+                setSuccessMessage('Reset to default commands');
+                setShowSuccess(true);
+                setTimeout(() => setShowSuccess(false), 2000);
+                setConfirmReset(false);
+            }
+        }
+    }, [
+        commands,
+        selectedIndex,
+        onBack,
+        loadCommands,
+        confirmDelete,
+        confirmReset,
+    ]);
+    // Handle add view input
+    const handleAddInput = useCallback((_input, key) => {
+        if (key.escape) {
+            setViewMode('list');
+            return;
+        }
+        if (key.tab) {
+            setAddField(prev => (prev === 'pattern' ? 'description' : 'pattern'));
+        }
+    }, []);
+    // Use input hook
+    useInput((input, key) => {
+        if (viewMode === 'list') {
+            handleListInput(input, key);
+        }
+        else {
+            handleAddInput(input, key);
+        }
+    }, { isActive: true });
+    // Handle pattern input change
+    const handlePatternChange = useCallback((value) => {
+        if (!isFocusEventInput(value)) {
+            setCustomPattern(stripFocusArtifacts(value));
+        }
+    }, []);
+    // Handle description input change
+    const handleDescriptionChange = useCallback((value) => {
+        if (!isFocusEventInput(value)) {
+            setCustomDescription(stripFocusArtifacts(value));
+        }
+    }, []);
+    // Handle add submit
+    const handleAddSubmit = useCallback(() => {
+        if (addField === 'pattern') {
+            setAddField('description');
+        }
+        else {
+            // Submit
+            if (customPattern.trim() && customDescription.trim()) {
+                try {
+                    addSensitiveCommand(customPattern.trim(), customDescription.trim());
+                    loadCommands();
+                    setViewMode('list');
+                    setSuccessMessage(`Added: ${customPattern}`);
+                    setShowSuccess(true);
+                    setTimeout(() => setShowSuccess(false), 2000);
+                }
+                catch (error) {
+                    // Handle error
+                }
+            }
+        }
+    }, [addField, customPattern, customDescription, loadCommands]);
+    if (viewMode === 'add') {
+        return (React.createElement(Box, { flexDirection: "column", paddingX: inlineMode ? 0 : 2, paddingY: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, "Add Custom Sensitive Command"),
+            React.createElement(Box, { marginTop: 1 }),
+            React.createElement(Text, { dimColor: true }, "Pattern (supports wildcards, e.g., \"rm*\"):"),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: addField === 'pattern' ? 'cyan' : 'gray' }, "\u276F "),
+                React.createElement(TextInput, { value: customPattern, onChange: handlePatternChange, onSubmit: handleAddSubmit, focus: addField === 'pattern' })),
+            React.createElement(Box, { marginTop: 1 }),
+            React.createElement(Text, { dimColor: true }, "Description:"),
+            React.createElement(Box, null,
+                React.createElement(Text, { color: addField === 'description' ? 'cyan' : 'gray' }, "\u276F "),
+                React.createElement(TextInput, { value: customDescription, onChange: handleDescriptionChange, onSubmit: handleAddSubmit, focus: addField === 'description' })),
+            React.createElement(Box, { marginTop: 1 }),
+            React.createElement(Text, { dimColor: true }, "Tab: Switch \u2022 Enter: Submit \u2022 Esc: Cancel")));
+    }
+    // Calculate visible range for scrolling
+    const viewportHeight = 13;
+    const startIndex = Math.max(0, selectedIndex - Math.floor(viewportHeight / 2));
+    const endIndex = Math.min(commands.length, startIndex + viewportHeight);
+    const adjustedStart = Math.max(0, endIndex - viewportHeight);
+    const selectedCmd = commands[selectedIndex];
+    return (React.createElement(Box, { flexDirection: "column", paddingX: inlineMode ? 0 : 2, paddingY: 1 },
+        React.createElement(Text, { bold: true, color: "cyan" }, "Sensitive Command Protection"),
+        React.createElement(Text, { dimColor: true }, "Configure commands that require confirmation even in YOLO/Always-Approved mode"),
+        showSuccess && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Alert, { variant: "success" }, successMessage))),
+        React.createElement(Box, { marginTop: 1 }),
+        commands.length === 0 ? (React.createElement(Text, { dimColor: true }, "No commands configured")) : (commands.map((cmd, index) => {
+            // Only render items in the visible viewport
+            if (index < adjustedStart || index >= endIndex) {
+                return null;
+            }
+            return (React.createElement(Text, { key: cmd.id, color: selectedIndex === index
+                    ? 'cyan'
+                    : cmd.enabled
+                        ? 'white'
+                        : 'gray', bold: selectedIndex === index, dimColor: !cmd.enabled },
+                selectedIndex === index ? '❯ ' : '  ',
+                "[",
+                cmd.enabled ? '✓' : ' ',
+                "]",
+                ' ',
+                cmd.pattern,
+                !cmd.isPreset && React.createElement(Text, { color: "yellow" }, " (custom)")));
+        })),
+        React.createElement(Box, { marginTop: 1 }),
+        selectedCmd && !confirmDelete && !confirmReset && (React.createElement(Text, { dimColor: true },
+            selectedCmd.description,
+            " (",
+            selectedCmd.enabled ? 'Enabled' : 'Disabled',
+            ")",
+            !selectedCmd.isPreset && ' [Custom]')),
+        confirmDelete && selectedCmd && (React.createElement(Text, { bold: true, color: "yellow" },
+            "\u26A0\uFE0F Press D again to confirm deletion of \"",
+            selectedCmd.pattern,
+            "\"")),
+        confirmReset && (React.createElement(Text, { bold: true, color: "yellow" }, "\u26A0\uFE0F Press R again to confirm reset to default commands")),
+        React.createElement(Box, { marginTop: 1 }),
+        React.createElement(Text, { dimColor: true }, confirmDelete || confirmReset
+            ? 'Press the same key again to confirm • Esc: Cancel'
+            : '↑↓: Navigate • Space: Toggle • A: Add • D: Delete • R: Reset • Esc: Back')));
+}

package/dist/ui/pages/SubAgentConfigScreen.js

@@ -353,7 +353,7 @@ export default function SubAgentConfigScreen({ onBack, onSave, inlineMode = fals
                         return (React.createElement(Box, { key: tool },
                             React.createElement(Text, { color: isCurrentTool ? 'cyan' : 'white', bold: isCurrentTool },
                                 isCurrentTool ? '❯ ' : '  ',
-                                selectedTools.has(tool) ? '☒' : '☐',
+                                selectedTools.has(tool) ? '[✓]' : '[ ]',
                                 " ",
                                 tool)));
                     })))));

package/dist/ui/pages/WelcomeScreen.js

@@ -9,6 +9,7 @@ import ConfigScreen from './ConfigScreen.js';
 import ProxyConfigScreen from './ProxyConfigScreen.js';
 import SubAgentConfigScreen from './SubAgentConfigScreen.js';
 import SubAgentListScreen from './SubAgentListScreen.js';
+import SensitiveCommandConfigScreen from './SensitiveCommandConfigScreen.js';
 export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
     const [infoText, setInfoText] = useState('Start a new chat conversation');
     const [inlineView, setInlineView] = useState('menu');
@@ -54,6 +55,11 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
             value: 'subagent',
             infoText: 'Configure sub-agents with custom tool permissions',
         },
+        {
+            label: 'Sensitive Commands',
+            value: 'sensitive-commands',
+            infoText: 'Configure commands that require confirmation even in YOLO mode',
+        },
         {
             label: 'Exit',
             value: 'exit',
@@ -75,6 +81,9 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
         else if (value === 'subagent') {
             setInlineView('subagent-list');
         }
+        else if (value === 'sensitive-commands') {
+            setInlineView('sensitive-commands');
+        }
         else {
             // Pass through to parent for other actions (chat, exit, etc.)
             onMenuSelect?.(value);
@@ -107,11 +116,11 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
         const handler = setTimeout(() => {
             stdout.write(ansiEscapes.clearTerminal);
             setRemountKey(prev => prev + 1); // Force re-render
-        }, 0); // Wait for resize to stabilize
+        }, 200); // Add debounce delay to avoid rapid re-renders
         return () => {
             clearTimeout(handler);
         };
-    }, [terminalWidth, stdout]);
+    }, [terminalWidth]); // Remove stdout from dependencies to avoid loops
     return (React.createElement(Box, { flexDirection: "column", width: terminalWidth },
         React.createElement(Static, { key: remountKey, items: [
                 React.createElement(Box, { key: "welcome-header", flexDirection: "row", paddingLeft: 2, paddingTop: 1, paddingBottom: 0, width: terminalWidth },
@@ -137,5 +146,7 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
         inlineView === 'subagent-add' && (React.createElement(Box, { paddingX: 1 },
             React.createElement(SubAgentConfigScreen, { onBack: () => setInlineView('subagent-list'), onSave: handleSubAgentSave, inlineMode: true }))),
         inlineView === 'subagent-edit' && (React.createElement(Box, { paddingX: 1 },
-            React.createElement(SubAgentConfigScreen, { onBack: () => setInlineView('subagent-list'), onSave: handleSubAgentSave, agentId: editingAgentId, inlineMode: true })))));
+            React.createElement(SubAgentConfigScreen, { onBack: () => setInlineView('subagent-list'), onSave: handleSubAgentSave, agentId: editingAgentId, inlineMode: true }))),
+        inlineView === 'sensitive-commands' && (React.createElement(Box, { paddingX: 1 },
+            React.createElement(SensitiveCommandConfigScreen, { onBack: handleBackToMenu, inlineMode: true })))));
 }

package/dist/utils/apiConfig.d.ts

@@ -6,6 +6,14 @@ export interface ThinkingConfig {
     type: 'enabled';
     budget_tokens: number;
 }
+export interface GeminiThinkingConfig {
+    enabled: boolean;
+    budget: number;
+}
+export interface ResponsesReasoningConfig {
+    enabled: boolean;
+    effort: 'low' | 'medium' | 'high';
+}
 export interface ApiConfig {
     baseUrl: string;
     apiKey: string;
@@ -17,6 +25,8 @@ export interface ApiConfig {
     compactModel?: CompactModelConfig;
     anthropicBeta?: boolean;
     thinking?: ThinkingConfig;
+    geminiThinking?: GeminiThinkingConfig;
+    responsesReasoning?: ResponsesReasoningConfig;
 }
 export interface MCPServer {
     url?: string;

package/dist/utils/sensitiveCommandManager.d.ts

@@ -0,0 +1,53 @@
+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;