synapse-sdk 1.0.0a98__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

synapse_sdk/cli/__init__.py

@@ -4,6 +4,7 @@ import click
 import inquirer
 import requests
 
+from .code_server import code_server
 from .config import config
 from .devtools import devtools
 from .plugin import plugin
@@ -108,88 +109,15 @@ def display_connection_status():
 
 def run_devtools(build=True):
     """Run devtools with default settings"""
-    try:
-        from synapse_sdk.devtools.config import get_server_config
-        from synapse_sdk.devtools.server import create_devtools_server
-        from synapse_sdk.devtools.utils import find_available_port, is_port_available
-
-        if build:
-            click.echo('Building...')
-            build_frontend()
-
-        click.echo('Starting Synapse Devtools...')
-
-        # Get server configuration defaults
-        server_config = get_server_config()
-        host = server_config['host']
-        port = server_config['port']
-
-        # Check if the port is available, fallback to next available port if not
-        if not is_port_available(host, port):
-            try:
-                fallback_port = find_available_port(host, port + 1)
-                click.echo(click.style(f'Port {port} is in use, falling back to port {fallback_port}', fg='yellow'))
-                port = fallback_port
-            except RuntimeError as e:
-                click.echo(click.style(f'Failed to find available port: {e}', fg='red'), err=True)
-                return
-
-        server = create_devtools_server(host=host, port=port)
-        server.start_server()
-    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 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
+    # Import the devtools command and run it
+    from .devtools import devtools
 
-        # Build the frontend
-        result = subprocess.run(['npm', 'run', 'build'], cwd=devtools_dir, capture_output=True, text=True)
+    # Use default settings
+    ctx = click.Context(devtools)
+    ctx.invoke(devtools, host=None, port=None, debug=False)
 
