Implement agent and MCP configuration endpoints, enhance install script with environment variable extraction, and update workspace actions for agent and MCP installation.

NicolasIRAGNE · NicolasIRAGNE · commit f81b149729f4 · 2025-08-21T16:35:34.000+02:00
diff --git a/app/routes/actions.py b/app/routes/actions.py
@@ -1,7 +1,8 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, HTTPException, Body
 from app.models.actions import ActionsResponse, Agent, Rule, MCP
 from app.services.actions_loader import actions_loader
-from typing import List
+from app.services.mcp_installer import get_agent_content, create_mcp_config
+from typing import List, Dict, Any
 
 router = APIRouter(prefix="/api/actions", tags=["actions"])
 
@@ -27,4 +28,41 @@ async def get_rules():
 @router.get("/mcps", response_model=List[MCP])
 async def get_mcps():
     """Get all available MCPs"""
-    return actions_loader.get_mcps()
+    return actions_loader.get_mcps()
+
+@router.get("/agent-content/{agent_name}")
+async def get_agent_content_endpoint(agent_name: str):
+    """Get agent content for virtual workspace"""
+    agents = actions_loader.get_agents()
+    agent = next((a for a in agents if a.name == agent_name), None)
+    
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    content = get_agent_content(agent.filename)
+    if not content:
+        raise HTTPException(status_code=500, detail="Failed to read agent file")
+    
+    return {
+        "filename": agent.filename,
+        "content": content,
+        "path": f".claude/agents/{agent.filename}"
+    }
+
+@router.post("/mcp-config/{mcp_name}")
+async def get_mcp_config_endpoint(mcp_name: str, current_config: Dict[str, Any] = Body(default={})):
+    """Get updated MCP config for virtual workspace"""
+    mcps = actions_loader.get_mcps()
+    mcp = next((m for m in mcps if m.name == mcp_name), None)
+    
+    if not mcp:
+        raise HTTPException(status_code=404, detail="MCP not found")
+    
+    updated_config, was_removed = create_mcp_config(current_config, mcp.name, mcp.config)
+    
+    return {
+        "filename": ".mcp.json",
+        "content": updated_config,
+        "path": ".mcp.json",
+        "was_removed": was_removed
+    }
diff --git a/app/routes/install.py b/app/routes/install.py
@@ -3,7 +3,8 @@
 from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel
 import hashlib
-from typing import Dict
+import re
+from typing import Dict, Set
 from datetime import datetime
 
 router = APIRouter()
@@ -15,6 +16,15 @@
 class InstallCreate(BaseModel):
     files: Dict[str, str]
 
+def extract_env_vars_from_files(files: Dict[str, str]) -> Set[str]:
+    """Extract environment variables from file contents"""
+    env_vars = set()
+    for content in files.values():
+        # Find ${VAR_NAME} patterns
+        matches = re.findall(r'\$\{([^}]+)\}', content)
+        env_vars.update(matches)
+    return env_vars
+
 @router.post("/api/install")
 async def create_install(request: Request, install: InstallCreate):
     """Generate install script from files and store by hash"""
@@ -26,11 +36,15 @@ async def create_install(request: Request, install: InstallCreate):
             for i in range(1, len(parts)):
                 directories.add('/'.join(parts[:i]))
     
+    # Extract environment variables from all files
+    env_vars = extract_env_vars_from_files(install.files)
+    
     # Generate script using Jinja2 template
     script_content = templates.get_template("install.sh.j2").render(
         timestamp=datetime.now().isoformat(),
         files=install.files,
-        directories=sorted(directories)
+        directories=sorted(directories),
+        env_vars=sorted(env_vars) if env_vars else None
     )
     
     # Hash the script content
