synapse-sdk 1.0.0a59__py3-none-any.whl → 1.0.0a60__py3-none-any.whl

synapse_sdk/cli/__init__.py

@@ -1,13 +1,254 @@
+import os
+
 import click
+import inquirer
+import requests
 
-from .alias import alias
+from .config import config
+from .devtools import devtools
 from .plugin import plugin
 
 
-@click.group()
-def cli():
-    pass
+def clear_screen():
+    """Clear the terminal screen"""
+    os.system('cls' if os.name == 'nt' else 'clear')
+
+
+def check_backend_status():
+    """Check backend connection status and token validity"""
+    from synapse_sdk.devtools.config import get_backend_config
+
+    backend_config = get_backend_config()
+    if not backend_config:
+        return 'not_configured', 'No backend configured'
+
+    try:
+        # Try an authenticated endpoint to verify token validity
+        # Use /users/me/ which requires authentication
+        response = requests.get(
+            f'{backend_config["host"]}/users/me/',
+            headers={'Synapse-Access-Token': f'Token {backend_config["token"]}'},
+            timeout=5,
+        )
+
+        if response.status_code == 200:
+            return 'healthy', f'Connected to {backend_config["host"]}'
+        elif response.status_code == 401:
+            return 'auth_error', 'Invalid token (401)'
+        elif response.status_code == 403:
+            return 'forbidden', 'Access forbidden (403)'
+        elif response.status_code == 404:
+            # If /users/me/ doesn't exist, try /health as fallback
+            try:
+                health_response = requests.get(
+                    f'{backend_config["host"]}/health',
+                    headers={'Synapse-Access-Token': f'Token {backend_config["token"]}'},
+                    timeout=3,
+                )
+                if health_response.status_code == 200:
+                    return 'healthy', f'Connected to {backend_config["host"]}'
+                elif health_response.status_code == 401:
+                    return 'auth_error', 'Invalid token (401)'
+                elif health_response.status_code == 403:
+                    return 'forbidden', 'Access forbidden (403)'
+                else:
+                    return 'error', f'HTTP {health_response.status_code}'
+            except:  # noqa: E722
+                return 'error', 'Endpoint not found (404)'
+        else:
+            return 'error', f'HTTP {response.status_code}'
+
+    except requests.exceptions.Timeout:
+        return 'timeout', 'Connection timeout (>5s)'
+    except requests.exceptions.ConnectionError:
+        return 'connection_error', 'Connection failed'
+    except Exception as e:
+        return 'error', f'Connection error: {str(e)}'
+
+
+def check_agent_status():
+    """Check agent configuration status"""
+    from synapse_sdk.devtools.config import load_devtools_config
+
+    config = load_devtools_config()
+    agent_config = config.get('agent', {})
+
+    if not agent_config.get('id'):
+        return 'not_configured', 'No agent selected'
+
+    return 'configured', f'{agent_config.get("name", "")} (ID: {agent_config["id"]})'
+
+
+def display_connection_status():
+    """Display connection status for backend and agent"""
+    click.echo(click.style('Connection Status:', fg='white', bold=True))
+
+    # Check backend status (async with timeout)
+    backend_status, backend_msg = check_backend_status()
+
+    # Backend status with specific handling for auth errors
+    if backend_status == 'healthy':
+        click.echo(f'🟢 Backend: {click.style(backend_msg, fg="green")}')
+    elif backend_status == 'not_configured':
+        click.echo(f'🔴 Backend: {click.style(backend_msg, fg="yellow")}')
+    elif backend_status in ['auth_error', 'forbidden']:
+        click.echo(f'🔴 Backend: {click.style(backend_msg, fg="red", bold=True)}')
+    else:
+        click.echo(f'🔴 Backend: {click.style(backend_msg, fg="red")}')
+
+    # Agent status (config check only, no network call)
+    agent_status, agent_msg = check_agent_status()
+    if agent_status == 'configured':
+        click.echo(f'🟢 Agent: {click.style(agent_msg, fg="green")}')
+    else:
+        click.echo(f'🔴 Agent: {click.style(agent_msg, fg="yellow")}')
+
+    click.echo()  # Empty line for spacing
+
+
+def run_devtools(build=False):
+    """Run devtools with default settings"""
+    try:
+        from synapse_sdk.devtools.server import create_devtools_server
+
+        if build:
+            click.echo('Building frontend assets...')
+            build_frontend()
+
+        click.echo('Starting Synapse Devtools...')
+        server = create_devtools_server(host='127.0.0.1', port=8080)
+        server.start_server(open_browser=True)
+    except ImportError:
+        click.echo(
+            click.style(
+                'Devtools dependencies not installed. Install with: pip install synapse-sdk[dashboard]', fg='red'
+            ),
+            err=True,
+        )
+    except KeyboardInterrupt:
+        click.echo('\nDevtools stopped.')
+    except Exception as e:
+        click.echo(click.style(f'Failed to start devtools: {e}', fg='red'), err=True)
+
+
+def build_frontend():
+    """Build the frontend assets"""
+    import subprocess
+    from pathlib import Path
+
+    # Find the web directory
+    devtools_dir = Path(__file__).parent.parent / 'devtools' / 'web'
+
+    if not devtools_dir.exists():
+        click.echo(click.style(f'Frontend directory not found: {devtools_dir}', fg='red'), err=True)
+        return False
+
+    try:
+        # Check if npm is available
+        subprocess.run(['npm', '--version'], capture_output=True, check=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        click.echo(click.style('npm not found. Please install Node.js and npm.', fg='red'), err=True)
+        return False
+
+    try:
+        # Install dependencies if node_modules doesn't exist
+        if not (devtools_dir / 'node_modules').exists():
+            click.echo('Installing frontend dependencies...')
+            result = subprocess.run(['npm', 'install'], cwd=devtools_dir, capture_output=True, text=True)
+            if result.returncode != 0:
+                click.echo(click.style(f'npm install failed:\n{result.stderr}', fg='red'), err=True)
+                return False
+
+        # Build the frontend
+        click.echo('Building frontend...')
+        result = subprocess.run(['npm', 'run', 'build'], cwd=devtools_dir, capture_output=True, text=True)
+
+        if result.returncode != 0:
+            click.echo(click.style(f'Frontend build failed:\n{result.stderr}', fg='red'), err=True)
+            return False
+
+        click.echo(click.style('Frontend build completed successfully!', fg='green'))
+        return True
+
+    except Exception as e:
+        click.echo(click.style(f'Build failed: {e}', fg='red'), err=True)
+        return False
+
+
+def run_config():
+    """Run the configuration menu"""
+    from .config import interactive_config
+
+    interactive_config()
+
+
+@click.group(invoke_without_command=True)
+@click.option('--dev-tools', is_flag=True, help='Start devtools immediately')
+@click.option('--build', is_flag=True, help='Build frontend before starting devtools (only with --dev-tools)')
+@click.pass_context
+def cli(ctx, dev_tools, build):
+    """Synapse SDK - Interactive CLI"""
+
+    # Handle --dev-tools flag
+    if dev_tools:
+        if build:
+            run_devtools(build=True)
+        else:
+            run_devtools(build=False)
+        return
+
+    # Handle --build flag without --dev-tools (show warning)
+    if build and not dev_tools:
+        click.echo(click.style('Warning: --build flag requires --dev-tools flag', fg='yellow'))
+        click.echo('Use: synapse --dev-tools --build')
+        return
+
+    if ctx.invoked_subcommand is None:
+        while True:
+            clear_screen()  # Always clear screen at start of main menu loop
+            click.echo(click.style('🚀 Synapse SDK', fg='cyan', bold=True))
+            click.echo()
+            display_connection_status()
+
+            try:
+                questions = [
+                    inquirer.List(
+                        'choice',
+                        message='Select an option:',
+                        choices=[
+                            ('🌐 Run Dev Tools', 'devtools'),
+                            ('⚙️  Configuration', 'config'),
+                            ('🔌 Plugin Management', 'plugin'),
+                            ('🚪 Exit', 'exit'),
+                        ],
+                    )
+                ]
+
+                answers = inquirer.prompt(questions)
+                if not answers or answers['choice'] == 'exit':
+                    clear_screen()
+                    click.echo(click.style('👋 Goodbye!', fg='green'))
+                    break
+
+                if answers['choice'] == 'devtools':
+                    run_devtools()
+                    break  # Exit after devtools finishes
+                elif answers['choice'] == 'config':
+                    run_config()
+                    # Config menu returned, continue to main menu loop
+                elif answers['choice'] == 'plugin':
+                    click.echo(click.style('🔌 Plugin Management', fg='cyan', bold=True))
+                    click.echo('For plugin management, use: synapse plugin --help\n')
+                    click.echo('Press Enter to return to main menu...')
+                    input()
+                    # Don't break - continue to main menu loop
+
+            except (KeyboardInterrupt, EOFError):
+                clear_screen()
+                click.echo(click.style('👋 Goodbye!', fg='yellow'))
+                break
 
 
 cli.add_command(plugin)
-cli.add_command(alias)
+cli.add_command(config)
+cli.add_command(devtools)

synapse_sdk/cli/alias/utils.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from dotenv import dotenv_values, load_dotenv, set_key, unset_key
 
-CONFIG_DIR = Path.home() / '.config' / 'synapse_alias'
+CONFIG_DIR = Path.home() / '.config' / 'synapse'
 DEFAULT_FILE = CONFIG_DIR / '__default__'
 
 

synapse_sdk/cli/config.py

@@ -0,0 +1,339 @@
+import os
+
+import click
+import inquirer
+import requests
+
+from synapse_sdk.devtools.config import (
+    clear_backend_config,
+    get_backend_config,
+    load_devtools_config,
+    save_devtools_config,
+    set_backend_config,
+)
+
+
+def clear_screen():
+    """Clear the terminal screen"""
+    os.system('cls' if os.name == 'nt' else 'clear')
+
+
+def get_agent_config():
+    """Get current agent configuration"""
+    config = load_devtools_config()
+    return config.get('agent', {})
+
+
+def get_tenant_config():
+    """Get current tenant configuration"""
+    config = load_devtools_config()
+    return config.get('tenant', {})
+
+
+def set_tenant_config(tenant_code: str, tenant_name: str = None):
+    """Set tenant configuration"""
+    config = load_devtools_config()
+    config['tenant'] = {'code': tenant_code}
+    if tenant_name:
+        config['tenant']['name'] = tenant_name
+    save_devtools_config(config)
+
+
+def clear_tenant_config():
+    """Clear tenant configuration"""
+    config = load_devtools_config()
+    if 'tenant' in config:
+        del config['tenant']
+    save_devtools_config(config)
+
+
+def set_agent_config(agent_id: str, agent_name: str = None, agent_url: str = None, agent_token: str = None):
+    """Set agent configuration"""
+    config = load_devtools_config()
+    config['agent'] = {'id': agent_id}
+    if agent_name:
+        config['agent']['name'] = agent_name
+    if agent_url:
+        config['agent']['url'] = agent_url
+    if agent_token:
+        config['agent']['token'] = agent_token
+
+    save_devtools_config(config)
+
+
+def clear_agent_config():
+    """Clear agent configuration"""
+    config = load_devtools_config()
+    if 'agent' in config:
+        del config['agent']
+    save_devtools_config(config)
+
+
+def fetch_agents_from_backend():
+    """Fetch available agents from the backend"""
+    backend_config = get_backend_config()
+    if not backend_config:
+        return None, 'No backend configuration found. Configure backend first.'
+
+    def extract_uuid(string):
+        import re
+
+        """Extract UUID between 'agents/' and '/node_install_script' from a string."""
+        pattern = r'agents/([a-f0-9]{40})/node_install_script'
+        match = re.search(pattern, string)
+        return match.group(1) if match else None
+
+    try:
+        response = requests.get(
+            f'{backend_config["host"]}/agents/',
+            headers={'Synapse-Access-Token': f'Token {backend_config["token"]}'},
+            timeout=10,
+        )
+        if response.status_code == 200:
+            try:
+                data = response.json()
+                results = data.get('results', [])
+                for result in results:
+                    _node_install_script = result.get('node_install_script')
+                    if _node_install_script:
+                        result['token'] = extract_uuid(_node_install_script)
+                return results, None
+            except ValueError:
+                return None, 'Invalid JSON response from server'
+        elif response.status_code == 401:
+            return None, 'Authentication failed. Check your backend token.'
+        elif response.status_code == 403:
+            return None, 'Access forbidden. Check your permissions.'
+        else:
+            return None, f'Failed to fetch agents: HTTP {response.status_code}'
+
+    except requests.exceptions.Timeout:
+        return None, 'Request timeout. Check your network connection.'
+    except requests.exceptions.ConnectionError:
+        return None, 'Connection failed. Check backend host URL.'
+    except Exception as e:
+        return None, f'Error fetching agents: {str(e)}'
+
+
+def configure_backend():
+    """Interactive backend configuration"""
+    backend_config = get_backend_config()
+
+    if backend_config:
+        click.echo(f'Current backend: {backend_config["host"]}')
+        click.echo(f'Token: {backend_config["token"][:8]}...')
+        click.echo()
+
+    questions = [
+        inquirer.List(
+            'action',
+            message='What would you like to do?',
+            choices=[
+                ('Configure new backend', 'configure'),
+                ('Show current configuration', 'show'),
+                ('Clear configuration', 'clear'),
+                ('← Back to main menu', 'back'),
+            ],
+        )
+    ]
+
+    answers = inquirer.prompt(questions)
+    if not answers or answers['action'] == 'back':
+        return
+
+    if answers['action'] == 'show':
+        if backend_config:
+            click.echo(click.style('\n✓ Backend Configuration:', fg='green'))
+            click.echo(f'  Host: {backend_config["host"]}')
+            click.echo(f'  Token: {backend_config["token"]}')
+        else:
+            click.echo(click.style('\n⚠ No backend configuration found.', fg='yellow'))
+        return
+
+    if answers['action'] == 'clear':
+        confirm = inquirer.confirm('Are you sure you want to clear the backend configuration?')
+        if confirm:
+            clear_backend_config()
+            click.echo(click.style('\n✓ Backend configuration cleared.', fg='yellow'))
+        return
+
+    if answers['action'] == 'configure':
+        config_questions = [
+            inquirer.Text(
+                'host',
+                message='Backend host URL',
+                default=backend_config['host'] if backend_config else 'https://api.synapse.sh',
+            ),
+            inquirer.Password('token', message='API token'),
+        ]
+
+        config_answers = inquirer.prompt(config_questions)
+        if config_answers and config_answers['token']:
+            set_backend_config(config_answers['host'], config_answers['token'])
+            click.echo(click.style('\n✓ Backend configuration saved!', fg='green'))
+            click.echo(f'Host: {config_answers["host"]}')
+            click.echo(f'Token: {config_answers["token"][:8]}...')
+
+
+def configure_agent():
+    """Interactive agent configuration"""
+    agent_config = get_agent_config()
+
+    if agent_config:
+        click.echo(f'Current agent: {agent_config.get("name", "Unknown")} ({agent_config.get("id")})')
+        click.echo()
+
+    questions = [
+        inquirer.List(
+            'action',
+            message='What would you like to do?',
+            choices=[
+                ('Select agent', 'select'),
+                ('Set agent ID manually', 'manual'),
+                ('← Back to main menu', 'back'),
+            ],
+        )
+    ]
+
+    answers = inquirer.prompt(questions)
+    if not answers or answers['action'] == 'back':
+        return
+
+    if answers['action'] == 'select':
+        click.echo('Fetching available agents...')
+        agents, error = fetch_agents_from_backend()
+
+        if error:
+            click.echo(click.style(f'\nError: {error}', fg='red'))
+            return
+
+        if not agents:
+            click.echo(click.style('\n⚠  No agents found in current workspace.', fg='yellow'))
+            return
+
+        # Create choices for agent selection
+        agent_choices = []
+        for agent in agents:
+            status_indicator = '🟢' if agent.get('status', '').lower() == 'connected' else '🔴'
+            display_name = f'{status_indicator} {agent["name"]} ({agent["id"]})'
+            if agent.get('url'):
+                display_name += f' - {agent["url"]}'
+            agent_choices.append((display_name, agent))
+
+        agent_choices.append(('← Cancel', None))
+
+        agent_questions = [inquirer.List('selected_agent', message='Select an agent:', choices=agent_choices)]
+
+        agent_answers = inquirer.prompt(agent_questions)
+        if agent_answers and agent_answers['selected_agent']:
+            selected = agent_answers['selected_agent']
+            set_agent_config(selected['id'], selected.get('name'), selected.get('url'), selected.get('token'))
+            click.echo(click.style('\n✓ Agent configured!', fg='green'))
+            click.echo(f'Selected: {selected["name"]} ({selected["id"]})')
+            if selected.get('url'):
+                click.echo(f'URL: {selected["url"]}')
+
+    if answers['action'] == 'manual':
+        manual_questions = [
+            inquirer.Text('agent_id', message='Agent ID', default=agent_config.get('id', '') if agent_config else ''),
+            inquirer.Text(
+                'agent_url', message='Agent URL', default=agent_config.get('url', '') if agent_config else ''
+            ),
+            inquirer.Text(
+                'agent_token', message='Agent Token', default=agent_config.get('token', '') if agent_config else ''
+            ),
+        ]
+
+        manual_answers = inquirer.prompt(manual_questions)
+        if manual_answers and manual_answers['agent_id']:
+            set_agent_config(
+                manual_answers['agent_id'], None, manual_answers.get('agent_url'), manual_answers.get('agent_token')
+            )
+            click.echo(click.style('\n✓ Agent configured!', fg='green'))
+            click.echo(f'Agent ID: {manual_answers["agent_id"]}')
+            if manual_answers.get('agent_url'):
+                click.echo(f'Agent URL: {manual_answers["agent_url"]}')
+        return
+
+
+def show_current_config():
+    """Show all current configuration"""
+    backend_config = get_backend_config()
+    agent_config = get_agent_config()
+
+    click.echo(click.style('\n📋 Current Configuration', fg='cyan', bold=True))
+    click.echo('=' * 30)
+
+    # Backend section
+    click.echo(click.style('\n🔗 Backend:', fg='blue', bold=True))
+    if backend_config:
+        click.echo(f'  Host: {backend_config["host"]}')
+        click.echo(f'  Token: {backend_config["token"][:8]}...')
+        click.echo(click.style('  Status: ✓ Configured', fg='green'))
+    else:
+        click.echo(click.style('  Status: ✗ Not configured', fg='red'))
+
+    # Agent section
+    click.echo(click.style('\n🤖 Agent:', fg='blue', bold=True))
+    if agent_config:
+        click.echo(f'  ID: {agent_config.get("id", "Not set")}')
+        if 'name' in agent_config:
+            click.echo(f'  Name: {agent_config["name"]}')
+        click.echo(click.style('  Status: ✓ Configured', fg='green'))
+    else:
+        click.echo(click.style('  Status: ✗ Not configured', fg='red'))
+
+
+def interactive_config():
+    while True:
+        clear_screen()
+        click.echo(click.style('🔧 Configuration', fg='cyan', bold=True))
+        click.echo('Configure your Synapse settings\n')
+
+        questions = [
+            inquirer.List(
+                'choice',
+                message='What would you like to configure?',
+                choices=[
+                    ('Synapse Backend Host', 'backend'),
+                    ('Synapse Agent', 'agent'),
+                    ('Show Current Config', 'show'),
+                    ('← Back to Main Menu', 'exit'),
+                ],
+            )
+        ]
+
+        try:
+            answers = inquirer.prompt(questions)
+            if not answers or answers['choice'] == 'exit':
+                clear_screen()  # Clear screen when exiting config
+                break
+
+            clear_screen()
+
+            if answers['choice'] == 'backend':
+                configure_backend()
+                click.echo('\nPress Enter to continue...')
+                input()
+            elif answers['choice'] == 'agent':
+                configure_agent()
+                click.echo('\nPress Enter to continue...')
+                input()
+            elif answers['choice'] == 'show':
+                show_current_config()
+                click.echo('\nPress Enter to continue...')
+                input()
+
+        except (KeyboardInterrupt, EOFError):
+            clear_screen()  # Clear screen on interrupt
+            break
+        except Exception as e:
+            click.echo(click.style(f'\nError: {str(e)}', fg='red'))
+            click.echo('\nPress Enter to continue...')
+            input()
+
+
+@click.command()
+def config():
+    """Configure Synapse settings interactively"""
+    interactive_config()

synapse_sdk/cli/devtools.py

@@ -0,0 +1,61 @@
+import os
+import sys
+
+import click
+
+from synapse_sdk.i18n import gettext as _
+
+
+@click.command()
+@click.option('--host', default=None, help='Host to bind the devtools server')
+@click.option('--port', default=None, type=int, help='Port to bind the devtools server')
+@click.option('--no-browser', is_flag=True, help='Do not open browser automatically')
+@click.option('--debug', is_flag=True, help='Run in debug mode')
+@click.option('--build', is_flag=True, help='Build frontend assets before starting server')
+def devtools(host, port, no_browser, debug, build):
+    """Start the Synapse devtools web interface"""
+
+    try:
+        from synapse_sdk.devtools.config import get_server_config
+        from synapse_sdk.devtools.server import create_devtools_server
+    except ImportError:
+        click.echo(
+            click.style(
+                _('Devtools dependencies not installed. Install with: pip install synapse-sdk[devtools]'), fg='red'
+            ),
+            err=True,
+        )
+        sys.exit(1)
+
+    if build:
+        click.echo('Building frontend assets...')
+        from synapse_sdk.cli import build_frontend
+
+        if not build_frontend():
+            click.echo(click.style('Build failed, continuing with existing assets...', fg='yellow'))
+
+    if debug:
+        click.echo(_('Starting devtools in debug mode...'))
+        os.environ['UVICORN_LOG_LEVEL'] = 'debug'
+
+    click.echo('Starting Synapse Devtools...')
+
+    # Get server configuration from config file
+    server_config = get_server_config()
+
+    # Use CLI arguments if provided, otherwise use config defaults
+    final_host = host if host is not None else server_config['host']
+    final_port = port if port is not None else server_config['port']
+
+    # Create and start the devtools server
+    # Pass the current working directory as the plugin directory
+    plugin_directory = os.getcwd()
+    server = create_devtools_server(host=final_host, port=final_port, plugin_directory=plugin_directory)
+
+    try:
+        server.start_server(open_browser=not no_browser)
+    except KeyboardInterrupt:
+        click.echo(_('\nDevtools stopped.'))
+    except Exception as e:
+        click.echo(click.style(f'Failed to start devtools: {e}', fg='red'), err=True)
+        sys.exit(1)

synapse_sdk/cli/plugin/publish.py

@@ -10,11 +10,10 @@ from synapse_sdk.plugins.upload import archive
 
 @click.command()
 @click.option('--host', required=True)
-@click.option('--user_token', required=True)
-@click.option('--tenant', required=True)
+@click.option('--access_token', required=True)
 @click.option('--debug_modules', default='', envvar='SYNAPSE_DEBUG_MODULES')
 @click.pass_context
-def publish(ctx, host, user_token, tenant, debug_modules):
+def publish(ctx, host, access_token, debug_modules):
     debug = ctx.obj['DEBUG']
 
     plugin_release = PluginRelease()
@@ -28,7 +27,7 @@ def publish(ctx, host, user_token, tenant, debug_modules):
         modules = debug_modules.split(',') if debug_modules else []
         data['meta'] = {'modules': modules}
 
-    client = BackendClient(host, user_token, tenant=tenant)
+    client = BackendClient(host, access_token)
     client.create_plugin_release(data)
     click.secho(
         _('Successfully published "{}" ({}) to synapse backend!').format(plugin_release.name, plugin_release.code),