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

synapse_sdk/__init__.py

@@ -0,0 +1,24 @@
+"""
+Export / Import Guidelines
+--------------------------
+
+1. Do NOT import the top-level package directly.
+   - All imports must start from at least two levels below the root package.
+     (e.g., `project.module.submodule` is allowed,
+            `project` 또는 `project.module` 단일 import는 금지)
+
+2. Wildcard import (`from x import *`) is strictly prohibited.
+   - 모든 외부 노출(export)은 명시적인 이름 기반으로 관리해야 한다.
+   - `__all__` 리스트를 통해 공개할 API를 명확히 정의할 것.
+
+3. Public API 를 구성할 때:
+   - 하위 모듈에서 export할 항목만 `__all__`에 선언한다.
+   - 내부 구현용 함수/클래스는 `_` prefix 를 사용하거나 `__all__`에 포함하지 않는다.
+
+4. 모듈 간 의존성은 최단 경로만 허용한다.
+   - 불필요한 상위/평행 패키지 import 경로는 금지하여 순환 의존성(circular dependency)을 방지한다.
+"""
+
+from synapse_sdk.shared import worker_process_setup_hook
+
+__all__ = ['worker_process_setup_hook']

synapse_sdk/cli/__init__.py

@@ -1,11 +1,316 @@
+import os
+
 import click
