synapse-sdk 1.0.0a23__py3-none-any.whl → 2025.12.3__py3-none-any.whl

synapse_sdk/devtools/streamlit_app/app.py

@@ -0,0 +1,128 @@
+"""Main Streamlit DevTools Application."""
+
+from pathlib import Path
+from typing import Dict, Optional
+
+import streamlit as st
+
+from synapse_sdk.clients.backend import BackendClient
+from synapse_sdk.devtools.config import get_backend_config, load_devtools_config
+
+from .services import JobService, PluginService, ServeService
+from .ui import ConfigTab, DeploymentTab, HttpTab, JobsTab, ServeTab
+from .ui.status_bar import StatusBar
+from .utils import CUSTOM_CSS
+
+
+class DevToolsApp:
+    """Main DevTools application class."""
+
+    def __init__(self):
+        self.plugin_directory = Path.cwd()
+
+        # Initialize backend client and agent info
+        self.backend_client = self._init_backend_client()
+        self.agent_id = self._get_agent_id()
+        self.agent_info = self._get_agent_info()
+
+        # Initialize services
+        self.plugin_service = PluginService(self.plugin_directory, self.backend_client)
+        self.job_service = JobService(self.backend_client)
+        self.serve_service = ServeService(self.backend_client)
+
+        # Initialize UI components
+        self.status_bar = StatusBar(
+            backend_client=self.backend_client, agent_id=self.agent_id, agent_info=self.agent_info
+        )
+        self.config_tab = ConfigTab(self.plugin_service)
+        self.http_tab = HttpTab(self.plugin_service, self.agent_id)
+        self.deployment_tab = DeploymentTab(self.plugin_service)
+        self.jobs_tab = JobsTab(self.job_service, self.agent_id, self.agent_info)
+        self.serve_tab = ServeTab(self.serve_service, self.agent_id, self.agent_info)
+
+    def _init_backend_client(self) -> Optional[BackendClient]:
+        """Initialize backend client from configuration."""
+        config = get_backend_config()
+        if config:
+            return BackendClient(config['host'], access_token=config['token'])
+        return None
+
+    def _get_agent_id(self) -> Optional[int]:
+        """Get agent ID from devtools configuration."""
+        devtools_config = load_devtools_config()
+        agent_config = devtools_config.get('agent', {})
+        if agent_config and 'id' in agent_config:
+            return agent_config['id']
+        return None
+
+    def _get_agent_info(self) -> Optional[Dict]:
+        """Get complete agent information from configuration or backend."""
+        devtools_config = load_devtools_config()
+        agent_config = devtools_config.get('agent', {})
+
+        # Return the full agent config which should include name, ip, etc.
+        if agent_config:
+            return agent_config
+
+        # If we have an agent_id but no full config, try to fetch from backend
+        if self.agent_id and self.backend_client:
+            try:
+                # Try to get agent details from backend
+                # This would require an API endpoint - for now return basic info
+                return {
+                    'id': self.agent_id,
+                    'name': agent_config.get('name', f'Agent-{self.agent_id}'),
+                    'url': agent_config.get('url', agent_config.get('ip', 'localhost')),
+                }
+            except Exception:
+                pass
+
+        return None
+
+    def run(self):
+        """Main application entry point."""
+        # Page configuration
+        st.set_page_config(
+            page_title='Synapse DevTools',
+            page_icon=None,
+            layout='wide',
+            initial_sidebar_state='collapsed',
+        )
+
+        # Apply custom CSS
+        st.markdown(CUSTOM_CSS, unsafe_allow_html=True)
+
+        # Display status bar
+        self.status_bar.render()
+
+        # Initialize session state
+        if 'config' not in st.session_state:
+            st.session_state['config'] = self.plugin_service.load_config()
+
+        # Create tabs
+        tabs = st.tabs(['Configuration', 'HTTP Request', 'Deployment', 'Jobs', 'Serve Apps'])
+
+        with tabs[0]:
+            self.config_tab.render()
+
+        with tabs[1]:
+            self.http_tab.render()
+
+        with tabs[2]:
+            self.deployment_tab.render()
+
+        with tabs[3]:
+            self.jobs_tab.render()
+
+        with tabs[4]:
+            self.serve_tab.render()
+
+
+def main():
+    """Main entry point for Streamlit app."""
+    app = DevToolsApp()
+    app.run()
+
+
+if __name__ == '__main__':
+    main()