-        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('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
+# build_frontend function removed - no longer needed with Streamlit
 
 
 def run_config():
@@ -199,6 +127,128 @@ def run_config():
     interactive_config()
 
 
+def run_plugin_management():
+    """Run interactive plugin management"""
+    while True:
+        clear_screen()
+        click.echo(click.style('🔌 Plugin Management', fg='cyan', bold=True))
+        click.echo('Manage your Synapse plugins\n')
+
+        questions = [
+            inquirer.List(
+                'action',
+                message='What would you like to do?',
+                choices=[
+                    ('Create new plugin', 'create'),
+                    ('Run plugin locally', 'run'),
+                    ('Publish plugin', 'publish'),
+                    ('← Back to main menu', 'back'),
+                ],
+            )
+        ]
+
+        answers = inquirer.prompt(questions)
+        if not answers or answers['action'] == 'back':
+            clear_screen()
+            break
+
+        if answers['action'] == 'create':
+            click.echo('\nCreating new plugin...')
+            from .plugin.create import create
+
+            ctx = click.Context(create)
+            ctx.invoke(create)
+            click.echo('\nPress Enter to continue...')
+            input()
+
+        elif answers['action'] == 'run':
+            # Get plugin action and parameters
+            run_questions = [
+                inquirer.Text('action', message='Plugin action to run'),
+                inquirer.Text('params', message='Parameters (JSON format)', default='{}'),
+                inquirer.List(
+                    'run_by',
+                    message='Run by',
+                    choices=[
+                        ('Script (local)', 'script'),
+                        ('Agent', 'agent'),
+                        ('Backend', 'backend'),
+                    ],
+                    default='script',
+                ),
+            ]
+
+            run_answers = inquirer.prompt(run_questions)
+            if run_answers:
+                click.echo('\nRunning plugin...')
+                from .plugin.run import run
+
+                ctx = click.Context(run)
+                ctx.obj = {'DEBUG': False}
+
+                try:
+                    if run_answers['run_by'] == 'script':
+                        ctx.invoke(
+                            run,
+                            action=run_answers['action'],
+                            params=run_answers['params'],
+                            job_id=None,
+                            direct=False,
+                            run_by='script',
+                            agent_host=None,
+                            agent_token=None,
+                            host=None,
+                            agent=None,
+                            user_token=None,
+                            tenant=None,
+                        )
+                    else:
+                        click.echo(click.style('\nNote: For agent/backend runs, use the command line:', fg='yellow'))
+                        cmd = (
+                            f"synapse plugin run {run_answers['action']} '{run_answers['params']}' "
+                            f'--run-by {run_answers["run_by"]}'
+                        )
+                        click.echo(cmd)
+                except Exception as e:
+                    click.echo(click.style(f'\nError: {str(e)}', fg='red'))
+
+                click.echo('\nPress Enter to continue...')
+                input()
+
+        elif answers['action'] == 'publish':
+            # Get backend configuration
+            from synapse_sdk.devtools.config import get_backend_config
+
+            backend_config = get_backend_config()
+
+            if not backend_config:
+                click.echo(click.style('\n⚠ No backend configured. Please configure backend first.', fg='yellow'))
+                click.echo('\nPress Enter to continue...')
+                input()
+                continue
+
+            publish_questions = [
+                inquirer.Confirm('debug', message='Publish in debug mode?', default=True),
+                inquirer.Confirm('confirm', message=f'Publish plugin to {backend_config["host"]}?', default=True),
+            ]
+
+            publish_answers = inquirer.prompt(publish_questions)
+            if publish_answers and publish_answers['confirm']:
+                click.echo('\nPublishing plugin...')
+                from .plugin.publish import _publish
+
+                debug_mode = publish_answers.get('debug', True)
+                try:
+                    _publish(backend_config['host'], backend_config['token'], debug=debug_mode)
+                except Exception as e:
+                    click.echo(click.style(f'\nError: {str(e)}', fg='red'))
+                    click.echo('\nPress Enter to continue...')
+                    input()
+                else:
+                    click.echo('\nPress Enter to continue...')
+                    input()
+
+
 @click.group(invoke_without_command=True)
 @click.option('--dev-tools', is_flag=True, help='Start devtools immediately')
 @click.pass_context
@@ -215,7 +265,6 @@ def cli(ctx, dev_tools):
             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 = [
@@ -224,6 +273,7 @@ def cli(ctx, dev_tools):
                         message='Select an option:',
                         choices=[
                             ('🌐 Run Dev Tools', 'devtools'),
+                            ('💻 Code-Server IDE', 'code_server'),
                             ('⚙️  Configuration', 'config'),
                             ('🔌 Plugin Management', 'plugin'),
                             ('🚪 Exit', 'exit'),
@@ -240,14 +290,18 @@ def cli(ctx, dev_tools):
                 if answers['choice'] == 'devtools':
                     run_devtools()
                     break  # Exit after devtools finishes
+                elif answers['choice'] == 'code_server':
+                    from .code_server import code_server
+
+                    ctx.invoke(code_server)
+                    click.echo('\nPress Enter to return to main menu...')
+                    input()
+                    # Continue to main menu loop
                 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()
+                    run_plugin_management()
                     # Don't break - continue to main menu loop
 
             except (KeyboardInterrupt, EOFError):
@@ -259,3 +313,4 @@ def cli(ctx, dev_tools):
 cli.add_command(plugin)
 cli.add_command(config)
 cli.add_command(devtools)
+cli.add_command(code_server)

synapse_sdk/cli/code_server.py

@@ -0,0 +1,169 @@
+"""Code-server integration for remote plugin development."""
+
+from typing import Optional
+
+import click
+
+from synapse_sdk.cli.config import fetch_agents_from_backend, get_agent_config
+from synapse_sdk.devtools.config import get_backend_config
+
+
+@click.command()
+@click.option('--agent', help='Agent name or ID')
+@click.option('--open-browser/--no-open-browser', default=True, help='Open in browser')
+def code_server(agent: Optional[str], open_browser: bool):
+    """Connect to web-based code-server on an agent for plugin development."""
+
+    # Get current agent configuration
+    agent_config = get_agent_config()
+    backend_config = get_backend_config()
+
+    if not backend_config:
+        click.echo("❌ No backend configured. Run 'synapse config' first.")
+        return
+
+    # If no agent specified, use current agent or let user choose
+    if not agent:
+        if agent_config and agent_config.get('id'):
+            agent = agent_config['id']
+            click.echo(f'Using current agent: {agent_config.get("name", agent)}')
+        else:
+            # List available agents
+            agents, error = fetch_agents_from_backend()
+            if not agents:
+                click.echo('❌ No agents available. Check your backend configuration.')
+                return
+
+            if len(agents) == 1:
+                # If only one agent, use it
+                agent = agents[0]['id']
+                click.echo(f'Using agent: {agents[0].get("name", agent)}')
+            else:
+                # Let user choose
+                click.echo('Available agents:')
+                for i, agent_info in enumerate(agents, 1):
+                    status = agent_info.get('status_display', 'Unknown')
+                    name = agent_info.get('name', agent_info['id'])
+                    click.echo(f'  {i}. {name} ({status})')
+
+                try:
+                    choice = click.prompt('Select agent', type=int)
+                    if 1 <= choice <= len(agents):
+                        agent = agents[choice - 1]['id']
+                    else:
+                        click.echo('❌ Invalid selection')
+                        return
+                except (ValueError, EOFError, KeyboardInterrupt):
+                    click.echo('\n❌ Cancelled')
+                    return
+
+    # Connect to agent and get code-server info
+    try:
+        # Get agent details from backend to get the agent URL
+        from synapse_sdk.clients.backend import BackendClient
+
+        backend_client = BackendClient(backend_config['host'], access_token=backend_config['token'])
+
+        # Get agent information
+        try:
+            agent_info = backend_client._get(f'agents/{agent}/')
+        except Exception as e:
+            click.echo(f'❌ Failed to get agent information for: {agent}')
+            click.echo(f'Error: {e}')
+            return
+
+        if not agent_info or not agent_info.get('url'):
+            click.echo(f'❌ Agent {agent} does not have a valid URL')
+            click.echo(f'Agent info: {agent_info}')
+            return
+
+        # Get the agent token from local configuration
+        agent_token = agent_config.get('token')
+        if not agent_token:
+            click.echo('❌ No agent token found in configuration')
+            click.echo("Run 'synapse config' to configure the agent")
+            return
+
+        # Create agent client
+        from synapse_sdk.clients.agent import AgentClient
+
+        client = AgentClient(base_url=agent_info['url'], agent_token=agent_token, user_token=backend_config['token'])
+
+        # Get code-server information
+        try:
+            info = client.get_code_server_info()
+        except AttributeError:
+            # Fallback to direct API call if method doesn't exist
+            response = client._get('code-server/info/')
+            info = response if isinstance(response, dict) else {}
+        except Exception as e:
+            # Handle other errors
+            click.echo(f'❌ Failed to get code-server info: {e}')
+            click.echo(f'Agent URL: {agent_info.get("url")}')
+            click.echo('\nNote: The agent might not have code-server endpoint implemented yet.')
+            return
+
+        if not info or not info.get('available', False):
+            message = info.get('message', 'Code-server is not available') if info else 'Failed to get code-server info'
+            click.echo(f'❌ {message}')
+            click.echo('\nTo enable code-server, reinstall the agent with code-server support.')
+            return
+
+        # Display connection information
+        click.echo('\n✅ Code-Server is available!')
+
+        workspace = info.get('workspace', '/home/coder/workspace')
+
+        # Show web browser access
+        click.echo('\n🌐 Web-based VS Code:')
+        click.echo(f'   URL: {info["url"]}')
+        password = info.get('password')
+        if password:
+            click.echo(f'   Password: {password}')
+        else:
+            click.echo('   Password: Not required (passwordless mode)')
+
+        click.echo(f'\n📁 Workspace: {workspace}')
+
+        # Optionally open in browser
+        if open_browser and info.get('url'):
+            import subprocess
+
+            click.echo('\nAttempting to open in browser...')
+
+            # Try to open browser, suppressing stderr to avoid xdg-open noise
+            try:
+                # Use subprocess to suppress xdg-open errors
+                result = subprocess.run(['xdg-open', info['url']], capture_output=True, text=True, timeout=2)
+                if result.returncode != 0:
+                    click.echo('⚠️  Could not open browser automatically (no display?)')
+                    click.echo(f'👉 Please manually open: {info["url"]}')
+            except (subprocess.TimeoutExpired, FileNotFoundError):
+                # xdg-open not available or timed out
+                click.echo('⚠️  Could not open browser (headless environment)')
+                click.echo(f'👉 Please manually open: {info["url"]}')
+            except Exception:
+                # Fallback for other errors
+                click.echo(f'👉 Please manually open: {info["url"]}')
+
+        # Show additional instructions
+        click.echo('\n📝 Quick Start:')
+        click.echo('1. Open the URL in your browser')
+        click.echo('2. Enter the password if prompted')
+        click.echo('3. Start coding in the web-based VS Code!')
+
+    except Exception as e:
+        import traceback
+
+        click.echo(f'❌ Failed to connect to agent: {e}')
+
+        # Show more detailed error in debug mode
+        if '--debug' in click.get_current_context().params:
+            click.echo('\nDebug trace:')
+            click.echo(traceback.format_exc())
+
+        click.echo('\nTroubleshooting:')
+        click.echo('1. Check if agent is running and accessible')
+        click.echo('2. Verify the agent has code-server support (may need agent update)')
+        click.echo('3. Check agent logs for more details')
+        click.echo('4. Try running with --no-open-browser to see connection details')

synapse_sdk/cli/config.py

@@ -18,6 +18,81 @@ def clear_screen():
     os.system('cls' if os.name == 'nt' else 'clear')
 
 
+def check_backend_connection(host, token):
+    """Test backend connection with given credentials"""
+    try:
+        # Try an authenticated endpoint to verify token validity
+        response = requests.get(
+            f'{host}/users/me/',
+            headers={'Synapse-Access-Token': f'Token {token}'},
+            timeout=5,
+        )
+
+        if response.status_code == 200:
+            return True, 'Connection successful'
+        elif response.status_code == 401:
+            return False, 'Invalid token (401)'
+        elif response.status_code == 403:
+            return False, 'Access forbidden (403)'
+        elif response.status_code == 404:
+            # If /users/me/ doesn't exist, try /health as fallback
+            try:
+                health_response = requests.get(
+                    f'{host}/health',
+                    headers={'Synapse-Access-Token': f'Token {token}'},
+                    timeout=3,
+                )
+                if health_response.status_code == 200:
+                    return True, 'Connection successful'
+                elif health_response.status_code == 401:
+                    return False, 'Invalid token (401)'
+                elif health_response.status_code == 403:
+                    return False, 'Access forbidden (403)'
+                else:
+                    return False, f'HTTP {health_response.status_code}'
+            except Exception:
+                return False, 'Endpoint not found (404)'
+        else:
+            return False, f'HTTP {response.status_code}'
+
+    except requests.exceptions.Timeout:
+        return False, 'Connection timeout (>5s)'
+    except requests.exceptions.ConnectionError:
+        return False, 'Connection failed'
+    except Exception as e:
+        return False, f'Connection error: {str(e)}'
+
+
+def check_agent_connection(agent_url, agent_token):
+    """Test agent connection with given credentials"""
+    if not agent_url or not agent_token:
+        return True, 'Agent configured (no URL/token to test)'
+
+    try:
+        # Try to connect to the agent
+        response = requests.get(
+            f'{agent_url}/health/',
+            headers={'Authorization': agent_token},
+            timeout=5,
+        )
+
+        if response.status_code == 200:
+            return True, 'Agent connection successful'
+        elif response.status_code == 401:
+            return False, 'Invalid agent token (401)'
+        elif response.status_code == 403:
+            return False, 'Agent access forbidden (403)'
+        else:
+            return False, f'Agent HTTP {response.status_code}'
+
+    except requests.exceptions.Timeout:
+        return False, 'Agent connection timeout (>5s)'
+    except requests.exceptions.ConnectionError:
+        return False, 'Agent connection failed'
+    except Exception as e:
+        return False, f'Agent error: {str(e)}'
+
+
 def get_agent_config():
     """Get current agent configuration"""
     config = load_devtools_config()
@@ -121,7 +196,7 @@ def configure_backend():
 
     if backend_config:
         click.echo(f'Current backend: {backend_config["host"]}')
-        click.echo(f'Token: {backend_config["token"][:8]}...')
+        click.echo(f'Token: {backend_config["token"]}')
         click.echo()
 
     questions = [
@@ -164,7 +239,7 @@ def configure_backend():
                 message='Backend host URL',
                 default=backend_config['host'] if backend_config else 'https://api.synapse.sh',
             ),
-            inquirer.Password('token', message='API token'),
+            inquirer.Text('token', default=backend_config['token'] if backend_config else '', message='API token'),
         ]
 
         config_answers = inquirer.prompt(config_questions)
@@ -172,7 +247,15 @@ def configure_backend():
             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]}...')
