runlayer 0.22.2__tar.gz → 0.23.0__tar.gz

{runlayer-0.22.2 → runlayer-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runlayer
-Version: 0.22.2
+Version: 0.23.0
 Summary: A command-line interface for running MCP servers via HTTP transport
 Project-URL: Homepage, https://runlayer.com
 Project-URL: Documentation, https://docs.runlayer.com/
@@ -421,6 +421,8 @@ DATABASE_URL=postgres://localhost/db
 LOG_LEVEL=debug
 ```
 
+**Limits:** Each `env` value in `runlayer.yaml` must be 2000 chars or less. If a value is too long, deploy validation fails and names the offending env var.
+
 **Note:** Variables from `.env` files override values from `os.environ`. The `$$VAR` syntax (double dollar sign) is reserved for backend variable substitution and will not be replaced by the CLI.
 
 ### `deploy validate` - Validate Configuration

{runlayer-0.22.2 → runlayer-0.23.0}/README.md

@@ -186,6 +186,8 @@ DATABASE_URL=postgres://localhost/db
 LOG_LEVEL=debug
 ```
 
+**Limits:** Each `env` value in `runlayer.yaml` must be 2000 chars or less. If a value is too long, deploy validation fails and names the offending env var.
+
 **Note:** Variables from `.env` files override values from `os.environ`. The `$$VAR` syntax (double dollar sign) is reserved for backend variable substitution and will not be replaced by the CLI.
 
 ### `deploy validate` - Validate Configuration

{runlayer-0.22.2 → runlayer-0.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "runlayer"
-version = "0.22.2"
+version = "0.23.0"
 description = "A command-line interface for running MCP servers via HTTP transport"
 readme = "README.md"
 requires-python = ">=3.10"

runlayer-0.23.0/runlayer_cli/commands/interactive_find.py

@@ -0,0 +1,100 @@
+from collections.abc import Callable, Sequence
+from typing import Literal, Protocol, TypeVar
+
+import questionary
+import typer
+
+T = TypeVar("T")
+
+
+class _ChoiceDetail(Protocol):
+    name: str
+    namespace: str | None
+    description: str | None
+
+
+def cancelled() -> None:
+    typer.echo("Cancelled.")
+    raise typer.Exit(0)
+
+
+def format_choice(item: _ChoiceDetail) -> str:
+    line = item.name
+    if item.namespace:
+        line += f"  ({item.namespace})"
+    if item.description:
+        line += f"  - {item.description}"
+    return line
+
+
+def prompt_items(
+    items: Sequence[T],
+    *,
+    noun: str,
+    format_item: Callable[[T], str],
+) -> list[T]:
+    if not items:
+        typer.echo(f"No {noun} available.")
+        raise typer.Exit(0)
+
+    selected = questionary.checkbox(
+        f"Select {noun} to install:",
+        choices=[
+            questionary.Choice(title=format_item(item), value=item) for item in items
+        ],
+        use_search_filter=True,
+        use_jk_keys=False,
+        instruction="(type to search, space to select)",
+    ).ask()
+    if not selected:
+        cancelled()
+    return list(selected)
+
+
+def prompt_clients(client_names: Sequence[str]) -> list[str]:
+    selected = questionary.checkbox(
+        "Select clients:",
+        choices=[
+            questionary.Choice(
+                title=client_name.replace("_", " ").title(),
+                value=client_name,
+                checked=client_name == "claude_code",
+            )
+            for client_name in sorted(client_names)
+        ],
+        use_search_filter=True,
+        use_jk_keys=False,
+        instruction="(type to search, space to select)",
+    ).ask()
+    if not selected:
+        cancelled()
+    return [str(client_name) for client_name in selected]
+
+
+def prompt_scope() -> Literal["project", "global"]:
+    selected = questionary.select(
+        "Install scope:",
+        choices=[
+            questionary.Choice(title="Project", value="project"),
+            questionary.Choice(title="Global", value="global"),
+        ],
+        use_jk_keys=False,
+        default="project",
+    ).ask()
+    if selected is None:
+        cancelled()
+    return selected
+
+
+def confirm_install(
+    *,
+    item_count: int,
+    client_count: int,
+    item_label: str,
+) -> None:
+    confirmed = questionary.confirm(
+        f"Install {item_count} {item_label} to {client_count} client(s)?",
+        default=True,
+    ).ask()
+    if not confirmed:
+        cancelled()

{runlayer-0.22.2 → runlayer-0.23.0}/runlayer_cli/commands/plugins.py

@@ -3,8 +3,16 @@ from pathlib import Path
 import anyio
 import structlog
 import typer
+from rich.console import Console
 
 from runlayer_cli.api import RunlayerClient
+from runlayer_cli.commands.interactive_find import (
+    confirm_install,
+    format_choice,
+    prompt_clients,
+    prompt_items,
+    prompt_scope,
+)
 from runlayer_cli.console import print_error
 from runlayer_cli.config import resolve_credentials, set_credentials_in_context
 from runlayer_cli.logging import setup_logging
@@ -26,6 +34,7 @@ from runlayer_cli.plugins.sync_engine import (
 )
 
 logger = structlog.get_logger(__name__)
+console = Console()
 
 app = typer.Typer(help="Manage plugins")
 
@@ -197,6 +206,94 @@ def push(
         raise typer.Exit(1)
 
 
+@app.command()
+def find(
+    ctx: typer.Context,
+    secret: str | None = typer.Option(
+        None, "--secret", "-s", envvar="RUNLAYER_API_KEY"
+    ),
+    host: str | None = typer.Option(None, "--host", "-H", envvar="RUNLAYER_HOST"),
+) -> None:
+    """Find and install one plugin from Runlayer API."""
+    log_file_path = setup_logging(command="plugins-find", quiet_console=False)
+
+    set_credentials_in_context(ctx, secret, host)
+    credentials = resolve_credentials(ctx, require_auth=True)
+
+    try:
+        api = RunlayerClient(hostname=credentials["host"], secret=credentials["secret"])
+        with console.status("Loading plugins..."):
+            plugins = sorted(
+                api.list_all_plugins(mine_only=False),
+                key=lambda plugin: (
+                    plugin.name.lower(),
+                    (plugin.namespace or "").lower(),
+                ),
+            )
+        selected_plugins = prompt_items(
+            plugins,
+            noun="plugins",
+            format_item=lambda plugin: format_choice(plugin),
+        )
+        resolved_clients = prompt_clients(list(_SUPPORTED_CLIENTS))
+        install_scope = prompt_scope()
+        global_install = install_scope == "global"
+        confirm_install(
+            item_count=len(selected_plugins),
+            client_count=len(resolved_clients),
+            item_label="plugin(s)",
+        )
+
+        async def _run() -> PluginInstallResult:
+            combined = PluginInstallResult()
+            for resolved_client in resolved_clients:
+                canonical, editor, lockfile = resolve_plugin_dirs(
+                    resolved_client, global_install, Path.cwd()
+                )
+
+                def on_progress(name: str, status: str) -> None:
+                    typer.echo(f"  {resolved_client} / {name}: {status}")
+
+                for selected_plugin in selected_plugins:
+                    result = await install_plugins(
+                        client=api,
+                        source=selected_plugin.id,
+                        install_all=False,
+                        plugin_name=None,
+                        canonical_dir=canonical,
+                        editor_dir=editor,
+                        lockfile_path=lockfile,
+                        client_name=resolved_client,
+                        host=credentials["host"],
+                        install_scope=install_scope,
+                        dry_run=False,
+                        on_progress=on_progress,
+                    )
+                    combined.installed.extend(result.installed)
+                    combined.skipped.extend(result.skipped)
+                    combined.errors.extend(result.errors)
+            return combined
+
+        result = anyio.run(_run)
+        parts = []
+        if result.installed:
+            parts.append(f"{len(result.installed)} installed")
+        if result.skipped:
+            parts.append(f"{len(result.skipped)} skipped")
+        typer.echo(f"Done: {', '.join(parts) if parts else 'nothing to do'}")
+
+        if result.errors:
+            for err in result.errors:
+                typer.secho(f"  Error: {err}", fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+    except typer.Exit:
+        raise
+    except Exception as e:
+        logger.error("find_failed", error=str(e), exc_info=True)
+        print_error(str(e), str(log_file_path))
+        raise typer.Exit(1)
+
+
 @app.command(
     name="list",
     help=(

{runlayer-0.22.2 → runlayer-0.23.0}/runlayer_cli/commands/skills.py

@@ -5,11 +5,19 @@ from pathlib import Path
 import anyio
 import structlog
 import typer
+from rich.console import Console
 
 from runlayer_cli.api import RunlayerClient, SkillScanResponse
 from runlayer_cli.console import print_error
 from runlayer_cli.config import resolve_credentials, set_credentials_in_context
 from runlayer_cli.logging import setup_logging
+from runlayer_cli.commands.interactive_find import (
+    confirm_install,
+    format_choice,
+    prompt_clients,
+    prompt_items,
+    prompt_scope,
+)
 from runlayer_cli.skills.discovery import discover_skills
 from runlayer_cli.skills.models import DiscoveredSkill
 from runlayer_cli.skills.installer import (
@@ -25,6 +33,7 @@ from runlayer_cli.skills.installer import (
 from runlayer_cli.skills.sync_engine import SyncResult, sync_skills
 
 logger = structlog.get_logger(__name__)
+console = Console()
 
 app = typer.Typer(help="Manage skills")
 
@@ -245,6 +254,90 @@ def scan(
         raise typer.Exit(1)
 
 
+@app.command()
+def find(
+    ctx: typer.Context,
+    secret: str | None = typer.Option(
+        None, "--secret", "-s", envvar="RUNLAYER_API_KEY"
+    ),
+    host: str | None = typer.Option(None, "--host", "-H", envvar="RUNLAYER_HOST"),
+) -> None:
+    """Find and install one skill from Runlayer API."""
+    log_file_path = setup_logging(command="skills-find", quiet_console=False)
+
+    set_credentials_in_context(ctx, secret, host)
+    credentials = resolve_credentials(ctx, require_auth=True)
+
+    try:
+        api = RunlayerClient(hostname=credentials["host"], secret=credentials["secret"])
+        with console.status("Loading skills..."):
+            skills = sorted(
+                api.list_all_skills(mine_only=False),
+                key=lambda skill: (skill.name.lower(), (skill.namespace or "").lower()),
+            )
+        selected_skills = prompt_items(
+            skills,
+            noun="skills",
+            format_item=lambda skill: format_choice(skill),
+        )
+        resolved_clients = prompt_clients(list(SKILLS_DIR_MAP))
+        install_scope = prompt_scope()
+        global_install = install_scope == "global"
+        confirm_install(
+            item_count=len(selected_skills),
+            client_count=len(resolved_clients),
+            item_label="skill(s)",
+        )
+
+        async def _run() -> InstallResult:
+            combined = InstallResult()
+            for resolved_client in resolved_clients:
+                canonical, editor, lockfile = resolve_dirs(
+                    resolved_client, global_install, Path.cwd()
+                )
+
+                def on_progress(name: str, status: str) -> None:
+                    typer.echo(f"  {resolved_client} / {name}: {status}")
+
+                for selected_skill in selected_skills:
+                    result = await install_skills(
+                        client=api,
+                        source=selected_skill.id,
+                        install_all=False,
+                        skill_name=None,
+                        canonical_dir=canonical,
+                        editor_dir=editor,
+                        lockfile_path=lockfile,
+                        client_name=resolved_client,
+                        install_scope=install_scope,
+                        dry_run=False,
+                        on_progress=on_progress,
+                    )
+                    combined.installed.extend(result.installed)
+                    combined.skipped.extend(result.skipped)
+                    combined.errors.extend(result.errors)
+            return combined
+
+        result = anyio.run(_run)
+        parts = []
+        if result.installed:
+            parts.append(f"{len(result.installed)} installed")
+        if result.skipped:
+            parts.append(f"{len(result.skipped)} skipped")
+        typer.echo(f"Done: {', '.join(parts) if parts else 'nothing to do'}")
+
+        if result.errors:
+            for err in result.errors:
+                typer.secho(f"  Error: {err}", fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+    except typer.Exit:
+        raise
+    except Exception as e:
+        logger.error("find_failed", error=str(e), exc_info=True)
+        print_error(str(e), str(log_file_path))
+        raise typer.Exit(1)
+
+
 @app.command(name="list")
 def list_skills(
     client_name: str | None = typer.Option(

{runlayer-0.22.2 → runlayer-0.23.0}/runlayer_cli/deploy/docker_builder.py

@@ -45,13 +45,31 @@ def check_docker_available() -> bool:
         return False
 
 
-def authenticate_ecr(credentials: ECRCredentials) -> None:
+def get_registry_hostname(registry_url: str) -> str:
+    """Normalize registry URLs to the hostname Docker expects."""
+    return registry_url.replace("https://", "").replace("http://", "")
+
+
+def get_registry_auth_config(credentials: ECRCredentials) -> dict[str, str]:
+    """Build request-scoped registry auth for Docker SDK calls."""
+    registry = get_registry_hostname(credentials.registry_url)
+    return {
+        "username": credentials.username,
+        "password": credentials.password,
+        "serveraddress": registry,
+    }
+
+
+def authenticate_ecr(credentials: ECRCredentials) -> dict[str, str]:
     """
     Authenticate Docker with ECR using provided credentials.
 
     Args:
         credentials: ECR credentials from backend
 
+    Returns:
+        Auth config that can be reused by later Docker SDK calls
+
     Raises:
         DockerException: If authentication fails
     """
@@ -73,11 +91,8 @@ def authenticate_ecr(credentials: ECRCredentials) -> None:
                 "Please get fresh credentials and try again."
             )
 
-        client = docker.from_env()
-
-        registry = credentials.registry_url.replace("https://", "").replace(
-            "http://", ""
-        )
+        registry = get_registry_hostname(credentials.registry_url)
+        auth_config = get_registry_auth_config(credentials)
 
         with Progress(
             SpinnerColumn(),
@@ -121,6 +136,7 @@ def authenticate_ecr(credentials: ECRCredentials) -> None:
                 console.print("[dim]Retrying with Docker SDK instead...[/dim]")
 
                 try:
+                    client = docker.from_env()
                     client.login(
                         username=credentials.username,
                         password=credentials.password,
@@ -133,6 +149,8 @@ def authenticate_ecr(credentials: ECRCredentials) -> None:
                 except Exception as sdk_error:
                     raise DockerException(f"Failed to authenticate: {sdk_error}")
 
+        return auth_config
+
     except APIError as e:
         raise DockerException(f"Failed to authenticate with ECR: {e}")
 
@@ -274,12 +292,13 @@ def tag_image(image_id: str, repository: str, tag: str) -> str:
         raise DockerException(f"Failed to tag image: {e}")
 
 
-def push_image(image_tag: str) -> str:
+def push_image(image_tag: str, auth_config: Optional[dict[str, str]] = None) -> str:
     """
     Push a Docker image to a registry and get its digest.
 
     Args:
         image_tag: Full image tag (e.g., "registry/repo:tag")
+        auth_config: Optional request-scoped auth for the registry
 
     Returns:
         Image digest (SHA256 hash) of the pushed image
@@ -302,7 +321,11 @@ def push_image(image_tag: str) -> str:
         ) as progress:
             task = progress.add_task(description="Starting push...", total=None)
 
-            for line in client.images.push(image_tag, stream=True, decode=True):
+            push_kwargs: dict[str, Any] = {"stream": True, "decode": True}
+            if auth_config:
+                push_kwargs["auth_config"] = auth_config
+
+            for line in client.images.push(image_tag, **push_kwargs):
                 if "error" in line:
                     error_msg = line.get("error", "Unknown error")
                     console.print(f"\n[red]ERROR: {error_msg}[/red]\n")
@@ -387,7 +410,7 @@ def build_and_push(
         DockerPushError: If push fails
     """
     # Authenticate with ECR
-    authenticate_ecr(credentials)
+    auth_config = authenticate_ecr(credentials)
 
     # Build the image with a local tag first
     local_tag = f"runlayer-build:{tag}"
@@ -404,6 +427,6 @@ def build_and_push(
     full_image_uri = tag_image(image_id, repository, tag)
 
     # Push to ECR and get digest
-    image_digest = push_image(full_image_uri)
+    image_digest = push_image(full_image_uri, auth_config=auth_config)
 
     return full_image_uri, image_digest

{runlayer-0.22.2 → runlayer-0.23.0}/runlayer_cli/deploy/service.py

@@ -293,11 +293,18 @@ def deploy_service(
     else:
         time_str = f"{seconds}s"
 
+    deployment_url = f"{host}/deploy/{deployment_id}"
+
     typer.secho(
         f"\n⏱️  Total deployment time: {time_str}",
         fg=typer.colors.CYAN,
         bold=True,
     )
+    typer.secho(
+        f"🔗 View deployment: {deployment_url}",
+        fg=typer.colors.CYAN,
+        bold=True,
+    )
 
 
 def _get_or_create_deployment(
@@ -485,9 +492,9 @@ def _push_to_ecr(
 
     typer.echo("Pushing image to ECR...\n")
     try:
-        authenticate_ecr(ecr_creds)
+        auth_config = authenticate_ecr(ecr_creds)
         full_image_uri = tag_image(image_id, repository, deployment_id)
-        image_digest = push_image(full_image_uri)
+        image_digest = push_image(full_image_uri, auth_config=auth_config)
 
         # Use digest-based reference for immutable deployments
         # This ensures ECS detects changes even with the same tag

{runlayer-0.22.2 → runlayer-0.23.0}/runlayer_cli/env_substitution.py

@@ -57,7 +57,7 @@ def load_env_vars(
     # Load .env file if found (overrides os.environ)
     if env_path:
         # Load .env file into a dict (doesn't modify os.environ)
-        dotenv_vars = dotenv_values(env_path)
+        dotenv_vars = dotenv_values(env_path, encoding="utf-8-sig")
 
         # Merge dotenv_vars into env_vars (dotenv file overrides os.environ)
         # Filter out None values (unset variables in .env file)

{runlayer-0.22.2 → runlayer-0.23.0}/tests/test_deploy_service.py

@@ -225,6 +225,11 @@ def test_push_to_ecr_success(mock_api_client):
         patch("runlayer_cli.deploy.service.push_image") as mock_push,
         patch("runlayer_cli.deploy.service.typer"),
     ):
+        mock_auth.return_value = {
+            "username": "AWS",
+            "password": "test-password",
+            "serveraddress": "123456789.dkr.ecr.us-east-1.amazonaws.com",
+        }
         mock_tag.return_value = (
             "123456789.dkr.ecr.us-east-1.amazonaws.com/my-repo:test-deployment-id"
         )
@@ -238,7 +243,10 @@ def test_push_to_ecr_success(mock_api_client):
         assert result == expected_uri
         mock_auth.assert_called_once()
         mock_tag.assert_called_once()
-        mock_push.assert_called_once()
+        mock_push.assert_called_once_with(
+            "123456789.dkr.ecr.us-east-1.amazonaws.com/my-repo:test-deployment-id",
+            auth_config=mock_auth.return_value,
+        )
 
 
 def test_update_deployment_config_success(mock_api_client):
@@ -504,6 +512,29 @@ def test_validate_runlayer_yaml_config_http_error(mock_api_client):
         assert exc_info.value.exit_code == 1
 
 
+def test_validate_runlayer_yaml_config_shows_backend_env_limit_error(mock_api_client):
+    """Test backend env limit error is surfaced unchanged."""
+    yaml_content = "name: test-service\nruntime: docker\nservice:\n  port: 8000\n"
+
+    mock_response = ValidateYAMLResponse(
+        valid=False,
+        error="Configuration error: env.API_KEY is too long (2001 chars, max 2000)",
+        parsed_config=None,
+    )
+    mock_api_client.validate_yaml.return_value = mock_response
+
+    with (
+        patch("runlayer_cli.deploy.service.typer.echo") as _mock_echo,
+        patch("runlayer_cli.deploy.service.typer.secho") as mock_secho,
+    ):
+        with pytest.raises(typer.Exit) as exc_info:
+            _validate_runlayer_yaml_config(mock_api_client, yaml_content)
+
+        assert exc_info.value.exit_code == 1
+        rendered_calls = [str(call) for call in mock_secho.call_args_list]
+        assert any("env.API_KEY is too long" in call for call in rendered_calls)
+
+
 def test_validate_service_success():
     """Test successful validation service call."""
     with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: