@defai.digital/ax-cli 3.12.10 → 3.13.1

package/dist/ui/hooks/use-input-handler.js

@@ -20,14 +20,21 @@ import { openExternalEditor, getPreferredEditor, getEditorDisplayName } from "..
 import { extractErrorMessage } from "../../utils/error-handler.js";
 import { getCustomCommandsManager } from "../../commands/custom-commands.js";
 import { getHooksManager } from "../../hooks/index.js";
+import { getMCPPrompts, getMCPManager, getMCPResources } from "../../llm/tools.js";
+import { promptToSlashCommand, parsePromptCommand, formatPromptResult, getPromptDescription } from "../../mcp/prompts.js";
+import { getPermissionManager, PermissionTier } from "../../permissions/permission-manager.js";
 import { parseFileMentions } from "../../utils/file-mentions.js";
 import * as fs from "fs";
 import * as path from "path";
 export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProcessing, setIsStreaming, setTokenCount, setProcessingTime, processingStartTime, isProcessing, isStreaming, isConfirmationActive = false, onQuickActionsToggle, onVerboseModeChange, onBackgroundModeChange, onAutoEditModeChange, onTaskMovedToBackground, onOperationInterrupted, onChatCleared, onCopyLastResponse, onMemoryWarmed, onMemoryRefreshed, onCheckpointCreated: _onCheckpointCreated, // Reserved for future checkpoint UI
 onCheckpointRestored: _onCheckpointRestored, // Reserved for future checkpoint UI
