snow-ai 0.3.23 → 0.3.25

package/dist/ui/components/ToolConfirmation.js

@@ -1,6 +1,7 @@
 import React, { useState, useMemo } from 'react';
 import { Box, Text } from 'ink';
 import SelectInput from 'ink-select-input';
+import { isSensitiveCommand } from '../../utils/sensitiveCommandManager.js';
 // Helper function to format argument values with truncation
 function formatArgumentValue(value, maxLength = 100) {
     if (value === null || value === undefined) {
@@ -35,11 +36,28 @@ function formatArgumentsAsTree(args, toolName) {
     return keys.map((key, index) => ({
         key,
         value: formatArgumentValue(args[key]),
-        isLast: index === keys.length - 1
+        isLast: index === keys.length - 1,
     }));
 }
-export default function ToolConfirmation({ toolName, toolArguments, allTools, onConfirm }) {
+export default function ToolConfirmation({ toolName, toolArguments, allTools, onConfirm, }) {
     const [hasSelected, setHasSelected] = useState(false);
+    // Check if this is a sensitive command (for terminal-execute)
+    const sensitiveCommandCheck = useMemo(() => {
+        if (toolName !== 'terminal-execute' || !toolArguments) {
+            return { isSensitive: false };
+        }
+        try {
+            const parsed = JSON.parse(toolArguments);
+            const command = parsed.command;
+            if (command && typeof command === 'string') {
+                return isSensitiveCommand(command);
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+        return { isSensitive: false };
+    }, [toolName, toolArguments]);
     // Parse and format tool arguments for display (single tool)
     const formattedArgs = useMemo(() => {
         if (!toolArguments)
@@ -61,31 +79,38 @@ export default function ToolConfirmation({ toolName, toolArguments, allTools, on
                 const parsed = JSON.parse(tool.function.arguments);
                 return {
                     name: tool.function.name,
-                    args: formatArgumentsAsTree(parsed, tool.function.name)
+                    args: formatArgumentsAsTree(parsed, tool.function.name),
                 };
             }
             catch {
                 return {
                     name: tool.function.name,
-                    args: []
+                    args: [],
                 };
             }
         });
     }, [allTools]);
-    const items = [
-        {
-            label: 'Approve (once)',
-            value: 'approve'
-        },
-        {
-            label: 'Always approve this tool',
-            value: 'approve_always'
-        },
-        {
-            label: 'Reject (end session)',
-            value: 'reject'
+    // Conditionally show "Always approve" based on sensitive command check
+    const items = useMemo(() => {
+        const baseItems = [
+            {
+                label: 'Approve (once)',
+                value: 'approve',
+            },
+        ];
+        // Only show "Always approve" if NOT a sensitive command
+        if (!sensitiveCommandCheck.isSensitive) {
+            baseItems.push({
+                label: 'Always approve this tool',
+                value: 'approve_always',
+            });
         }
-    ];
+        baseItems.push({
+            label: 'Reject (end session)',
+            value: 'reject',
+        });
+        return baseItems;
+    }, [sensitiveCommandCheck.isSensitive]);
     const handleSelect = (item) => {
         if (!hasSelected) {
             setHasSelected(true);
@@ -98,8 +123,21 @@ export default function ToolConfirmation({ toolName, toolArguments, allTools, on
         !formattedAllTools && (React.createElement(React.Fragment, null,
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null,
-                    "Tool: ",
+                    "Tool:",
+                    ' ',
                     React.createElement(Text, { bold: true, color: "cyan" }, toolName))),
+            sensitiveCommandCheck.isSensitive && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, { bold: true, color: "red" }, "SENSITIVE COMMAND DETECTED")),
+                React.createElement(Box, { flexDirection: "column", gap: 0 },
+                    React.createElement(Box, null,
+                        React.createElement(Text, { dimColor: true }, "Pattern: "),
+                        React.createElement(Text, { color: "magenta", bold: true }, sensitiveCommandCheck.matchedCommand?.pattern)),
+                    React.createElement(Box, { marginTop: 0 },
+                        React.createElement(Text, { dimColor: true }, "Reason: "),
+                        React.createElement(Text, { color: "white" }, sensitiveCommandCheck.matchedCommand?.description))),
+                React.createElement(Box, { marginTop: 1, paddingX: 1, paddingY: 0 },
+                    React.createElement(Text, { color: "yellow", italic: true }, "This command requires confirmation even in YOLO/Always-Approved mode")))),
             formattedArgs && formattedArgs.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
                 React.createElement(Text, { dimColor: true }, "Arguments:"),
                 formattedArgs.map((arg, index) => (React.createElement(Box, { key: index, flexDirection: "column" },
@@ -107,12 +145,14 @@ export default function ToolConfirmation({ toolName, toolArguments, allTools, on
                         arg.isLast ? '└─' : '├─',
                         " ",
                         arg.key,
-                        ": ",
+                        ":",
+                        ' ',
                         React.createElement(Text, { color: "white" }, arg.value))))))))),
         formattedAllTools && (React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null,
-                    "Tools: ",
+                    "Tools:",
+                    ' ',
                     React.createElement(Text, { bold: true, color: "cyan" },
                         formattedAllTools.length,
                         " tools in parallel"))),
@@ -125,11 +165,12 @@ export default function ToolConfirmation({ toolName, toolArguments, allTools, on
                     arg.isLast ? '└─' : '├─',
                     " ",
                     arg.key,
-                    ": ",
+                    ":",
+                    ' ',
                     React.createElement(Text, { color: "white" }, arg.value))))))))))),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Select action:")),
