signalpilot-ai-internal 0.10.0__py3-none-any.whl → 0.11.24__py3-none-any.whl

signalpilot_ai_internal/file_scanner_service.py

@@ -19,6 +19,7 @@ import pyarrow.dataset as ds
 from openpyxl import load_workbook
 
 from .cache_service import get_cache_service, get_file_scan_cache_manager
+from .log_utils import print
 
 
 class FileScannerService:
@@ -30,7 +31,7 @@ class FileScannerService:
         self._lock = threading.RLock()
         
         # Data file extensions
-        self.DATA_EXTENSIONS = {'.csv', '.json', '.xlsx', '.xls', '.parquet', '.pkl', '.pickle',
+        self.DATA_EXTENSIONS = {'.csv', '.json', '.xlsx', '.xls', '.parquet',
                                '.feather', '.hdf5', '.h5', '.sql', '.db', '.sqlite', '.tsv', '.txt', '.ipynb'}
         
         # Directories to exclude from search
@@ -76,100 +77,6 @@ class FileScannerService:
                 return (printable / len(chunk)) < 0.7
         except (IOError, OSError):
             return True
-    
-    def _generate_pickle_data_preview(self, data: Any, max_items: int = 3, max_chars: int = 1000) -> Tuple[str, bool]:
-        """
-        Generate a content preview for non-DataFrame pickle data.
-        Returns (preview_content, is_truncated)
-        """
-        try:
-            data_type = type(data).__name__
-            
-            if isinstance(data, (list, tuple)):
-                if len(data) == 0:
-                    return f"Empty {data_type}", False
-                
-                preview_items = []
-                for i, item in enumerate(data[:max_items]):
-                    item_str = str(item)
-                    if len(item_str) > 200:
-                        item_str = item_str[:200] + "..."
-                    preview_items.append(f"[{i}]: {item_str}")
-                
-                preview = f"{data_type} with {len(data)} items:\n" + "\n".join(preview_items)
-                is_truncated = len(data) > max_items
-                
-                if len(preview) > max_chars:
-                    preview = preview[:max_chars] + "..."
-                    is_truncated = True
-                    
-                return preview, is_truncated
-                
-            elif isinstance(data, dict):
-                if len(data) == 0:
-                    return f"Empty {data_type}", False
-                
-                preview_items = []
-                for i, (key, value) in enumerate(list(data.items())[:max_items]):
-                    key_str = str(key)
-                    value_str = str(value)
-                    if len(value_str) > 150:
-                        value_str = value_str[:150] + "..."
-                    preview_items.append(f"'{key_str}': {value_str}")
-                
-                preview = f"{data_type} with {len(data)} keys:\n" + "\n".join(preview_items)
-                is_truncated = len(data) > max_items
-                
-                if len(preview) > max_chars:
-                    preview = preview[:max_chars] + "..."
-                    is_truncated = True
-                    
-                return preview, is_truncated
-                
-            elif isinstance(data, np.ndarray):
-                shape_str = str(data.shape)
-                dtype_str = str(data.dtype)
-                
-                if data.size == 0:
-                    return f"Empty numpy array: shape={shape_str}, dtype={dtype_str}", False
-                
-                # Show first few elements
-                flat_data = data.flatten()[:max_items]
-                elements_str = ", ".join([str(x) for x in flat_data])
-                
-                preview = f"numpy.ndarray: shape={shape_str}, dtype={dtype_str}\nFirst elements: [{elements_str}]"
-                is_truncated = data.size > max_items
-                
-                if len(preview) > max_chars:
-                    preview = preview[:max_chars] + "..."
-                    is_truncated = True
-                    
-                return preview, is_truncated
-                
-            elif isinstance(data, str):
-                if len(data) == 0:
-                    return "Empty string", False
-                    
-                preview = f"String ({len(data)} chars): {data[:max_chars]}"
-                is_truncated = len(data) > max_chars
-                return preview, is_truncated
-                
-            elif isinstance(data, (int, float, bool)):
-                return f"{data_type}: {data}", False
-                
-            else:
-                # For other types, try to convert to string
-                data_str = str(data)
-                if len(data_str) > max_chars:
-                    data_str = data_str[:max_chars] + "..."
-                    is_truncated = True
-                else:
-                    is_truncated = False
-                    
-                return f"{data_type}: {data_str}", is_truncated
-                
-        except Exception as e:
-            return f"Error generating preview for {type(data).__name__}: {str(e)}", False
 
     def _parse_json_array_simple(self, filepath: str, max_items: int = 5) -> Tuple[List[Any], bool]:
         """
@@ -613,12 +520,11 @@ class FileScannerService:
             'is_tsv': extension == '.tsv',
             'is_json': extension == '.json',
             'is_parquet': extension == '.parquet',
-            'is_pkl': extension in ['.pkl', '.pickle'],
             'is_xlsx': extension == '.xlsx',
             'is_ipynb': extension == '.ipynb',
             'is_text': extension in ['.txt', '.md', '.py', '.js', '.ts', '.html', '.xml', '.ipynb'],
-            'is_data': extension in ['.csv', '.tsv', '.json', '.jsonl', '.parquet', '.pkl', '.pickle', '.xlsx'],
-            'is_binary': extension in ['.parquet', '.pkl', '.pickle', '.xlsx']  # Will be set later based on actual binary detection
+            'is_data': extension in ['.csv', '.tsv', '.json', '.jsonl', '.parquet', '.xlsx'],
+            'is_binary': extension in ['.parquet', '.xlsx']  # Will be set later based on actual binary detection
         }
         
         try:
@@ -1121,8 +1027,6 @@ class FileScannerService:
                 file_type = 'tsv'
             elif extension == '.parquet':
                 file_type = 'parquet'
-            elif extension in ['.pkl', '.pickle']:
-                file_type = 'pkl'
             elif extension == '.xlsx':
                 file_type = 'xlsx'
             elif extension == '.json' or extension == '.jsonl':
@@ -1174,51 +1078,6 @@ class FileScannerService:
                     except Exception:
                         sheet_names = ['Sheet1']  # Default sheet name
                         total_sheets = 1  # Default to 1 if we can't determine
-                elif file_type == 'pkl':
-                    print(f"Reading pickle file: {abs_path}")
-                    data = pd.read_pickle(abs_path)
-                    print(f"Data: {data}")
-                    if isinstance(data, pd.DataFrame):
-                        print(f"Data is a DataFrame: {data.head(5)}")
-                        df = data.head(5)  # Limit to first 5 rows
-                    else:
-                        # Handle non-DataFrame pickle data
-                        print(f"Data is not a DataFrame: {type(data).__name__}")
-                        
-                        # Get file info
-                        file_info = self._get_file_type_info(str(item), extension)
-                        entry['file_info'] = file_info
-                        
-                        # Check if file is binary (pickle files are always binary)
-                        is_binary = True
-                        file_info['is_binary'] = True
-                        
-                        # Generate content preview for the pickle data
-                        content_preview, is_truncated = self._generate_pickle_data_preview(data)
-                        entry['content_preview'] = content_preview
-                        entry['is_truncated'] = is_truncated
-                        
-                        # Create schema for non-DataFrame pickle data
-                        schema = {
-                            'success': True,
-                            'fileId': abs_path,
-                            'fileName': item.name,
-                            'filePath': abs_path,
-                            'fileType': file_type,
-                            'extractedAt': datetime.now().isoformat(),
-                            'summary': f'Pickle file containing {type(data).__name__}',
-                            'columns': [],
-                            'totalRows': 1 if not hasattr(data, '__len__') else len(data) if hasattr(data, '__len__') else 1,
-                            'totalColumns': 0,
-                            'fileMtime': current_mtime
-                        }
-                        
-                        # Cache the entry
-                        if entry:
-                            entry['schema'] = schema
-                            self.file_scan_cache.set_file_entry(abs_path, entry)
-                        
-                        return schema
                 elif file_type == 'json':
                     # Read and analyze JSON file
                     json_data, file_format, is_truncated = self._read_json_file(abs_path)
@@ -1273,7 +1132,7 @@ class FileScannerService:
 
                     return schema
 
-                # Get file info for DataFrame pickle files and other file types
+                # Get file info for other file types
                 file_info = self._get_file_type_info(str(item), extension)
                 entry['file_info'] = file_info
 

signalpilot_ai_internal/handlers.py

@@ -8,12 +8,42 @@ from jupyter_server.base.handlers import APIHandler
 from jupyter_server.utils import url_path_join
 import tornado
 
+# Import controlled print function
+from .log_utils import print
 from .cache_service import get_cache_service
 from .cache_handlers import ChatHistoriesHandler, AppValuesHandler, CacheInfoHandler
 from .unified_database_schema_service import UnifiedDatabaseSchemaHandler, UnifiedDatabaseQueryHandler
 from .snowflake_schema_service import SnowflakeSchemaHandler, SnowflakeQueryHandler
+from .databricks_schema_service import DatabricksSchemaHandler, DatabricksQueryHandler, DatabricksTestHandler
 from .file_scanner_service import get_file_scanner_service
 from .schema_search_service import SchemaSearchHandler
+from .mcp_handlers import (
+    MCPServersHandler,
+    MCPServerHandler,
+    MCPConnectHandler,
+    MCPDisconnectHandler,
+    MCPToolsHandler,
+    MCPAllToolsHandler,
+    MCPToolCallHandler,
+    MCPServerEnableHandler,
+    MCPServerDisableHandler,
+    MCPToolEnableHandler,
+    MCPConfigFileHandler
+)
+from .composio_handlers import (
+    IntegrationsHandler,
+    IntegrationConnectHandler,
+    IntegrationCompleteHandler,
+    IntegrationStatusHandler,
+    IntegrationDisconnectHandler,
+    IntegrationRefreshHandler,
+)
+from .database_config_handlers import (
+    DatabaseConfigsHandler,
+    DatabaseDefaultsHandler,
+    SignalPilotHomeInfoHandler,
+)
+from .signalpilot_home import get_user_rules_manager
 
 
 class HelloWorldHandler(APIHandler):
@@ -28,11 +58,205 @@ class HelloWorldHandler(APIHandler):
         }))
 
 
+class UserRulesHandler(APIHandler):
+    """Handler for user rules (snippets) stored as markdown files."""
+
+    @tornado.web.authenticated
+    def get(self, rule_id=None):
+        """Get all rules or a specific rule by ID."""
+        try:
+            rules_manager = get_user_rules_manager()
+
+            if not rules_manager.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "User rules service not available",
+                    "message": "Rules directory is not accessible"
+                }))
+                return
+
+            if rule_id:
+                # Get specific rule
+                rule = rules_manager.get_rule(rule_id)
+                if rule is None:
+                    self.set_status(404)
+                    self.finish(json.dumps({
+                        "error": "Rule not found",
+                        "rule_id": rule_id
+                    }))
+                else:
+                    self.finish(json.dumps(rule))
+            else:
+                # Get all rules
+                rules = rules_manager.list_rules()
+                self.finish(json.dumps({
+                    "rules": rules,
+                    "count": len(rules)
+                }))
+
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+
+    @tornado.web.authenticated
+    def post(self, rule_id=None):
+        """Create a new rule or update an existing one."""
+        try:
+            rules_manager = get_user_rules_manager()
+
+            if not rules_manager.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "User rules service not available",
+                    "message": "Rules directory is not accessible"
+                }))
+                return
+
+            # Parse request body
+            try:
+                body = json.loads(self.request.body.decode('utf-8'))
+            except json.JSONDecodeError:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "error": "Invalid JSON in request body"
+                }))
+                return
+
+            if rule_id:
+                # Update existing rule
+                title = body.get('title')
+                content = body.get('content')
+                description = body.get('description')
+
+                result = rules_manager.update_rule(
+                    rule_id=rule_id,
+                    title=title,
+                    content=content,
+                    description=description
+                )
+
+                if result:
+                    self.finish(json.dumps({
+                        "success": True,
+                        "rule": result,
+                        "message": "Rule updated successfully"
+                    }))
+                else:
+                    self.set_status(404)
+                    self.finish(json.dumps({
+                        "error": "Rule not found",
+                        "rule_id": rule_id
+                    }))
+            else:
+                # Create new rule
+                title = body.get('title')
+                content = body.get('content', '')
+                description = body.get('description', '')
+                provided_id = body.get('id')
+
+                if not title:
+                    self.set_status(400)
+                    self.finish(json.dumps({
+                        "error": "Missing required field: title"
+                    }))
+                    return
+
+                result = rules_manager.create_rule(
+                    title=title,
+                    content=content,
+                    description=description,
+                    rule_id=provided_id
+                )
+
+                if result:
+                    self.set_status(201)
+                    self.finish(json.dumps({
+                        "success": True,
+                        "rule": result,
+                        "message": "Rule created successfully"
+                    }))
+                else:
+                    self.set_status(500)
+                    self.finish(json.dumps({
+                        "error": "Failed to create rule"
+                    }))
+
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+
+    @tornado.web.authenticated
+    def delete(self, rule_id=None):
+        """Delete a rule by ID."""
+        try:
+            rules_manager = get_user_rules_manager()
+
+            if not rules_manager.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "User rules service not available",
+                    "message": "Rules directory is not accessible"
+                }))
+                return
+
+            if not rule_id:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "error": "Rule ID is required for deletion"
+                }))
+                return
+
+            success = rules_manager.delete_rule(rule_id)
+
+            if success:
+                self.finish(json.dumps({
+                    "success": True,
+                    "message": f"Rule '{rule_id}' deleted successfully"
+                }))
+            else:
+                self.set_status(404)
+                self.finish(json.dumps({
+                    "error": "Rule not found",
+                    "rule_id": rule_id
+                }))
+
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+
+
+class UserRulesInfoHandler(APIHandler):
+    """Handler for user rules service information."""
+
+    @tornado.web.authenticated
+    def get(self):
+        """Get user rules service information."""
+        try:
+            rules_manager = get_user_rules_manager()
+            info = rules_manager.get_info()
+            self.finish(json.dumps(info))
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+
+
 class ReadAllFilesHandler(APIHandler):
     """Handler for reading all notebook and data files in the workspace"""
     
     # Common data file extensions
-    DATA_EXTENSIONS = {'.csv', '.json', '.xlsx', '.xls', '.parquet', '.pkl', '.pickle', 
+    DATA_EXTENSIONS = {'.csv', '.json', '.xlsx', '.xls', '.parquet',
                        '.feather', '.hdf5', '.h5', '.sql', '.db', '.sqlite', '.tsv', '.txt'}
     
     # Directories to exclude from search
@@ -178,9 +402,9 @@ class ReadAllFilesHandler(APIHandler):
         # Search for data file references
         # Common patterns: pd.read_csv('file.csv'), open('file.csv'), 'path/to/file.csv'
         patterns = [
-            r'["\']([^"\']+\.(?:csv|json|xlsx?|parquet|pkl|pickle|feather|hdf5|h5|sql|db|sqlite|tsv|txt))["\']',
-            r'read_(?:csv|json|excel|parquet|pickle|feather|hdf|sql|table)\(["\']([^"\']+)["\']',
-            r'to_(?:csv|json|excel|parquet|pickle|feather|hdf|sql)\(["\']([^"\']+)["\']',
+            r'["\']([^"\']+\.(?:csv|json|xlsx?|parquet|feather|hdf5|h5|sql|db|sqlite|tsv|txt))["\']',
+            r'read_(?:csv|json|excel|parquet|feather|hdf|sql|table)\(["\']([^"\']+)["\']',
+            r'to_(?:csv|json|excel|parquet|feather|hdf|sql)\(["\']([^"\']+)["\']',
         ]
         
         found_references = set()
@@ -437,18 +661,72 @@ class ScannedDirectoriesHandler(APIHandler):
 
 
 class WorkDirHandler(APIHandler):
-    """Handler for returning current working directory"""
+    """Handler for returning current working directory and setup manager type"""
 
     @tornado.web.authenticated
     def get(self):
         try:
-            self.finish(json.dumps({"workdir": os.getcwd()}))
+            # Detect the setup manager type
+            setup_manager = self._detect_setup_manager()
+
+            self.finish(json.dumps({
+                "workdir": os.getcwd(),
+                "setupManager": setup_manager
+            }))
         except Exception as e:
             self.set_status(500)
             self.finish(json.dumps({
                 "error": str(e)
             }))
 
+    def _detect_setup_manager(self) -> str:
+        """
+        Detect the Python environment manager being used.
+        Returns: 'conda', 'venv', 'uv', or 'system'
+        """
+        env_type, _ = self._detect_kernel_env()
+        return env_type
+
+    def _detect_kernel_env(self):
+        """
+        Detect the actual environment running this kernel,
+        not what shell env vars claim.
+        """
+        import sys
+
+        prefix = Path(sys.prefix)
+        executable = Path(sys.executable)
+
+        # Check pyvenv.cfg first — exists for venv/uv, not conda
+        pyvenv_cfg = prefix / 'pyvenv.cfg'
+        if pyvenv_cfg.exists():
+            try:
+                content = pyvenv_cfg.read_text().lower()
+                if 'uv' in content:
+                    return 'uv', str(prefix)
+                return 'venv', str(prefix)
+            except (IOError, OSError):
+                return 'venv', str(prefix)
+
+        # No pyvenv.cfg — check if we're in a conda env
+        # Conda envs live under <conda_root>/envs/<name>/ or are the base env
+        # Key marker: conda-meta directory exists
+        conda_meta = prefix / 'conda-meta'
+        if conda_meta.exists():
+            # Extract env name from path
+            if 'envs' in prefix.parts:
+                idx = prefix.parts.index('envs')
+                env_name = prefix.parts[idx + 1] if len(prefix.parts) > idx + 1 else 'base'
+            else:
+                env_name = 'base'
+            return 'conda', env_name
+
+        # Fallback: check if prefix differs from base (generic venv)
+        if sys.prefix != sys.base_prefix:
+            return 'venv', str(prefix)
+
+        return 'system', str(prefix)
+
 
 class TerminalExecuteHandler(APIHandler):
     """Handler for executing terminal commands"""
@@ -476,9 +754,15 @@ class TerminalExecuteHandler(APIHandler):
                 timeout=300
             )
 
-            def truncate_output(output: str, max_lines: int = 50) -> str:
+            def truncate_output(output: str, max_lines: int = 50, max_chars: int = 20000) -> str:
                 if not output:
                     return output
+                # First, truncate by character limit
+                if len(output) > max_chars:
+                    half = max_chars // 2
+                    truncated_chars = len(output) - max_chars
+                    output = output[:half] + f'\n... {truncated_chars} characters truncated ...\n' + output[-half:]
+                # Then, truncate by line count
                 lines = output.splitlines()
                 if len(lines) <= max_lines * 2:
                     return output
@@ -741,12 +1025,49 @@ def setup_handlers(web_app):
     # Snowflake service endpoints
     snowflake_schema_route = url_path_join(base_url, "signalpilot-ai-internal", "snowflake", "schema")
     snowflake_query_route = url_path_join(base_url, "signalpilot-ai-internal", "snowflake", "query")
-    
+
+    # Databricks service endpoints
+    databricks_schema_route = url_path_join(base_url, "signalpilot-ai-internal", "databricks", "schema")
+    databricks_query_route = url_path_join(base_url, "signalpilot-ai-internal", "databricks", "query")
+    databricks_test_route = url_path_join(base_url, "signalpilot-ai-internal", "databricks", "test")
+
     # Notebook HTML export endpoint
     notebook_html_route = url_path_join(base_url, "signalpilot-ai-internal", "notebook", "to-html")
 
     # Terminal endpoint
     terminal_execute_route = url_path_join(base_url, "signalpilot-ai-internal", "terminal", "execute")
+    
+    # MCP service endpoints
+    mcp_servers_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "servers")
+    mcp_server_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "servers", "([^/]+)")
+    mcp_connect_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "connect")
+    mcp_disconnect_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "servers", "([^/]+)", "disconnect")
+    mcp_tools_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "servers", "([^/]+)", "tools")
+    mcp_all_tools_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "tools")
+    mcp_tool_call_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "call-tool")
+    mcp_tool_enable_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "servers", "([^/]+)", "tools", "([^/]+)")
+    mcp_server_enable_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "servers", "([^/]+)", "enable")
+    mcp_server_disable_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "servers", "([^/]+)", "disable")
+    mcp_config_file_route = url_path_join(base_url, "signalpilot-ai-internal", "mcp", "config-file")
+
+    # Composio integration endpoints
+    integrations_route = url_path_join(base_url, "signalpilot-ai-internal", "integrations")
+    integration_connect_route = url_path_join(base_url, "signalpilot-ai-internal", "integrations", "([^/]+)", "connect")
+    integration_complete_route = url_path_join(base_url, "signalpilot-ai-internal", "integrations", "([^/]+)", "complete")
+    integration_status_route = url_path_join(base_url, "signalpilot-ai-internal", "integrations", "([^/]+)", "status")
+    integration_refresh_route = url_path_join(base_url, "signalpilot-ai-internal", "integrations", "([^/]+)", "refresh")
+    integration_disconnect_route = url_path_join(base_url, "signalpilot-ai-internal", "integrations", "([^/]+)")
+
+    # Database config endpoints (db.toml)
+    db_configs_route = url_path_join(base_url, "signalpilot-ai-internal", "db-configs")
+    db_configs_type_route = url_path_join(base_url, "signalpilot-ai-internal", "db-configs", "([^/]+)")
+    db_defaults_route = url_path_join(base_url, "signalpilot-ai-internal", "db-defaults")
+    signalpilot_home_info_route = url_path_join(base_url, "signalpilot-ai-internal", "home-info")
+
+    # User rules endpoints (markdown files in user-rules/)
+    user_rules_route = url_path_join(base_url, "signalpilot-ai-internal", "rules")
+    user_rule_route = url_path_join(base_url, "signalpilot-ai-internal", "rules", "([^/]+)")
+    user_rules_info_route = url_path_join(base_url, "signalpilot-ai-internal", "rules-info")
 
     handlers = [
         # Original endpoint
@@ -791,9 +1112,48 @@ def setup_handlers(web_app):
         # Snowflake service endpoints
         (snowflake_schema_route, SnowflakeSchemaHandler),
         (snowflake_query_route, SnowflakeQueryHandler),
-        
+
+        # Databricks service endpoints
+        (databricks_schema_route, DatabricksSchemaHandler),
+        (databricks_query_route, DatabricksQueryHandler),
+        (databricks_test_route, DatabricksTestHandler),
+
         # Notebook HTML export endpoint
         (notebook_html_route, NotebookToHTMLHandler),
+        
+        # MCP service endpoints
+        # Note: More specific routes should come before parameterized routes
+        (mcp_config_file_route, MCPConfigFileHandler),
+        (mcp_servers_route, MCPServersHandler),
+        (mcp_server_route, MCPServerHandler),
+        (mcp_connect_route, MCPConnectHandler),
+        (mcp_disconnect_route, MCPDisconnectHandler),
+        (mcp_tools_route, MCPToolsHandler),
+        (mcp_all_tools_route, MCPAllToolsHandler),
+        (mcp_tool_call_route, MCPToolCallHandler),
+        (mcp_tool_enable_route, MCPToolEnableHandler),
+        (mcp_server_enable_route, MCPServerEnableHandler),
+        (mcp_server_disable_route, MCPServerDisableHandler),
+
+        # Composio integration endpoints
+        # Note: More specific routes should come before parameterized routes
+        (integrations_route, IntegrationsHandler),
+        (integration_connect_route, IntegrationConnectHandler),
+        (integration_complete_route, IntegrationCompleteHandler),
+        (integration_status_route, IntegrationStatusHandler),
+        (integration_refresh_route, IntegrationRefreshHandler),
+        (integration_disconnect_route, IntegrationDisconnectHandler),
+
+        # Database config endpoints (db.toml in cache_dir/connect/)
+        (db_configs_route, DatabaseConfigsHandler),
+        (db_configs_type_route, DatabaseConfigsHandler),
+        (db_defaults_route, DatabaseDefaultsHandler),
+        (signalpilot_home_info_route, SignalPilotHomeInfoHandler),
+
+        # User rules endpoints (markdown files in user-rules/)
+        (user_rules_route, UserRulesHandler),
+        (user_rule_route, UserRulesHandler),
+        (user_rules_info_route, UserRulesInfoHandler),
     ]
     
     web_app.add_handlers(host_pattern, handlers)
@@ -806,6 +1166,18 @@ def setup_handlers(web_app):
     else:
         print("WARNING: SignalPilot AI cache service failed to initialize!")
     
+    # Register cleanup handler for MCP servers on shutdown
+    from .mcp_server_manager import get_mcp_server_manager
+    
+    def cleanup_mcp_servers():
+        """Stop all MCP servers on shutdown"""
+        manager = get_mcp_server_manager()
+        manager.stop_all_servers()
+    
+    # Register cleanup with web app
+    import atexit
+    atexit.register(cleanup_mcp_servers)
+
     print("SignalPilot AI backend handlers registered:")
     print(f"  - Hello World: {hello_route}")
     print(f"  - Read All Files: {read_all_files_route}")
@@ -821,5 +1193,12 @@ def setup_handlers(web_app):
     print(f"  - MySQL Query: {mysql_query_route}")
     print(f"  - Snowflake Schema: {snowflake_schema_route}")
     print(f"  - Snowflake Query: {snowflake_query_route}")
+    print(f"  - Databricks Schema: {databricks_schema_route}")
+    print(f"  - Databricks Query: {databricks_query_route}")
+    print(f"  - Databricks Test: {databricks_test_route}")
     print(f"  - Notebook Cells: {notebook_cells_route}")
     print(f"  - Notebook to HTML: {notebook_html_route}")
+    print(f"  - MCP Servers: {mcp_servers_route}")
+    print(f"  - MCP Connect: {mcp_connect_route}")
+    print(f"  - MCP Tools: {mcp_all_tools_route}")
+    print(f"  - MCP Tool Call: {mcp_tool_call_route}")