-onLargePaste, onPasteTruncated, onKeyboardHelp, onThinkingModeChange, onEditorOpening, onEditorSuccess, onEditorCancelled, onEditorError, }) {
+onLargePaste, onPasteTruncated, onKeyboardHelp, onMcpDashboardToggle, onThinkingModeChange, onEditorOpening, onEditorSuccess, onEditorCancelled, onEditorError, }) {
     const [showCommandSuggestions, setShowCommandSuggestions] = useState(false);
     const [selectedCommandIndex, setSelectedCommandIndex] = useState(0);
+    const [resourceSuggestions, setResourceSuggestions] = useState([]);
+    const [suggestionMode, setSuggestionMode] = useState("command");
+    // BUG FIX: Track current MCP query to prevent race condition with stale async results
+    const currentMcpQueryRef = useRef(null);
     const retryTimeoutRef = useRef(null);
     const [autoEditEnabled, setAutoEditEnabled] = useState(() => {
         const confirmationService = ConfirmationService.getInstance();
@@ -69,6 +76,11 @@ onLargePaste, onPasteTruncated, onKeyboardHelp, onThinkingModeChange, onEditorOp
             if (showCommandSuggestions) {
                 setShowCommandSuggestions(false);
                 setSelectedCommandIndex(0);
+                // Reset resource mode if active
+                if (suggestionMode === "resource") {
+                    setResourceSuggestions([]);
+                    setSuggestionMode("command");
+                }
                 return true;
             }
             if (isProcessing || isStreaming) {
@@ -84,33 +96,51 @@ onLargePaste, onPasteTruncated, onKeyboardHelp, onThinkingModeChange, onEditorOp
             }
             return false; // Let default escape handling work
         }
-        // Handle command suggestions navigation
+        // Handle command/resource suggestions navigation
         if (showCommandSuggestions) {
-            const filteredSuggestions = filterCommandSuggestions(commandSuggestions, input);
-            if (filteredSuggestions.length === 0) {
+            // Get appropriate suggestions based on mode
+            const currentSuggestions = suggestionMode === "resource"
+                ? resourceSuggestions.map((r) => ({ command: r.reference, description: r.description || r.name }))
+                : filterCommandSuggestions(commandSuggestions, input);
+            if (currentSuggestions.length === 0) {
                 setShowCommandSuggestions(false);
                 setSelectedCommandIndex(0);
                 return false; // Continue processing
             }
             else {
                 if (key.upArrow) {
-                    setSelectedCommandIndex((prev) => prev === 0 ? filteredSuggestions.length - 1 : prev - 1);
+                    setSelectedCommandIndex((prev) => prev === 0 ? currentSuggestions.length - 1 : prev - 1);
                     return true;
                 }
                 if (key.downArrow) {
-                    setSelectedCommandIndex((prev) => (prev + 1) % filteredSuggestions.length);
+                    setSelectedCommandIndex((prev) => (prev + 1) % currentSuggestions.length);
                     return true;
                 }
                 if (key.tab || key.return) {
                     // Check if there are any suggestions available
-                    if (filteredSuggestions.length === 0) {
+                    if (currentSuggestions.length === 0) {
                         return true; // No suggestions, do nothing
                     }
-                    const safeIndex = Math.min(selectedCommandIndex, filteredSuggestions.length - 1);
-                    const selectedCommand = filteredSuggestions[safeIndex];
-                    const newInput = selectedCommand.command + " ";
-                    setInput(newInput);
-                    setCursorPosition(newInput.length);
+                    const safeIndex = Math.min(selectedCommandIndex, currentSuggestions.length - 1);
+                    const selected = currentSuggestions[safeIndex];
+                    if (suggestionMode === "resource") {
+                        // Replace @mcp:partial with the full reference
+                        const mcpMatch = input.match(/@mcp:[^\s]*$/);
+                        if (mcpMatch) {
+                            const newInput = input.replace(/@mcp:[^\s]*$/, selected.command + " ");
+                            setInput(newInput);
+                            setCursorPosition(newInput.length);
+                        }
+                        // Reset resource mode
+                        setResourceSuggestions([]);
+                        setSuggestionMode("command");
+                    }
+                    else {
+                        // Command suggestion - replace entire input
+                        const newInput = selected.command + " ";
+                        setInput(newInput);
+                        setCursorPosition(newInput.length);
+                    }
                     setShowCommandSuggestions(false);
                     setSelectedCommandIndex(0);
                     return true;
@@ -132,6 +162,41 @@ onLargePaste, onPasteTruncated, onKeyboardHelp, onThinkingModeChange, onEditorOp
         }
     };
     const handleInputChange = useCallback((newInput) => {
+        // Check for @mcp: resource auto-complete
+        const mcpMatch = newInput.match(/@mcp:([^\s]*)$/);
+        if (mcpMatch) {
+            const query = mcpMatch[1].toLowerCase();
+            // BUG FIX: Track current query to prevent race condition
+            // If user types faster than async completes, stale results are discarded
+            currentMcpQueryRef.current = query;
+            // Load resources asynchronously
+            getMCPResources().then((resources) => {
+                // BUG FIX: Only apply results if query hasn't changed (prevents stale suggestions)
+                if (currentMcpQueryRef.current !== query) {
+                    return; // Query changed, discard stale results
+                }
+                const filtered = resources.filter((r) => r.reference.toLowerCase().includes(query) ||
+                    r.name.toLowerCase().includes(query) ||
+                    (r.description && r.description.toLowerCase().includes(query)));
+                setResourceSuggestions(filtered);
+                setSuggestionMode("resource");
+                setShowCommandSuggestions(true);
+                setSelectedCommandIndex(0);
+            }).catch(() => {
+                // Only clear if this is still the current query
+                if (currentMcpQueryRef.current === query) {
+                    setResourceSuggestions([]);
+                }
+            });
+            return;
+        }
+        // Reset resource mode if it was active but no longer matches
+        // BUG FIX: Also clear the query ref when leaving resource mode
+        if (suggestionMode === "resource") {
+            currentMcpQueryRef.current = null;
+            setResourceSuggestions([]);
+            setSuggestionMode("command");
+        }
         // Update command suggestions based on input
         if (newInput.startsWith("/")) {
             setShowCommandSuggestions(true);
@@ -141,7 +206,7 @@ onLargePaste, onPasteTruncated, onKeyboardHelp, onThinkingModeChange, onEditorOp
             setShowCommandSuggestions(false);
             setSelectedCommandIndex(0);
         }
-    }, []);
+    }, [suggestionMode]);
     const handleVerboseToggle = useCallback(() => {
         // Cycle through verbosity levels: QUIET -> CONCISE -> VERBOSE -> QUIET
         setVerbosityLevel((prev) => {
@@ -265,6 +330,8 @@ onLargePaste, onPasteTruncated, onKeyboardHelp, onThinkingModeChange, onEditorOp
             { command: "/init", description: "Initialize project with smart analysis" },
             { command: "/usage", description: "Show API usage statistics" },
             { command: "/doctor", description: "Run health check diagnostics" },
+            { command: "/mcp", description: "Open MCP server dashboard" },
+            { command: "/permissions", description: "View/manage tool permissions" },
             { command: "/tasks", description: "List background tasks" },
             { command: "/task", description: "View output of a background task" },
             { command: "/kill", description: "Kill a background task" },
@@ -291,7 +358,13 @@ onLargePaste, onPasteTruncated, onKeyboardHelp, onThinkingModeChange, onEditorOp
             command: `/${cmd.name}`,
             description: `${cmd.description} [${cmd.scope}]`,
         }));
-        return [...builtIn, ...customSuggestions];
+        // Add MCP prompts as slash commands
+        const mcpPrompts = getMCPPrompts();
+        const mcpPromptSuggestions = mcpPrompts.map((prompt) => ({
+            command: promptToSlashCommand(prompt),
+            description: getPromptDescription(prompt),
+        }));
+        return [...builtIn, ...customSuggestions, ...mcpPromptSuggestions];
     }, [customCommandsManager]);
     // Load models from configuration with fallback to defaults
     const availableModels = useMemo(() => {
@@ -626,6 +699,7 @@ Built-in Commands:
   /shortcuts  - Show keyboard shortcuts guide
   /usage      - Show API usage statistics
   /doctor     - Run health check diagnostics
+  /mcp        - Open MCP server dashboard
   /exit       - Exit application
   exit, quit  - Exit application
 
@@ -819,6 +893,193 @@ Examples:
             clearInput();
             return true;
         }
+        // MCP Dashboard command
+        if (trimmedInput === "/mcp") {
+            if (onMcpDashboardToggle) {
+                onMcpDashboardToggle();
+            }
+            clearInput();
+            return true;
+        }
+        // Permissions management command
+        if (trimmedInput === "/permissions" || trimmedInput.startsWith("/permissions ")) {
+            const args = trimmedInput.replace("/permissions", "").trim();
+            const permManager = getPermissionManager();
+            const config = permManager.getConfig();
+            if (!args || args === "show" || args === "list") {
+                // Show current permissions configuration
+                const permissionLines = [
+                    "**Permission Configuration**\n",
+                    `Default Tier: **${config.permissions.default_tier}**\n`,
+                    "\n**Tool Permissions:**\n",
+                ];
+                const tierEmoji = {
+                    [PermissionTier.AutoApprove]: "✅",
+                    [PermissionTier.Notify]: "🔔",
+                    [PermissionTier.Confirm]: "⚠️",
+                    [PermissionTier.Block]: "🚫",
+                };
+                for (const [tool, toolConfig] of Object.entries(config.permissions.tools)) {
+                    const emoji = tierEmoji[toolConfig.tier] || "❓";
+                    permissionLines.push(`- ${emoji} **${tool}**: ${toolConfig.tier}\n`);
+                }
+                permissionLines.push("\n**Session Settings:**\n");
+                permissionLines.push(`- Allow all bash: ${config.permissions.session_approvals.allow_all_bash ? "Yes" : "No"}\n`);
+                permissionLines.push(`- Trust current directory: ${config.permissions.session_approvals.trust_current_directory ? "Yes" : "No"}\n`);
+                permissionLines.push("\n*Tip: Use `/permissions set <tool> <tier>` to change permissions*\n");
+                permissionLines.push("*Tiers: auto_approve, notify, confirm, block*");
+                const permEntry = {
+                    type: "assistant",
+                    content: permissionLines.join(""),
+                    timestamp: new Date(),
+                };
+                setChatHistory((prev) => [...prev, permEntry]);
+            }
+            else if (args.startsWith("set ")) {
+                // Set permission for a tool
+                const setArgs = args.replace("set ", "").trim().split(/\s+/);
+                if (setArgs.length >= 2) {
+                    const [tool, tier] = setArgs;
+                    const validTiers = ["auto_approve", "notify", "confirm", "block"];
+                    if (!validTiers.includes(tier)) {
+                        const errorEntry = {
+                            type: "assistant",
+                            content: `❌ Invalid tier: "${tier}"\n\nValid tiers are: ${validTiers.join(", ")}`,
+                            timestamp: new Date(),
+                        };
+                        setChatHistory((prev) => [...prev, errorEntry]);
+                    }
+                    else {
+                        // Update the permission
+                        const newTools = { ...config.permissions.tools };
+                        newTools[tool] = { tier: tier };
+                        permManager.updateConfig({ tools: newTools }).then(() => {
+                            const successEntry = {
+                                type: "assistant",
+                                content: `✅ Set **${tool}** permission to **${tier}**`,
+                                timestamp: new Date(),
+                            };
+                            setChatHistory((prev) => [...prev, successEntry]);
+                        }).catch((error) => {
+                            const errorEntry = {
+                                type: "assistant",
+                                content: `❌ Failed to update permission: ${extractErrorMessage(error)}`,
+                                timestamp: new Date(),
+                            };
+                            setChatHistory((prev) => [...prev, errorEntry]);
+                        });
+                    }
+                }
+                else {
+                    const helpEntry = {
+                        type: "assistant",
+                        content: "Usage: `/permissions set <tool> <tier>`\n\nExample: `/permissions set bash confirm`",
+                        timestamp: new Date(),
+                    };
+                    setChatHistory((prev) => [...prev, helpEntry]);
+                }
+            }
+            else if (args === "reset") {
+                // Reset to default permissions
+                permManager.clearSessionApprovals();
+                const resetEntry = {
+                    type: "assistant",
+                    content: "✅ Session permissions cleared. Tool permissions reset to defaults.",
+                    timestamp: new Date(),
+                };
+                setChatHistory((prev) => [...prev, resetEntry]);
+            }
+            else {
+                // Show help
+                const helpEntry = {
+                    type: "assistant",
+                    content: "**Permission Commands:**\n\n" +
+                        "- `/permissions` - Show current permissions\n" +
+                        "- `/permissions set <tool> <tier>` - Set tool permission tier\n" +
+                        "- `/permissions reset` - Reset session approvals\n\n" +
+                        "**Permission Tiers:**\n" +
+                        "- `auto_approve` - Automatically allow (safe operations)\n" +
+                        "- `notify` - Allow with notification\n" +
+                        "- `confirm` - Require user confirmation\n" +
+                        "- `block` - Always block",
+                    timestamp: new Date(),
+                };
+                setChatHistory((prev) => [...prev, helpEntry]);
+            }
+            clearInput();
+            return true;
+        }
+        // MCP Prompt commands (format: /mcp__servername__promptname [args])
+        if (trimmedInput.startsWith("/mcp__")) {
+            const parts = trimmedInput.split(" ");
+            const commandPart = parts[0];
+            const argsPart = parts.slice(1).join(" ");
+            const parsed = parsePromptCommand(commandPart);
+            if (parsed) {
+                const { serverName, promptName } = parsed;
+                // Add user command to chat history
+                const userEntry = {
+                    type: "user",
+                    content: trimmedInput,
+                    timestamp: new Date(),
+                };
+                setChatHistory((prev) => [...prev, userEntry]);
+                // Execute the prompt asynchronously
+                (async () => {
+                    try {
+                        const manager = getMCPManager();
+                        const v2 = manager.getV2Instance();
+                        const { createServerName } = await import("../../mcp/client-v2.js");
+                        const serverNameBranded = createServerName(serverName);
+                        if (!serverNameBranded) {
+                            throw new Error(`Invalid server name: ${serverName}`);
+                        }
+                        // Parse arguments if provided (format: key=value key2=value2)
+                        const promptArgs = {};
+                        if (argsPart) {
+                            const argMatches = argsPart.match(/(\w+)=("[^"]+"|[^\s]+)/g);
+                            if (argMatches) {
+                                for (const match of argMatches) {
+                                    const [key, ...valueParts] = match.split("=");
+                                    let value = valueParts.join("=");
+                                    // Remove quotes if present
+                                    if (value.startsWith('"') && value.endsWith('"')) {
+                                        value = value.slice(1, -1);
+                                    }
+                                    promptArgs[key] = value;
+                                }
+                            }
+                        }
+                        const result = await v2.getPrompt(serverNameBranded, promptName, Object.keys(promptArgs).length > 0 ? promptArgs : undefined);
+                        if (!result.success) {
+                            throw result.error;
+                        }
+                        // Cast to GetPromptResult format for formatPromptResult
+                        const promptResult = result.value;
+                        const formattedContent = formatPromptResult(promptResult);
+                        // Add the prompt result as an assistant message
+                        const promptEntry = {
+                            type: "assistant",
+                            content: `**MCP Prompt: ${serverName}/${promptName}**\n\n${formattedContent}`,
+                            timestamp: new Date(),
+                        };
+                        setChatHistory((prev) => [...prev, promptEntry]);
+                    }
+                    catch (error) {
+                        const errorMessage = extractErrorMessage(error);
+                        // Use assistant type with error content since "error" is not a valid ChatEntry type
+                        const errorEntry = {
+                            type: "assistant",
+                            content: `❌ **Failed to execute MCP prompt:** ${errorMessage}`,
+                            timestamp: new Date(),
+                        };
+                        setChatHistory((prev) => [...prev, errorEntry]);
+                    }
+                })();
+                clearInput();
+                return true;
+            }
+        }
         if (trimmedInput === "/exit") {
             process.exit(0);
             return true;
@@ -1708,6 +1969,8 @@ Respond with ONLY the commit message, no additional text.`;
         showCommandSuggestions,
         selectedCommandIndex,
         commandSuggestions,
+        resourceSuggestions,
+        suggestionMode,
         availableModels,
         agent,
         autoEditEnabled,