+import inquirer
+import requests
+
+from .code_server import code_server
+from .config import config
+from .devtools import devtools
+from .plugin import plugin
+
+
+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=True):
+    """Run devtools with default settings"""
+    # Import the devtools command and run it
+    from .devtools import devtools
+
+    # Use default settings
+    ctx = click.Context(devtools)
+    ctx.invoke(devtools, host=None, port=None, debug=False)
+
+
+# build_frontend function removed - no longer needed with Streamlit
+
+
+def run_config():
+    """Run the configuration menu"""
+    from .config import interactive_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
+def cli(ctx, dev_tools):
+    """Synapse SDK - Interactive CLI"""
+
+    # Handle --dev-tools flag
+    if dev_tools:
+        run_devtools()
+        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()
+
+            try:
+                questions = [
+                    inquirer.List(
+                        'choice',
+                        message='Select an option:',
+                        choices=[
+                            ('🌐 Run Dev Tools', 'devtools'),
+                            ('💻 Open Code-Server IDE', 'code_server'),
+                            ('⚙️  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
 
-from synapse_sdk.cli.create_plugin import create_plugin
+                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':
+                    run_plugin_management()
+                    # Don't break - continue to main menu loop
 
-@click.group()
-def cli():
-    pass
+            except (KeyboardInterrupt, EOFError):
+                clear_screen()
+                click.echo(click.style('👋 Goodbye!', fg='yellow'))
+                break
 
 
-cli.add_command(create_plugin)
+cli.add_command(plugin)
+cli.add_command(config)
+cli.add_command(devtools)
+cli.add_command(code_server)

synapse_sdk/cli/alias/__init__.py

@@ -0,0 +1,22 @@
+import click
+
+from .create import create
+from .default import default
+from .delete import delete
+from .list import list as list_cli
+from .read import read
+from .update import update
+
+
+@click.group()
+def alias():
+    """Manage aliases"""
+    pass
+
+
+alias.add_command(list_cli)
+alias.add_command(create)
+alias.add_command(read)
+alias.add_command(update)
+alias.add_command(delete)
+alias.add_command(default)

synapse_sdk/cli/alias/create.py

@@ -0,0 +1,36 @@
+import click
+
+from .dataclass import ENV_VARS
+from .utils import CONFIG_DIR, DEFAULT_FILE, ensure_config_dir, save_alias_field, set_default_alias
+
+
+@click.command()
+def create():
+    """Create a new alias."""
+    ensure_config_dir()
+    name = click.prompt('Enter alias name (eg. prod, test)', type=str)
+    alias_file = CONFIG_DIR / f'{name}.env'
+    if alias_file.exists():
+        click.echo(f"Alias '{name}' already exists.")
+        return
+    if alias_file.name == DEFAULT_FILE.name:
+        click.echo(f"Invalid alias name '{name}'.")
+        return
+
+    alias_data = {}
+
+    for key, value in ENV_VARS.items():
+        prompt_kwargs = {'text': value.name, 'type': value.type, 'show_default': value.show_default}
+        if bool(value.default):
+            prompt_kwargs['default'] = alias_data[value.default]
+
+        alias_data[key] = click.prompt(**prompt_kwargs)
+
+    for key, value in alias_data.items():
+        save_alias_field(name, key, value)
+
+    # Set the default alias if it is the first alias created
+    if not DEFAULT_FILE.exists():
+        set_default_alias(name)
+
+    click.echo(f"Alias '{name}' created.")

synapse_sdk/cli/alias/dataclass.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Union
+
+
+@dataclass
+class EnvVar:
+    name: str
+    type = str
+    default: Union[str, None] = None
+    show_default: bool = True
+
+
+ENV_VARS = {
+    'RAY_ADDRESS': EnvVar('RAY_ADDRESS'),
+    'RAY_DASHBOARD_ADDRESS': EnvVar('RAY_DASHBOARD_ADDRESS'),
+    'RAY_SERVE_ADDRESS': EnvVar('RAY_SERVE_ADDRESS'),
+    'SYNAPSE_PLUGIN_STORAGE': EnvVar('SYNAPSE_PLUGIN_STORAGE', default='', show_default=False),
+    'SYNAPSE_DEBUG_PLUGIN_PATH': EnvVar('SYNAPSE_DEBUG_PLUGIN_PATH', default='', show_default=False),
+    'SYNAPSE_DEBUG_MODULES': EnvVar('SYNAPSE_DEBUG_MODULES', default='', show_default=False),
+    'SYNAPSE_PLUGIN_PUBLISH_HOST': EnvVar('SYNAPSE_PLUGIN_PUBLISH_HOST'),
+    'SYNAPSE_PLUGIN_PUBLISH_USER_TOKEN': EnvVar('SYNAPSE_PLUGIN_PUBLISH_USER_TOKEN'),
+    'SYNAPSE_PLUGIN_PUBLISH_TENANT': EnvVar('SYNAPSE_PLUGIN_PUBLISH_TENANT'),
+    'SYNAPSE_PLUGIN_RUN_HOST': EnvVar('SYNAPSE_PLUGIN_RUN_HOST', default='SYNAPSE_PLUGIN_PUBLISH_HOST'),
+    'SYNAPSE_PLUGIN_RUN_AGENT': EnvVar('SYNAPSE_PLUGIN_RUN_AGENT', default='', show_default=False),
+    'SYNAPSE_PLUGIN_RUN_AGENT_TOKEN': EnvVar('SYNAPSE_PLUGIN_RUN_AGENT_TOKEN'),
+    'SYNAPSE_PLUGIN_RUN_AGENT_HOST': EnvVar('SYNAPSE_PLUGIN_RUN_AGENT_HOST'),
+    'SYNAPSE_PLUGIN_RUN_USER_TOKEN': EnvVar(
+        'SYNAPSE_PLUGIN_RUN_USER_TOKEN', default='SYNAPSE_PLUGIN_PUBLISH_USER_TOKEN'
+    ),
+    'SYNAPSE_PLUGIN_RUN_TENANT': EnvVar('SYNAPSE_PLUGIN_RUN_TENANT', default='SYNAPSE_PLUGIN_PUBLISH_TENANT'),
+}

synapse_sdk/cli/alias/default.py

@@ -0,0 +1,16 @@
+import click
+
+from .utils import load_alias, set_default_alias
+
+
+@click.command()
+@click.argument('name', required=True)
+def default(name):
+    """Set an alias as the default."""
+    alias_data = load_alias(name)
+    if not alias_data:
+        click.echo(f"Alias '{name}' does not exist.")
+        return
+
+    set_default_alias(name)
+    click.echo(f"Alias '{name}' is now the default.")

synapse_sdk/cli/alias/delete.py

@@ -0,0 +1,15 @@
+import click
+
+from .utils import delete_alias_file, load_alias
+
+
+@click.command()
+@click.argument('name', required=True)
+def delete(name):
+    """Delete an alias."""
+    alias_data = load_alias(name)
+    if not alias_data:
+        click.echo(f"Alias '{name}' does not exist.")
+        return
+    delete_alias_file(name)
+    click.echo(f"Alias '{name}' deleted.")

synapse_sdk/cli/alias/list.py

@@ -0,0 +1,19 @@
+import click
+
+from .utils import CONFIG_DIR, DEFAULT_FILE, ensure_config_dir, get_default_alias
+
+
+@click.command()
+def list():
+    """List all aliases."""
+    ensure_config_dir()
+    aliases = [f.stem for f in CONFIG_DIR.glob('*') if f.is_file() and f.stem != DEFAULT_FILE.stem]
+    default_alias = get_default_alias()
+    if not aliases:
+        click.echo('No aliases found.')
+        return
+    for alias_name in aliases:
+        if alias_name == default_alias:
+            click.echo(f'{alias_name} (default)')
+        else:
+            click.echo(alias_name)

synapse_sdk/cli/alias/read.py

@@ -0,0 +1,15 @@
+import click
+
+from .utils import load_alias
+
+
+@click.command()
+@click.argument('name', required=True)
+def read(name):
+    """Read an alias."""
+    alias_data = load_alias(name)
+    if not alias_data:
+        click.echo(f"Alias '{name}' does not exist.")
+        return
+    for key, value in alias_data.items():
+        click.echo(f'{key}: {value}')

synapse_sdk/cli/alias/update.py

@@ -0,0 +1,17 @@
+import click
+
+from .utils import load_alias, save_alias_field
+
+
+@click.command()
+@click.argument('name', required=True)
+@click.argument('field', required=True)
+@click.argument('value', required=True)
+def update(name, field, value):
+    """Update a specific field in an alias."""
+    alias_data = load_alias(name)
+    if not alias_data:
+        click.echo(f"Alias '{name}' does not exist.")
+        return
+    save_alias_field(name, field.upper(), value)
+    click.echo(f"Alias '{name}' updated. Field '{field}' is now '{value}'.")

synapse_sdk/cli/alias/utils.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+from dotenv import dotenv_values, load_dotenv, set_key, unset_key
+
+CONFIG_DIR = Path.home() / '.config' / 'synapse'
+DEFAULT_FILE = CONFIG_DIR / '__default__'
+
+
+def ensure_config_dir():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_alias(alias_name):
+    ensure_config_dir()
+    alias_file = CONFIG_DIR / alias_name
+    if not alias_file.exists():
+        return None
+    return dotenv_values(alias_file)
+
+
+# Save or update a field in an alias .env file
+def save_alias_field(alias_name, key, value):
+    ensure_config_dir()
+    alias_file = CONFIG_DIR / alias_name
+    set_key(alias_file, key, value)
+
+
+# Delete a field from an alias .env file
+def delete_alias_field(alias_name, key):
+    ensure_config_dir()
+    alias_file = CONFIG_DIR / alias_name
+    unset_key(alias_file, key)
+
+
+# Delete an alias .env file
+def delete_alias_file(alias_name):
+    ensure_config_dir()
+    alias_file = CONFIG_DIR / alias_name
+    if alias_file.exists():
+        alias_file.unlink()
+
+
+def get_default_alias():
+    ensure_config_dir()
+    if DEFAULT_FILE.exists():
+        default_data = dotenv_values(DEFAULT_FILE)
+        return default_data.get('DEFAULT_ALIAS')
+    return None
+
+
+# Set the default alias
+def set_default_alias(alias_name):
+    ensure_config_dir()
+    with open(DEFAULT_FILE, 'w') as f:
+        f.write(f'DEFAULT_ALIAS={alias_name}\n')
+
+
+def load_dotenv_default_alias():
+    default_alias = get_default_alias()
+    if default_alias is not None:
+        load_dotenv(CONFIG_DIR / default_alias)