synapse_sdk/devtools/streamlit_app/services/__init__.py

@@ -0,0 +1,11 @@
+"""Services for business logic."""
+
+from .job_service import JobService
+from .plugin_service import PluginService
+from .serve_service import ServeService
+
+__all__ = [
+    'JobService',
+    'PluginService',
+    'ServeService',
+]

synapse_sdk/devtools/streamlit_app/services/job_service.py

@@ -0,0 +1,233 @@
+"""Job service for managing job operations."""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from synapse_sdk.clients.backend import BackendClient
+from synapse_sdk.clients.exceptions import ClientError
+
+
+class JobService:
+    """Service for job-related operations."""
+
+    def __init__(self, backend_client: Optional[BackendClient] = None):
+        self.backend_client = backend_client
+
+    def list_jobs(self, agent_id: Optional[int] = None, agent_info: Optional[Dict] = None) -> List[Dict]:
+        """List jobs from the backend."""
+        if not self.backend_client:
+            return []
+
+        try:
+            params = {}
+            if agent_id:
+                params['agent'] = agent_id
+
+            jobs_response = self.backend_client.list_jobs(params=params)
+
+            # Handle paginated response - extract results
+            if jobs_response is None:
+                return []
+            elif isinstance(jobs_response, dict) and 'results' in jobs_response:
+                jobs = jobs_response['results']
+            else:
+                jobs = jobs_response if isinstance(jobs_response, list) else []
+
+            # Remove None jobs and sort by created time (most recent first)
+            valid_jobs = [job for job in jobs if job is not None]
+            valid_jobs.sort(key=lambda job: job.get('created', ''), reverse=True)
+
+            # Try to enrich jobs with plugin names
+            enriched_jobs = []
+            for job in valid_jobs:
+                enriched_job = job.copy()
+
+                # Try to get plugin info
+                if 'plugin_release' in job:
+                    try:
+                        # Try to fetch plugin release details
+                        plugin_release_response = self.backend_client.get(f'/plugin_releases/{job["plugin_release"]}/')
+                        if plugin_release_response and isinstance(plugin_release_response, dict):
+                            # Get version from plugin release
+                            enriched_job['plugin_version'] = plugin_release_response.get('version')
+
+                            # Try to get plugin details from the plugin ID
+                            plugin_id = plugin_release_response.get('plugin')
+                            if plugin_id:
+                                try:
+                                    plugin_response = self.backend_client.get(f'/plugins/{plugin_id}/')
+                                    if plugin_response and isinstance(plugin_response, dict):
+                                        enriched_job['plugin_name'] = plugin_response.get('name')
+                                        enriched_job['plugin_code'] = plugin_response.get('code')
+                                except Exception:
+                                    # Fallback to config if plugin fetch fails
+                                    config = plugin_release_response.get('config', {})
+                                    enriched_job['plugin_name'] = config.get('name') or config.get('code')
+                                    enriched_job['plugin_code'] = config.get('code')
+                            else:
+                                # Fallback to config if no plugin ID
+                                config = plugin_release_response.get('config', {})
+                                enriched_job['plugin_name'] = config.get('name') or config.get('code')
+                                enriched_job['plugin_code'] = config.get('code')
+                    except Exception:
+                        pass
+
+                # Try to get agent info
+                if 'agent' in job:
+                    # First check if we have local agent info
+                    if agent_info and job.get('agent') == agent_id:
+                        enriched_job['agent_name'] = agent_info.get('name')
+                        enriched_job['agent_url'] = agent_info.get('url')
+                    else:
+                        # Try to fetch agent details from API
+                        try:
+                            agent_response = self.backend_client.get(f'/agents/{job["agent"]}/')
+                            if agent_response and isinstance(agent_response, dict):
+                                enriched_job['agent_name'] = agent_response.get('name')
+                                enriched_job['agent_url'] = agent_response.get('url')
+                        except Exception:
+                            pass
+
+                enriched_jobs.append(enriched_job)
+
+            return enriched_jobs
+        except ClientError:
+            raise
+        except Exception as e:
+            raise Exception(f'Failed to list jobs: {e}')
+
+    def get_job_logs(self, job_id: str):
+        """Get all logs for a job at once."""
+        if not self.backend_client:
+            raise Exception('Backend client not configured')
+
+        try:
+            # Get logs from console_logs endpoint (returns list of strings)
+            logs_response = self.backend_client.list_job_console_logs(job_id)
+
+            # API returns a list of log strings
+            if isinstance(logs_response, list):
+                if not logs_response:
+                    # Empty list means no logs yet
+                    yield 'No logs available for this job yet.\n'
+                else:
+                    for log_entry in logs_response:
+                        # Each entry is already a formatted string with timestamp
+                        yield str(log_entry) + '\n' if not str(log_entry).endswith('\n') else str(log_entry)
+            elif logs_response:
+                # Fallback for unexpected format
+                yield str(logs_response) + '\n'
+            else:
+                yield 'No logs available for this job yet.\n'
+
+        except Exception as e:
+            from synapse_sdk.clients.exceptions import ClientError
+
+            # Check if it's a ClientError with specific status
+            if isinstance(e, ClientError):
+                if e.status == 404:
+                    yield 'Job not found or logs not available.\n'
+                elif e.status == 401:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    # Check for Korean error message in the reason
+                    error_str = str(e.reason) if hasattr(e, 'reason') else str(e)
+                    if '찾을 수 없습니다' in error_str:
+                        yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                    else:
+                        yield f'Failed to fetch logs: {error_str}\n'
+            else:
+                error_str = str(e)
+                if '찾을 수 없습니다' in error_str or '404' in error_str or 'Not found' in error_str:
+                    yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                elif '401' in error_str or 'Unauthorized' in error_str:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    yield f'Failed to fetch logs: {error_str}\n'
+
+    def stream_job_logs(self, job_id: str):
+        """Stream logs for a job (simulated streaming since tail endpoint doesn't exist)."""
+        if not self.backend_client:
+            raise Exception('Backend client not configured')
+
+        # Since tail_console_logs endpoint returns 404, we'll simulate streaming
+        # by fetching all logs and yielding them one by one
+        try:
+            from synapse_sdk.clients.exceptions import ClientError
+
+            # Get logs from console_logs endpoint (returns list of strings)
+            logs_response = self.backend_client.list_job_console_logs(job_id)
+
+            # API returns a list of log strings
+            if isinstance(logs_response, list):
+                if not logs_response:
+                    # Empty list means no logs yet
+                    yield 'No logs available for this job yet.\n'
+                else:
+                    # Yield logs one by one to simulate streaming
+                    for log_entry in logs_response:
+                        # Each entry is already a formatted string with timestamp
+                        yield str(log_entry) + '\n' if not str(log_entry).endswith('\n') else str(log_entry)
+            elif logs_response:
+                # Fallback for unexpected format
+                yield str(logs_response) + '\n'
+            else:
+                yield 'No logs available for this job yet.\n'
+
+        except Exception as e:
+            # Check if it's a ClientError with specific status
+            if isinstance(e, ClientError):
+                if e.status == 404:
+                    yield 'Job not found or logs not available.\n'
+                elif e.status == 401:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    # Check for Korean error message in the reason
+                    error_str = str(e.reason) if hasattr(e, 'reason') else str(e)
+                    if '찾을 수 없습니다' in error_str:
+                        yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                    else:
+                        yield f'Failed to stream logs: {error_str}\n'
+            else:
+                error_str = str(e)
+                if '찾을 수 없습니다' in error_str or '404' in error_str or 'Not found' in error_str:
+                    yield 'Job logs not found. The job may not have generated any logs yet.\n'
+                elif '401' in error_str or 'Unauthorized' in error_str:
+                    yield 'Unauthorized to access job logs.\n'
+                else:
+                    yield f'Failed to stream logs: {error_str}\n'
+
+    @staticmethod
+    def format_duration(created: str, completed: Optional[str] = None) -> str:
+        """Format duration between created and completed timestamps."""
+        if not created:
+            return '-'
+
+        try:
+            created_dt = datetime.fromisoformat(created.replace('+09:00', '+09:00'))
+            if completed:
+                completed_dt = datetime.fromisoformat(completed.replace('+09:00', '+09:00'))
+                duration = completed_dt - created_dt
+                total_seconds = int(duration.total_seconds())
+                if total_seconds < 60:
+                    return f'{total_seconds}s'
+                else:
+                    minutes = total_seconds // 60
+                    seconds = total_seconds % 60
+                    return f'{minutes}m {seconds}s'
+            else:
+                return '...'
+        except Exception:
+            return '-'
+
+    @staticmethod
+    def format_timestamp(timestamp: str) -> str:
+        """Format timestamp for display."""
+        if not timestamp:
+            return '-'
+
+        try:
+            dt = datetime.fromisoformat(timestamp.replace('+09:00', '+09:00'))
+            return dt.strftime('%m/%d %H:%M')
+        except Exception:
+            return timestamp[:16] if len(timestamp) > 16 else timestamp