+            click.echo(f'Token: {config_answers["token"]}')
+
+            # Test the connection
+            click.echo('\nTesting connection...')
+            success, message = check_backend_connection(config_answers['host'], config_answers['token'])
+            if success:
+                click.echo(click.style(f'🟢 {message}', fg='green'))
+            else:
+                click.echo(click.style(f'🔴 {message}', fg='red'))
 
 
 def configure_agent():
@@ -233,6 +316,15 @@ def configure_agent():
             if selected.get('url'):
                 click.echo(f'URL: {selected["url"]}')
 
+            # Test the agent connection if URL and token are provided
+            if selected.get('url') and selected.get('token'):
+                click.echo('\nTesting agent connection...')
+                success, message = check_agent_connection(selected['url'], selected['token'])
+                if success:
+                    click.echo(click.style(f'🟢 {message}', fg='green'))
+                else:
+                    click.echo(click.style(f'🔴 {message}', fg='red'))
+
     if answers['action'] == 'manual':
         manual_questions = [
             inquirer.Text('agent_id', message='Agent ID', default=agent_config.get('id', '') if agent_config else ''),
@@ -253,6 +345,15 @@ def configure_agent():
             click.echo(f'Agent ID: {manual_answers["agent_id"]}')
             if manual_answers.get('agent_url'):
                 click.echo(f'Agent URL: {manual_answers["agent_url"]}')
+
+            # Test the agent connection if URL and token are provided
+            if manual_answers.get('agent_url') and manual_answers.get('agent_token'):
+                click.echo('\nTesting agent connection...')
+                success, message = check_agent_connection(manual_answers['agent_url'], manual_answers['agent_token'])
+                if success:
+                    click.echo(click.style(f'🟢 {message}', fg='green'))
+                else:
+                    click.echo(click.style(f'🔴 {message}', fg='red'))
         return
 
 
@@ -268,7 +369,7 @@ def show_current_config():
     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(f'  Token: {backend_config["token"]}')
         click.echo(click.style('  Status: ✓ Configured', fg='green'))
     else:
         click.echo(click.style('  Status: ✗ Not configured', fg='red'))