diff --git a/app/services/mcp_installer.py b/app/services/mcp_installer.py
@@ -0,0 +1,53 @@
+import json
+import re
+from pathlib import Path
+from typing import Dict, Any, Set, Tuple
+
+def get_agent_content(agent_filename: str) -> str:
+    """Get agent content from actions/agents directory"""
+    source_path = Path(__file__).parent.parent / "actions" / "agents" / agent_filename
+    if source_path.exists():
+        with open(source_path, 'r') as f:
+            return f.read()
+    return ""
+
+def get_current_mcp_config() -> Dict[str, Any]:
+    """Get current .mcp.json config from virtual workspace or create new"""
+    # This would be called from frontend with workspace content
+    # For now, return default structure
+    return {"mcpServers": {}}
+
+def create_mcp_config(existing_config: Dict[str, Any], mcp_name: str, mcp_config: Dict[str, Any]) -> Tuple[str, bool]:
+    """Create updated .mcp.json content, returns (content, was_removed)"""
+    if not isinstance(existing_config, dict) or "mcpServers" not in existing_config:
+        config = {"mcpServers": {}}
+    else:
+        config = existing_config.copy()
+    
+    # Toggle behavior: if exists, remove it; if not, add it
+    was_removed = False
+    if mcp_name in config["mcpServers"]:
+        del config["mcpServers"][mcp_name]
+        was_removed = True
+    else:
+        config["mcpServers"][mcp_name] = mcp_config
+    
+    return json.dumps(config, indent=2), was_removed
+
+def extract_env_vars_from_config(config: Dict[str, Any]) -> Set[str]:
+    """Extract environment variable names from MCP config"""
+    env_vars = set()
+    
+    def find_env_vars(obj):
+        if isinstance(obj, str):
+            matches = re.findall(r'\$\{([^}]+)\}', obj)
+            env_vars.update(matches)
+        elif isinstance(obj, dict):
+            for value in obj.values():
+                find_env_vars(value)
+        elif isinstance(obj, list):
+            for item in obj:
+                find_env_vars(item)
+    
+    find_env_vars(config)
+    return env_vars
diff --git a/app/static/js/auto_share.js b/app/static/js/auto_share.js
@@ -145,7 +145,13 @@ class AutoShareManager {
     collectWorkspaceData() {
         const allFiles = {};
         
-        // Helper function to collect files from tree structure
+        // Get files directly from workspace manager state
+        const state = window.workspaceManager?.getState();
+        if (state?.files) {
+            return { ...state.files };
+        }
+        
+        // Fallback: collect files from tree structure
         function collectFilesFromTree(nodes, collected) {
             nodes.forEach(node => {
                 if (node.type === 'file') {
@@ -159,7 +165,7 @@ class AutoShareManager {
             });
         }
         
-        // Collect files from dynamic tree
+        // Collect files from dynamic tree if available
         if (window.generateFileTreeData) {
             const fileTreeData = window.generateFileTreeData();
             collectFilesFromTree(fileTreeData, allFiles);
diff --git a/app/templates/components/quick_actions.html b/app/templates/components/quick_actions.html
@@ -206,27 +206,63 @@ <h3 class="text-sm font-black text-black mb-2 flex items-center gap-1">
     createNewContextFromScratch();
 }
 
-// Create a new context and apply a template to it
-function createNewContextAndApplyTemplate(templateName) {
+
+// Create a new empty context from scratch
+function createNewContextFromScratch() {
+    if (!window.workspaceManager) {
+        console.error('WorkspaceManager not available');
+        return;
+    }
+    
+    // Generate unique context ID
+    const timestamp = Date.now();
+    const contextId = `scratch-${timestamp}`;
+    const contextName = `From Scratch - ${new Date().toLocaleString()}`;
+    
+    // Create new context
+    if (workspaceManager.createContext(contextId, contextName)) {
+        // Switch to new context (it will be empty by default)
+        workspaceManager.switchContext(contextId);
+        
+        // Show workspace
+        showWorkspace();
+    } else {
+        console.error('Failed to create new context');
+    }
+}
+
+// Action functions that use backend data
+function addAgent(name) {
+    createNewContextAndInstallAgent(name);
+}
+
+function addRule(name) {
+    createNewContextAndInsertRule(name);
+}
+
+function addMCP(name) {
+    createNewContextAndInstallMCP(name);
+}
+
+// New context creation functions that use the same API as workspace
+function createNewContextAndInstallAgent(agentName) {
     if (!window.workspaceManager) {
         console.error('WorkspaceManager not available');
         return;
     }
     
     // Generate unique context ID
     const timestamp = Date.now();
-    const contextId = `context-${timestamp}`;
-    const contextName = `${templateName} - ${new Date().toLocaleString()}`;
+    const contextId = `agent-${timestamp}`;
+    const contextName = `${agentName} - ${new Date().toLocaleString()}`;
     
     // Create new context
     if (workspaceManager.createContext(contextId, contextName)) {
         // Switch to new context
         workspaceManager.switchContext(contextId);
         
-        // Apply template to new context
-        if (window.includeTemplate) {
-            window.includeTemplate(templateName);
-        }
+        // Install agent using the same function as workspace sidebar
+        installAgentInContext(agentName);
         
         // Show workspace
         showWorkspace();
@@ -235,41 +271,134 @@ <h3 class="text-sm font-black text-black mb-2 flex items-center gap-1">
     }
 }
 
-// Create a new empty context from scratch
-function createNewContextFromScratch() {
+function createNewContextAndInstallMCP(mcpName) {
     if (!window.workspaceManager) {
         console.error('WorkspaceManager not available');
         return;
     }
     
     // Generate unique context ID
     const timestamp = Date.now();
-    const contextId = `scratch-${timestamp}`;
-    const contextName = `From Scratch - ${new Date().toLocaleString()}`;
+    const contextId = `mcp-${timestamp}`;
+    const contextName = `${mcpName} - ${new Date().toLocaleString()}`;
     
     // Create new context
     if (workspaceManager.createContext(contextId, contextName)) {
-        // Switch to new context (it will be empty by default)
+        // Switch to new context
         workspaceManager.switchContext(contextId);
         
+        // Install MCP using the same function as workspace sidebar
+        installMCPInContext(mcpName);
+        
         // Show workspace
         showWorkspace();
     } else {
         console.error('Failed to create new context');
     }
 }
 
-// Action functions that use backend data
-function addAgent(name) {
-    createNewContextAndApplyTemplate(name);
+function createNewContextAndInsertRule(ruleName) {
+    if (!window.workspaceManager) {
+        console.error('WorkspaceManager not available');
+        return;
+    }
+    
+    // Generate unique context ID
+    const timestamp = Date.now();
+    const contextId = `rule-${timestamp}`;
+    const contextName = `${ruleName} - ${new Date().toLocaleString()}`;
+    
+    // Create new context
+    if (workspaceManager.createContext(contextId, contextName)) {
+        // Switch to new context
+        workspaceManager.switchContext(contextId);
+        
+        // Insert rule text directly into editor
+        insertRuleInContext(ruleName);
+        
+        // Show workspace
+        showWorkspace();
+    } else {
+        console.error('Failed to create new context');
+    }
 }
 
-function addRule(name) {
-    createNewContextAndApplyTemplate(name);
+// Helper functions that use the same API as workspace sidebar
+async function installAgentInContext(agentName) {
+    try {
+        const response = await fetch(`/api/actions/agent-content/${encodeURIComponent(agentName)}`);
+        
+        if (response.ok) {
+            const result = await response.json();
+            
+            // Add to virtual workspace
+            if (window.workspaceManager && window.workspaceManager.currentState) {
+                window.workspaceManager.currentState.addFile(result.path, result.content);
+                window.workspaceManager.saveState(window.workspaceManager.currentContextId);
+                window.workspaceManager.render();
+            }
+        } else {
+            const error = await response.json();
+            console.error(`Error: ${error.detail}`);
+        }
+    } catch (error) {
+        console.error(`Error installing agent: ${error.message}`);
+    }
 }
 
-function addMCP(name) {
-    createNewContextAndApplyTemplate(name + ' MCP');
+async function installMCPInContext(mcpName) {
+    try {
+        // Get current .mcp.json content from workspace
+        let currentConfig = {};
+        if (window.workspaceManager && window.workspaceManager.getState()) {
+            const mcpFile = window.workspaceManager.getState().files['.mcp.json'];
+            if (mcpFile) {
+                try {
+                    currentConfig = JSON.parse(mcpFile);
+                } catch (e) {
+                    currentConfig = {};
+                }
+            }
+        }
+        
+        const response = await fetch(`/api/actions/mcp-config/${encodeURIComponent(mcpName)}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(currentConfig)
+        });
+        
+        if (response.ok) {
+            const result = await response.json();
+            
+            // Add to virtual workspace
+            if (window.workspaceManager && window.workspaceManager.currentState) {
+                window.workspaceManager.currentState.addFile(result.path, result.content);
+                window.workspaceManager.saveState(window.workspaceManager.currentContextId);
+                window.workspaceManager.render();
+            }
+        } else {
+            const error = await response.json();
+            console.error(`Error: ${error.detail}`);
+        }
+    } catch (error) {
+        console.error(`Error installing MCP: ${error.message}`);
+    }
+}
+
+function insertRuleInContext(ruleName) {
+    // For rules, we just insert the text directly into the editor
+    // This matches the workspace sidebar behavior for rules
+    setTimeout(() => {
+        if (window.insertTextAtCursor) {
+            window.insertTextAtCursor(ruleName);
+        } else if (window.workspaceMonacoEditor) {
+            // Fallback: set editor value directly
+            window.workspaceMonacoEditor.setValue(ruleName);
+            window.workspaceMonacoEditor.focus();
+        }
+    }, 100);
 }
 
 // Show workspace with fade transition
diff --git a/app/templates/components/workspace_actions.html b/app/templates/components/workspace_actions.html
diff --git a/app/templates/install.sh.j2 b/app/templates/install.sh.j2
