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

signalpilot_ai_internal/__init__.py

@@ -8,6 +8,7 @@ except ImportError:
     warnings.warn("Importing 'signalpilot_ai_internal' outside a proper installation.")
     __version__ = "dev"
 from .handlers import setup_handlers
+from .mcp_server_manager import autostart_mcp_servers
 
 
 def _jupyter_labextension_paths():

signalpilot_ai_internal/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '0.10.0'
+__version__ = VERSION = '0.11.24'

signalpilot_ai_internal/cache_service.py

@@ -15,6 +15,9 @@ import uuid
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+# Import controlled print function
+from .log_utils import print
+
 
 class CacheDirectoryManager:
     """OS-specific cache directory management with fallbacks"""
@@ -75,7 +78,7 @@ class CacheDirectoryManager:
             directories.append(Path(tempfile.gettempdir()) / f"signalpilot-ai-internal-{os.getuid() if hasattr(os, 'getuid') else 'user'}")
             
         except Exception as e:
-            print(f"Error determining cache directories: {e}")
+            print(f"ERROR: determining cache directories: {e}")
             # Emergency fallback
             directories.append(Path(tempfile.gettempdir()) / "signalpilot-ai-internal-emergency")
         
@@ -93,7 +96,7 @@ class CacheDirectoryManager:
                 test_file = cache_dir / f"test_write_{uuid.uuid4().hex[:8]}.tmp"
                 test_file.write_text("test")
                 test_file.unlink()
-                
+
                 print(f"Using cache directory: {cache_dir}")
                 return cache_dir
                 
@@ -111,14 +114,13 @@ class RobustFileOperations:
     @staticmethod
     def safe_write_json(file_path: Path, data: Any, max_retries: int = 3) -> bool:
         """Safely write JSON data with atomic operations and backups"""
-        # print(f"Attempting to write JSON to: {file_path}")
         
         if not file_path.parent.exists():
             try:
                 print(f"Creating parent directory: {file_path.parent}")
                 file_path.parent.mkdir(parents=True, exist_ok=True)
             except Exception as e:
-                print(f"Failed to create directory {file_path.parent}: {e}")
+                print(f"ERROR: Failed to create directory {file_path.parent}: {e}")
                 return False
         
         # Create backup if file exists and is valid, but only if last backup is older than 1 hour
@@ -135,7 +137,6 @@ class RobustFileOperations:
                 if should_create_backup:
                     backup_path = file_path.with_suffix(f".backup.{int(time.time())}")
                     shutil.copy2(file_path, backup_path)
-                    print(f"Created backup: {backup_path}")
                     
                     # Keep only the most recent backup that's at least 1 hour old
                     RobustFileOperations._cleanup_backups(file_path)
@@ -183,7 +184,7 @@ class RobustFileOperations:
                             shutil.copy2(backup_path, file_path)
                             print(f"Restored {file_path} from backup")
                         except Exception as restore_error:
-                            print(f"Failed to restore backup: {restore_error}")
+                            print(f"ERROR: Failed to restore backup: {restore_error}")
                     
                     return False
                 
@@ -203,7 +204,7 @@ class RobustFileOperations:
             with open(file_path, 'r', encoding='utf-8') as f:
                 return json.load(f)
         except Exception as e:
-            print(f"Failed to read {file_path}: {e}")
+            print(f"ERROR: Failed to read {file_path}: {e}")
             
             # Try to recover from backup
             backup_files = sorted(
@@ -224,7 +225,7 @@ class RobustFileOperations:
                         shutil.copy2(backup_path, file_path)
                         print(f"Restored {file_path} from {backup_path}")
                     except Exception as restore_error:
-                        print(f"Could not restore main file: {restore_error}")
+                        print(f"ERROR: Could not restore main file: {restore_error}")
                     
                     return data
                     
@@ -254,7 +255,7 @@ class RobustFileOperations:
             return backup_age > 3600  # 3600 seconds = 1 hour
             
         except Exception as e:
-            print(f"Error checking backup age: {e}")
+            print(f"ERROR: checking backup age: {e}")
             return True  # If we can't check, err on the side of creating a backup
     
     @staticmethod
@@ -273,10 +274,10 @@ class RobustFileOperations:
                     old_backup.unlink()
                     print(f"Cleaned up old backup: {old_backup}")
                 except Exception as cleanup_error:
-                    print(f"Failed to cleanup backup {old_backup}: {cleanup_error}")
+                    print(f"ERROR: Failed to cleanup backup {old_backup}: {cleanup_error}")
                     
         except Exception as e:
-            print(f"Error cleaning up backups: {e}")
+            print(f"ERROR: cleaning up backups: {e}")
 
 
 class PersistentCacheService:
@@ -404,21 +405,21 @@ class PersistentCacheService:
             if not self.chat_histories_file:
                 print(f"ERROR: Cannot save chat history for {chat_id} - no chat histories file configured")
                 return False
-            
+
             try:
                 print(f"Attempting to save chat history for chat_id: {chat_id}")
                 histories = self.get_chat_histories()
                 print(f"Current histories count: {len(histories)}")
-                
+
                 histories[chat_id] = history
                 print(f"Updated histories count: {len(histories)}")
-                
+
                 success = RobustFileOperations.safe_write_json(self.chat_histories_file, histories)
                 if success:
                     print(f"Successfully saved chat history for {chat_id}")
                 else:
                     print(f"ERROR: Failed to write chat history file for {chat_id}")
-                
+
                 return success
                 
             except Exception as e:
@@ -584,7 +585,7 @@ class FileScanCacheManager:
             cache_path = self._get_file_cache_path(file_path)
             return RobustFileOperations.safe_read_json(cache_path, None)
         except Exception as e:
-            print(f"Error reading file cache for {file_path}: {e}")
+            print(f"ERROR: reading file cache for {file_path}: {e}")
             return None
     
     def set_file_entry(self, file_path: str, entry: Dict[str, Any]) -> bool:
@@ -596,7 +597,7 @@ class FileScanCacheManager:
             cache_path = self._get_file_cache_path(file_path)
             return RobustFileOperations.safe_write_json(cache_path, entry)
         except Exception as e:
-            print(f"Error writing file cache for {file_path}: {e}")
+            print(f"ERROR: writing file cache for {file_path}: {e}")
             return False
     
     def delete_file_entry(self, file_path: str) -> bool:
@@ -611,7 +612,7 @@ class FileScanCacheManager:
                 return True
             return True  # File doesn't exist, consider it deleted
         except Exception as e:
-            print(f"Error deleting file cache for {file_path}: {e}")
+            print(f"ERROR: deleting file cache for {file_path}: {e}")
             return False
     
     def get_scanned_directories(self) -> List[Dict[str, Any]]:
@@ -622,7 +623,7 @@ class FileScanCacheManager:
         try:
             return RobustFileOperations.safe_read_json(self.scanned_directories_file, [])
         except Exception as e:
-            print(f"Error reading scanned directories: {e}")
+            print(f"ERROR: reading scanned directories: {e}")
             return []
     
     def set_scanned_directories(self, directories: List[Dict[str, Any]]) -> bool:
@@ -633,7 +634,7 @@ class FileScanCacheManager:
         try:
             return RobustFileOperations.safe_write_json(self.scanned_directories_file, directories)
         except Exception as e:
-            print(f"Error writing scanned directories: {e}")
+            print(f"ERROR: writing scanned directories: {e}")
             return False
     
     def clear_all_file_entries(self) -> bool:
@@ -648,7 +649,7 @@ class FileScanCacheManager:
                     cache_file.unlink()
             return True
         except Exception as e:
-            print(f"Error clearing file entries: {e}")
+            print(f"ERROR: clearing file entries: {e}")
             return False
     
     def get_cache_stats(self) -> Dict[str, Any]:

signalpilot_ai_internal/composio_handlers.py

@@ -0,0 +1,224 @@
+"""
+Composio Integration Handlers - Tornado HTTP handlers for OAuth integrations
+Provides REST API for managing Composio OAuth integrations (Notion, Slack, Google)
+"""
+import json
+import logging
+import traceback
+import tornado
+from jupyter_server.base.handlers import APIHandler
+from .composio_service import get_composio_service
+
+logger = logging.getLogger(__name__)
+
+# Enable debug logging
+logger.setLevel(logging.DEBUG)
+
+
+class IntegrationsHandler(APIHandler):
+    """Handler for listing all integrations and their status"""
+
+    @tornado.web.authenticated
+    async def get(self):
+        """Get all available integrations with their connection status"""
+        try:
+            service = get_composio_service()
+            integrations = service.get_integrations()
+
+            self.finish(json.dumps({
+                'integrations': integrations,
+                'configured': service.is_configured(),
+                'workerUrl': service.get_worker_url() if service.is_configured() else None,
+            }))
+        except Exception as e:
+            logger.error(f"Error getting integrations: {e}")
+            logger.error(traceback.format_exc())
+            self.set_status(500)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+
+
+class IntegrationConnectHandler(APIHandler):
+    """Handler for initiating OAuth connection for an integration"""
+
+    @tornado.web.authenticated
+    async def post(self, integration_id):
+        """
+        Get worker URL and user ID for initiating OAuth connection.
+        Frontend will call the worker directly.
+        """
+        try:
+            service = get_composio_service()
+
+            if not service.is_configured():
+                self.set_status(400)
+                self.finish(json.dumps({
+                    'error': 'Composio worker URL not configured. Set COMPOSIO_WORKER_URL environment variable.',
+                    'configured': False,
+                }))
+                return
+
+            result = service.get_initiate_url(integration_id)
+
+            self.finish(json.dumps({
+                'success': True,
+                'workerUrl': result['workerUrl'],
+                'userId': result['userId'],
+            }))
+        except ValueError as e:
+            self.set_status(400)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+        except Exception as e:
+            logger.error(f"Error initiating connection for {integration_id}: {e}")
+            logger.error(traceback.format_exc())
+            self.set_status(500)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+
+
+class IntegrationCompleteHandler(APIHandler):
+    """Handler for completing OAuth connection after callback"""
+
+    @tornado.web.authenticated
+    async def post(self, integration_id):
+        """Complete OAuth connection and create MCP server"""
+        try:
+            service = get_composio_service()
+
+            if not service.is_configured():
+                self.set_status(400)
+                self.finish(json.dumps({
+                    'error': 'Composio worker URL not configured',
+                    'configured': False,
+                }))
+                return
+
+            result = await service.complete_connection(integration_id)
+
+            self.finish(json.dumps({
+                'success': True,
+                **result,
+            }))
+        except ValueError as e:
+            self.set_status(400)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+        except Exception as e:
+            logger.error(f"Error completing connection for {integration_id}: {e}")
+            logger.error(traceback.format_exc())
+            self.set_status(500)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+
+
+class IntegrationStatusHandler(APIHandler):
+    """Handler for checking connection status of an integration"""
+
+    @tornado.web.authenticated
+    async def get(self, integration_id):
+        """Check connection status for an integration"""
+        try:
+            service = get_composio_service()
+
+            if not service.is_configured():
+                self.set_status(400)
+                self.finish(json.dumps({
+                    'error': 'Composio worker URL not configured',
+                    'configured': False,
+                }))
+                return
+
+            result = await service.check_connection_status(integration_id)
+
+            self.finish(json.dumps({
+                'success': True,
+                **result,
+            }))
+        except ValueError as e:
+            self.set_status(400)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+        except Exception as e:
+            logger.error(f"Error checking status for {integration_id}: {e}")
+            logger.error(traceback.format_exc())
+            self.set_status(500)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+
+
+class IntegrationDisconnectHandler(APIHandler):
+    """Handler for disconnecting an integration"""
+
+    @tornado.web.authenticated
+    async def delete(self, integration_id):
+        """Disconnect an integration and remove MCP server"""
+        try:
+            service = get_composio_service()
+
+            result = await service.disconnect(integration_id)
+
+            self.finish(json.dumps({
+                'success': True,
+                **result,
+            }))
+        except ValueError as e:
+            self.set_status(400)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+        except Exception as e:
+            logger.error(f"Error disconnecting {integration_id}: {e}")
+            logger.error(traceback.format_exc())
+            self.set_status(500)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+
+
+class IntegrationRefreshHandler(APIHandler):
+    """Handler for manually refreshing OAuth tokens for an integration"""
+
+    @tornado.web.authenticated
+    async def post(self, integration_id):
+        """
+        Manually trigger token refresh for an integration.
+        Fetches fresh credentials from Composio and updates MCP server if tokens changed.
+        """
+        try:
+            service = get_composio_service()
+
+            if not service.is_configured():
+                self.set_status(400)
+                self.finish(json.dumps({
+                    'error': 'Composio worker URL not configured',
+                    'configured': False,
+                }))
+                return
+
+            result = await service.refresh_token(integration_id)
+
+            self.finish(json.dumps({
+                'success': result.get('success', False),
+                'tokens_updated': result.get('tokens_updated', False),
+                'error': result.get('error'),
+            }))
+        except ValueError as e:
+            self.set_status(400)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))
+        except Exception as e:
+            logger.error(f"Error refreshing tokens for {integration_id}: {e}")
+            logger.error(traceback.format_exc())
+            self.set_status(500)
+            self.finish(json.dumps({
+                'error': str(e)
+            }))