synapse_sdk/devtools/streamlit_app/services/plugin_service.py

@@ -0,0 +1,236 @@
+"""Plugin service for managing plugin operations."""
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Dict, Optional
+
+import yaml
+
+from synapse_sdk.cli.plugin.publish import _publish
+from synapse_sdk.clients.backend import BackendClient
+
+
+class PluginService:
+    """Service for plugin-related operations."""
+
+    def __init__(self, plugin_directory: Path, backend_client: Optional[BackendClient] = None):
+        self.plugin_directory = plugin_directory
+        self.config_path = plugin_directory / 'config.yaml'
+        self.test_http_path = plugin_directory / 'test.http'
+        self.backend_client = backend_client
+
+    def load_config(self) -> Dict:
+        """Load plugin configuration from config.yaml."""
+        if not self.config_path.exists():
+            return {}
+
+        try:
+            with open(self.config_path, 'r') as f:
+                return yaml.safe_load(f)
+        except Exception:
+            return {}
+
+    def save_config(self, config: Dict) -> bool:
+        """Save plugin configuration to config.yaml."""
+        try:
+            # Backup existing config
+            if self.config_path.exists():
+                backup_path = self.config_path.with_suffix('.yaml.bak')
+                self.config_path.rename(backup_path)
+
+            # Write new config
+            with open(self.config_path, 'w') as f:
+                yaml.dump(config, f, default_flow_style=False, allow_unicode=True, indent=2)
+
+            return True
+        except Exception:
+            # Restore backup if write failed
+            backup_path = self.config_path.with_suffix('.yaml.bak')
+            if backup_path.exists():
+                backup_path.rename(self.config_path)
+            return False
+
+    def parse_test_http(self) -> Dict[str, Dict]:
+        """Parse test.http file and extract action parameters."""
+        if not self.test_http_path.exists():
+            return {}
+
+        requests = {}
+        current_request_name = None
+        current_body_lines = []
+        in_body = False
+
+        try:
+            with open(self.test_http_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line.startswith('###'):
+                        # Process previous request
+                        if current_request_name and current_body_lines:
+                            try:
+                                full_request = json.loads(''.join(current_body_lines))
+                                if 'params' in full_request:
+                                    requests[current_request_name] = full_request['params']
+                            except json.JSONDecodeError:
+                                pass
+
+                        # Start new request
+                        current_request_name = line.replace('###', '').strip()
+                        current_body_lines = []
+                        in_body = False
+                    elif current_request_name and line.startswith('{'):
+                        in_body = True
+                        current_body_lines.append(line)
+                    elif in_body and current_request_name:
+                        current_body_lines.append(line)
+
+                # Process last request
+                if current_request_name and current_body_lines:
+                    try:
+                        full_request = json.loads(''.join(current_body_lines))
+                        if 'params' in full_request:
+                            requests[current_request_name] = full_request['params']
+                    except json.JSONDecodeError:
+                        pass
+
+            return requests
+        except Exception:
+            return {}
+
+    def update_test_http_params(self, action: str, new_params: Dict) -> bool:
+        """Update parameters for a specific action in test.http."""
+        if not self.test_http_path.exists():
+            return False
+
+        try:
+            with open(self.test_http_path, 'r') as f:
+                lines = f.readlines()
+
+            current_action = None
+            in_json = False
+            json_start_line = -1
+            json_lines = []
+            updated = False
+
+            for i, line in enumerate(lines):
+                if line.strip().startswith('###'):
+                    current_action = line.replace('###', '').strip()
+                    in_json = False
+                    json_lines = []
+                elif current_action and line.strip().startswith('{'):
+                    in_json = True
+                    json_start_line = i
+                    json_lines = [line]
+                elif in_json:
+                    json_lines.append(line)
+                    if line.strip() == '}':
+                        if current_action == action:
+                            try:
+                                full_json = json.loads(''.join(json_lines))
+                                full_json['params'] = new_params
+                                new_json = json.dumps(full_json, indent=2)
+                                lines[json_start_line : i + 1] = [new_json + '\n']
+                                updated = True
+                                break
+                            except json.JSONDecodeError:
+                                pass
+                        in_json = False
+                        json_lines = []
+
+            if updated:
+                with open(self.test_http_path, 'w') as f:
+                    f.writelines(lines)
+                return True
+
+            return False
+        except Exception:
+            return False
+
+    def execute_plugin_action(
+        self, action: str, params: Dict, plugin_code: str, agent_id: Optional[int] = None, debug: bool = True
+    ) -> Dict:
+        """Execute a plugin action via HTTP request."""
+        if not self.backend_client:
+            return {'success': False, 'error': 'Backend client not configured'}
+
+        if not plugin_code:
+            return {'success': False, 'error': 'Plugin code not found in configuration'}
+
+        plugin_url = f'{self.backend_client.base_url}/plugins/{plugin_code}/run/'
+
+        headers = {
+            'Accept': 'application/json; indent=4',
+            'Content-Type': 'application/json',
+        }
+
+        # Get auth headers from backend client
+        auth_headers = self.backend_client._get_headers()
+        headers.update(auth_headers)
+
+        payload = {
+            'agent': agent_id or 2,
+            'action': action,
+            'params': params,
+            'debug': debug,
+        }
+
+        start_time = time.time()
+
+        try:
+            import requests
+
+            response = requests.post(plugin_url, json=payload, headers=headers, timeout=30)
+            execution_time = int((time.time() - start_time) * 1000)
+
+            try:
+                response_data = response.json()
+            except Exception:
+                response_data = response.text
+
+            return {
+                'success': response.status_code < 400,
+                'status_code': response.status_code,
+                'response_data': response_data,
+                'execution_time': execution_time,
+                'url': plugin_url,
+                'method': 'POST',
+                'headers': headers,
+                'payload': payload,
+            }
+        except Exception as e:
+            execution_time = int((time.time() - start_time) * 1000)
+            return {
+                'success': False,
+                'status_code': 500,
+                'error': str(e),
+                'execution_time': execution_time,
+                'url': plugin_url,
+            }
+
+    def publish_plugin(self, host: str, access_token: str, debug: bool = True) -> Dict:
+        """Publish plugin to Synapse platform."""
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(str(self.plugin_directory))
+
+            debug_modules = os.getenv('SYNAPSE_DEBUG_MODULES', '')
+            plugin_release = _publish(host, access_token, debug, debug_modules)
+
+            return {
+                'success': True,
+                'message': (
+                    f'Successfully published "{plugin_release.name}" ({plugin_release.code}) to synapse backend!'
+                ),
+                'plugin_code': plugin_release.code,
+                'version': plugin_release.version,
+                'name': plugin_release.name,
+            }
+        except Exception as e:
+            return {
+                'success': False,
+                'error': str(e),
+            }
+        finally:
+            os.chdir(original_cwd)