-        !hasSelected && (React.createElement(SelectInput, { items: items, onSelect: handleSelect })),
+        !hasSelected && React.createElement(SelectInput, { items: items, onSelect: handleSelect }),
         hasSelected && (React.createElement(Box, null,
             React.createElement(Text, { color: "green" }, "Confirmed")))));
 }

package/dist/ui/pages/ChatScreen.js

@@ -13,7 +13,6 @@ import MarkdownRenderer from '../components/MarkdownRenderer.js';
 import ToolConfirmation from '../components/ToolConfirmation.js';
 import DiffViewer from '../components/DiffViewer.js';
 import ToolResultPreview from '../components/ToolResultPreview.js';
-import TodoTree from '../components/TodoTree.js';
 import FileRollbackConfirmation from '../components/FileRollbackConfirmation.js';
 import ShimmerText from '../components/ShimmerText.js';
 import { getOpenAiConfig } from '../../utils/apiConfig.js';
@@ -50,7 +49,6 @@ import '../../utils/commands/todoPicker.js';
 export default function ChatScreen({ skipWelcome }) {
     const [messages, setMessages] = useState([]);
     const [isSaving] = useState(false);
-    const [currentTodos, setCurrentTodos] = useState([]);
     const [pendingMessages, setPendingMessages] = useState([]);
     const pendingMessagesRef = useRef([]);
     const hasAttemptedAutoVscodeConnect = useRef(false);
@@ -570,7 +568,6 @@ export default function ChatScreen({ skipWelcome }) {
                 saveMessage,
                 setMessages,
                 setStreamTokenCount: streamingState.setStreamTokenCount,
-                setCurrentTodos,
                 requestToolConfirmation,
                 isToolAutoApproved,
                 addMultipleToAlwaysApproved,
@@ -754,7 +751,6 @@ export default function ChatScreen({ skipWelcome }) {
                 saveMessage,
                 setMessages,
                 setStreamTokenCount: streamingState.setStreamTokenCount,
-                setCurrentTodos,
                 requestToolConfirmation,
                 isToolAutoApproved,
                 addMultipleToAlwaysApproved,
@@ -939,7 +935,7 @@ export default function ChatScreen({ skipWelcome }) {
                                 React.createElement(Text, { color: "gray", dimColor: true },
                                     "\u2514\u2500 ",
                                     message.commandName),
-                                message.content && (React.createElement(Text, { color: "white" }, message.content)))) : message.showTodoTree ? (React.createElement(TodoTree, { todos: currentTodos })) : (React.createElement(React.Fragment, null,
+                                message.content && (React.createElement(Text, { color: "white" }, message.content)))) : (React.createElement(React.Fragment, null,
                                 message.role === 'user' || isToolMessage ? (React.createElement(Text, { color: message.role === 'user'
                                         ? 'gray'
                                         : message.content.startsWith('⚡')

package/dist/ui/pages/ConfigScreen.js

@@ -455,7 +455,7 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                         "Anthropic Beta:"),
                     React.createElement(Box, { marginLeft: 3 },
                         React.createElement(Text, { color: "gray" },
-                            anthropicBeta ? '☒ Enabled' : '☐ Disabled',
+                            anthropicBeta ? '[✓] Enabled' : '[ ] Disabled',
                             " (Press Enter to toggle)"))));
             case 'thinkingEnabled':
                 return (React.createElement(Box, { key: field, flexDirection: "column" },
@@ -464,7 +464,7 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                         "Thinking Enabled:"),
                     React.createElement(Box, { marginLeft: 3 },
                         React.createElement(Text, { color: "gray" },
-                            thinkingEnabled ? '☒ Enabled' : '☐ Disabled',
+                            thinkingEnabled ? '[✓] Enabled' : '[ ] Disabled',
                             " (Press Enter to toggle)"))));
             case 'thinkingBudgetTokens':
                 return (React.createElement(Box, { key: field, flexDirection: "column" },
@@ -484,7 +484,7 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                         "Gemini Thinking Enabled:"),
                     React.createElement(Box, { marginLeft: 3 },
                         React.createElement(Text, { color: "gray" },
-                            geminiThinkingEnabled ? '☒ Enabled' : '☐ Disabled',
+                            geminiThinkingEnabled ? '[✓] Enabled' : '[ ] Disabled',
                             " (Press Enter to toggle)"))));
             case 'geminiThinkingBudget':
                 return (React.createElement(Box, { key: field, flexDirection: "column" },
@@ -504,8 +504,9 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                         "Responses Reasoning Enabled:"),
                     React.createElement(Box, { marginLeft: 3 },
                         React.createElement(Text, { color: "gray" },
-                            responsesReasoningEnabled ? '☒ Enabled' : '☐ Disabled',
-                            " (Press Enter to toggle)"))));
+                            responsesReasoningEnabled ? '[✓] Enabled' : '[ ] Disabled',
+                            ' ',
+                            "(Press Enter to toggle)"))));
             case 'responsesReasoningEffort':
                 return (React.createElement(Box, { key: field, flexDirection: "column" },
                     React.createElement(Text, { color: isActive ? 'green' : 'white' },
@@ -964,7 +965,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 currentField === 'advancedModel' && 'Advanced Model',
                 currentField === 'basicModel' && 'Basic Model',
                 currentField === 'compactModelName' && 'Compact Model',
-                currentField === 'responsesReasoningEffort' && 'Responses Reasoning Effort',
+                currentField === 'responsesReasoningEffort' &&
+                    'Responses Reasoning Effort',
                 ":"),
             React.createElement(Box, { marginLeft: 3, marginTop: 1 },
                 currentField === 'profile' && (React.createElement(Box, { flexDirection: "column" },

package/dist/ui/pages/HeadlessModeScreen.js

@@ -339,7 +339,6 @@ export default function HeadlessModeScreen({ prompt, onComplete }) {
                 saveMessage,
                 setMessages,
                 setStreamTokenCount: streamingState.setStreamTokenCount,
-                setCurrentTodos: () => { }, // No-op in headless mode
                 requestToolConfirmation,
                 isToolAutoApproved,
                 addMultipleToAlwaysApproved,

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

@@ -4,5 +4,5 @@ type Props = {
     onSave: () => void;
     inlineMode?: boolean;
 };
-export default function ProxyConfigScreen({ onBack, onSave, inlineMode }: Props): React.JSX.Element;
+export default function ProxyConfigScreen({ onBack, onSave, inlineMode, }: Props): React.JSX.Element;
 export {};

package/dist/ui/pages/ProxyConfigScreen.js

@@ -4,7 +4,7 @@ import Gradient from 'ink-gradient';
 import { Alert } from '@inkjs/ui';
 import TextInput from 'ink-text-input';
 import { getProxyConfig, updateProxyConfig, } from '../../utils/apiConfig.js';
-export default function ProxyConfigScreen({ onBack, onSave, inlineMode = false }) {
+export default function ProxyConfigScreen({ onBack, onSave, inlineMode = false, }) {
     const [enabled, setEnabled] = useState(false);
     const [port, setPort] = useState('7890');
     const [browserPath, setBrowserPath] = useState('');
@@ -86,7 +86,7 @@ export default function ProxyConfigScreen({ onBack, onSave, inlineMode = false }
         }
     });
     return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-        !inlineMode && (React.createElement(Box, { marginBottom: 1, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
+        !inlineMode && (React.createElement(Box, { marginBottom: 1, borderStyle: "double", borderColor: 'cyan', paddingX: 2, paddingY: 1 },
             React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Gradient, { name: "rainbow" }, "Proxy Configuration"),
                 React.createElement(Text, { color: "gray", dimColor: true }, "Configure system proxy for web search and fetch")))),
@@ -98,7 +98,7 @@ export default function ProxyConfigScreen({ onBack, onSave, inlineMode = false }
                         "Enable Proxy:"),
                     React.createElement(Box, { marginLeft: 3 },
                         React.createElement(Text, { color: "gray" },
-                            enabled ? '☒ Enabled' : '☐ Disabled',
+                            enabled ? '[✓] Enabled' : '[ ] Disabled',
                             " (Press Enter to toggle)")))),
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Box, { flexDirection: "column" },
@@ -131,13 +131,13 @@ export default function ProxyConfigScreen({ onBack, onSave, inlineMode = false }
                 "Browser Path Examples: ",
                 React.createElement(Newline, null),
                 React.createElement(Text, { color: 'blue' }, "\u2022 Windows: C:\\Program Files(x86)\\Microsoft\\Edge\\Application\\msedge.exe"),
-                " ",
+                ' ',
                 React.createElement(Newline, null),
                 React.createElement(Text, { color: 'green' }, "\u2022 macOS: /Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
-                " ",
+                ' ',
                 React.createElement(Newline, null),
                 React.createElement(Text, { color: 'yellow' }, "\u2022 Linux: /usr/bin/chromium-browser"),
-                " ",
+                ' ',
                 React.createElement(Newline, null),
                 "Leave empty to auto-detect system browser (Edge/Chrome)"))));
 }

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

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    onBack: () => void;
+    inlineMode?: boolean;
+};
+export default function SensitiveCommandConfigScreen({ onBack, inlineMode, }: Props): React.JSX.Element;
+export {};

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/patch-highlight.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Patch cli-highlight to gracefully handle unknown languages
+ * This must be loaded BEFORE any modules that use cli-highlight
+ */
+export {};