outerbounds 0.3.179rc5__py3-none-any.whl → 0.3.180rc0__py3-none-any.whl

outerbounds/apps/app_cli.py

@@ -1,7 +1,8 @@
 import json
 import os
 import sys
-from functools import wraps
+import random
+from functools import wraps, partial
 from typing import Dict, List, Any, Optional, Union
 
 # IF this CLI is supposed to be reusable across Metaflow Too
@@ -15,6 +16,10 @@ from typing import Dict, List, Any, Optional, Union
 # That will break the CLI.
 # So we need to find a way to import click without having it try to check for remote-config
 # or load the config from the environment.
+# If we import click from metaflow over here then it might
+# end up creating issues with click in general. So we need to figure a
+# way to figure the right import of click dynamically. a neat way to handle that would be
+# to have a function that can import the correct click based on the context in which stuff is being loaded.
 from metaflow._vendor import click
 from outerbounds._vendor import yaml
 from outerbounds.utils import metaflowconfig
@@ -27,19 +32,40 @@ from .app_config import (
 )
 from .perimeters import PerimeterExtractor
 from .cli_to_config import build_config_from_options
-from .utils import CommaSeparatedListType, KVPairType, KVDictType
+from .utils import (
+    CommaSeparatedListType,
+    KVPairType,
+    KVDictType,
+    MultiStepSpinner,
+)
 from . import experimental
 from .validations import deploy_validations
 from .code_package import CodePackager
-from .capsule import CapsuleDeployer, list_and_filter_capsules, CapsuleApi
+from .capsule import (
+    CapsuleDeployer,
+    list_and_filter_capsules,
+    CapsuleApi,
+    DEPLOYMENT_READY_CONDITIONS,
+)
+from .dependencies import bake_deployment_image
 import shlex
 import time
 import uuid
 from datetime import datetime
 
-LOGGER_TIMESTAMP = "magenta"
-LOGGER_COLOR = "green"
-LOGGER_BAD_COLOR = "red"
+
+class ColorTheme:
+    TIMESTAMP = "magenta"
+    LOADING_COLOR = "cyan"
+    BAD_COLOR = "red"
+    INFO_COLOR = "green"
+
+    TL_HEADER_COLOR = "magenta"
+    ROW_COLOR = "bright_white"
+
+    INFO_KEY_COLOR = "green"
+    INFO_VALUE_COLOR = "bright_white"
+
 
 NativeList = list
 
@@ -53,17 +79,48 @@ def _logger(
         else:
             dt = timestamp
         tstamp = dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
-        click.secho(tstamp + " ", fg=LOGGER_TIMESTAMP, nl=False)
+        click.secho(tstamp + " ", fg=ColorTheme.TIMESTAMP, nl=False)
     if head:
-        click.secho(head, fg=LOGGER_COLOR, nl=False)
+        click.secho(head, fg=ColorTheme.INFO_COLOR, nl=False)
     click.secho(
         body,
         bold=system_msg,
-        fg=LOGGER_BAD_COLOR if bad else color if color is not None else None,
+        fg=ColorTheme.BAD_COLOR if bad else color if color is not None else None,
         nl=nl,
     )
 
 
+def _logger_styled(
+    body="", system_msg=False, head="", bad=False, timestamp=True, nl=True, color=None
+):
+    message_parts = []
+
+    if timestamp:
+        if timestamp is True:
+            dt = datetime.now()
+        else:
+            dt = timestamp
+        tstamp = dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        message_parts.append(click.style(tstamp + " ", fg=ColorTheme.TIMESTAMP))
+
+    if head:
+        message_parts.append(click.style(head, fg=ColorTheme.INFO_COLOR))
+
+    message_parts.append(
+        click.style(
+            body,
+            bold=system_msg,
+            fg=ColorTheme.BAD_COLOR if bad else color if color is not None else None,
+        )
+    )
+
+    return "".join(message_parts)
+
+
+def _spinner_logger(spinner, *msg):
+    spinner.log(*[_logger_styled(x, timestamp=True) for x in msg])
+
+
 class CliState(object):
     pass
 
@@ -81,6 +138,7 @@ def _pre_create_debug(app_config: AppConfig, capsule: CapsuleDeployer, state_dir
                     {
                         "app_state": app_config.dump_state(),
                         "capsule_input": capsule.create_input(),
+                        "deploy_response": capsule._capsule_deploy_response,
                     },
                     default_flow_style=False,
                     indent=2,
@@ -88,8 +146,22 @@ def _pre_create_debug(app_config: AppConfig, capsule: CapsuleDeployer, state_dir
             )
 
 
+def _post_create_debug(capsule: CapsuleDeployer, state_dir: str):
+    if CAPSULE_DEBUG:
+        debug_path = os.path.join(
+            state_dir, f"debug_deploy_response_{time.time()}.yaml"
+        )
+        with open(debug_path, "w") as f:
+            f.write(
+                yaml.dump(
+                    capsule._capsule_deploy_response, default_flow_style=False, indent=2
+                )
+            )
+
+
 def print_table(data, headers):
     """Print data in a formatted table."""
+
     if not data:
         return
 
@@ -105,17 +177,17 @@ def print_table(data, headers):
     header_row = " | ".join(
         [headers[i].ljust(col_widths[i]) for i in range(len(headers))]
     )
-    click.secho("-" * len(header_row), fg="yellow")
-    click.secho(header_row, fg="yellow", bold=True)
-    click.secho("-" * len(header_row), fg="yellow")
+    click.secho("-" * len(header_row), fg=ColorTheme.TL_HEADER_COLOR)
+    click.secho(header_row, fg=ColorTheme.TL_HEADER_COLOR, bold=True)
+    click.secho("-" * len(header_row), fg=ColorTheme.TL_HEADER_COLOR)
 
     # Print data rows
     for row in data:
         formatted_row = " | ".join(
             [str(row[i]).ljust(col_widths[i]) for i in range(len(row))]
         )
-        click.secho(formatted_row, fg="green", bold=True)
-    click.secho("-" * len(header_row), fg="yellow")
+        click.secho(formatted_row, fg=ColorTheme.ROW_COLOR, bold=True)
+    click.secho("-" * len(header_row), fg=ColorTheme.TL_HEADER_COLOR)
 
 
 @click.group()
@@ -173,6 +245,33 @@ def parse_commands(app_config: AppConfig, cli_command_input):
     return base_commands
 
 
+def deployment_instance_options(func):
+    # These parameters influence how the CLI behaves for each instance of a launched deployment.
+    @click.option(
+        "--readiness-condition",
+        type=click.Choice(DEPLOYMENT_READY_CONDITIONS.enums()),
+        help=DEPLOYMENT_READY_CONDITIONS.__doc__,
+        default=DEPLOYMENT_READY_CONDITIONS.ATLEAST_ONE_RUNNING,
+    )
+    @click.option(
+        "--readiness-wait-time",
+        type=int,
+        help="The time (in seconds) to monitor the deployment for readiness after the readiness condition is met.",
+        default=4,
+    )
+    @click.option(
+        "--max-wait-time",
+        type=int,
+        help="The maximum time (in seconds) to wait for the deployment to be ready.",
+        default=600,
+    )
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
 def common_deploy_options(func):
     @click.option(
         "--name",
@@ -291,6 +390,12 @@ def common_deploy_options(func):
         help="The type of app to deploy.",
         default=None,
     )
+    @click.option(
+        "--force-upgrade",
+        is_flag=True,
+        help="Force upgrade the app even if it is currently being upgraded.",
+        default=False,
+    )
     @wraps(func)
     def wrapper(*args, **kwargs):
         return func(*args, **kwargs)
@@ -395,10 +500,18 @@ def _package_necessary_things(app_config: AppConfig, logger):
 @app.command(help="Deploy an app to the Outerbounds Platform.")
 @common_deploy_options
 @common_run_options
+@deployment_instance_options
 @experimental.wrapping_cli_options
 @click.pass_context
 @click.argument("command", nargs=-1, type=click.UNPROCESSED, required=False)
-def deploy(ctx, command, **options):
+def deploy(
+    ctx,
+    command,
+    readiness_condition=None,
+    max_wait_time=None,
+    readiness_wait_time=None,
+    **options,
+):
     """Deploy an app to the Outerbounds Platform."""
     from functools import partial
 
@@ -423,7 +536,7 @@ def deploy(ctx, command, **options):
         app_config.validate()
         logger(
             f"🚀 Deploying {app_config.get('name')} to the Outerbounds platform...",
-            color=LOGGER_COLOR,
+            color=ColorTheme.INFO_COLOR,
             system_msg=True,
         )
 
@@ -494,11 +607,31 @@ def deploy(ctx, command, **options):
         cache_dir = os.path.join(
             ctx.obj.app_state_dir, app_config.get("name", "default")
         )
+
         deploy_validations(
             app_config,
             cache_dir=cache_dir,
             logger=logger,
         )
+        with MultiStepSpinner(
+            text=lambda: _logger_styled(
+                "🍞 Baking Docker Image",
+                timestamp=True,
+            ),
+            color=ColorTheme.LOADING_COLOR,
+        ) as spinner:
+            _ctx_lgr = partial(_spinner_logger, spinner)
+            baking_status = bake_deployment_image(
+                app_config=app_config,
+                cache_file_path=os.path.join(cache_dir, "image_cache"),
+                logger=_ctx_lgr,
+            )
+            app_config.set_state(
+                "image",
+                baking_status.resolved_image,
+            )
+            app_config.set_state("python_path", baking_status.python_path)
+            _ctx_lgr("🐳 Using The Docker Image : %s" % app_config.get_state("image"))
 
         base_commands = parse_commands(app_config, command)
 
@@ -513,22 +646,74 @@ def deploy(ctx, command, **options):
         app_config.set_state("perimeter", ctx.obj.perimeter)
 
         # 2. Convert to the IR that the backend accepts
-        capsule = CapsuleDeployer(app_config, ctx.obj.api_url, debug_dir=cache_dir)
+        capsule = CapsuleDeployer(
+            app_config,
+            ctx.obj.api_url,
+            debug_dir=cache_dir,
+            success_terminal_state_condition=readiness_condition,
+            create_timeout=max_wait_time,
+            readiness_wait_time=readiness_wait_time,
+        )
+        currently_present_capsules = list_and_filter_capsules(
+            capsule.capsule_api,
+            None,
+            None,
+            capsule.name,
+            None,
+            None,
+            None,
+        )
+
+        force_upgrade = app_config.get_state("force_upgrade", False)
 
         _pre_create_debug(app_config, capsule, cache_dir)
+
+        if len(currently_present_capsules) > 0:
+            # Only update the capsule if there is no upgrade in progress
+            # Only update a "already updating" capsule if the `--force-upgrade` flag is provided.
+            _curr_cap = currently_present_capsules[0]
+            this_capsule_is_being_updated = _curr_cap.get("status", {}).get(
+                "updateInProgress", False
+            )
+
+            if this_capsule_is_being_updated and not force_upgrade:
+                _upgrader = _curr_cap.get("metadata", {}).get("lastModifiedBy", None)
+                message = f"{capsule.capsule_type} is currently being upgraded"
+                if _upgrader:
+                    message = (
+                        f"{capsule.capsule_type} is currently being upgraded. Upgrade was launched by {_upgrader}. "
+                        "If you wish to force upgrade, you can do so by providing the `--force-upgrade` flag."
+                    )
+                raise AppConfigError(message)
+            logger(
+                f"🚀 {'' if not force_upgrade else 'Force'} Upgrading {capsule.capsule_type.lower()} `{capsule.name}`....",
+                color=ColorTheme.INFO_COLOR,
+                system_msg=True,
+            )
+        else:
+            logger(
+                f"🚀 Deploying {capsule.capsule_type.lower()} to the platform....",
+                color=ColorTheme.INFO_COLOR,
+                system_msg=True,
+            )
         # 3. Throw the job into the platform and report deployment status
-        logger(
-            f"🚀 Deploying {capsule.capsule_type.lower()} to the platform...",
-            color=LOGGER_COLOR,
-            system_msg=True,
-        )
         capsule.create()
-        capsule.wait_for_terminal_state(logger=logger)
-        logger(
-            f"💊 {capsule.capsule_type} {app_config.config['name']} ({capsule.identifier}) deployed successfully! You can access it at {capsule.status.out_of_cluster_url}",
-            color=LOGGER_COLOR,
-            system_msg=True,
-        )
+        _post_create_debug(capsule, cache_dir)
+
+        with MultiStepSpinner(
+            text=lambda: _logger_styled(
+                "💊 Waiting for %s %s to be ready to serve traffic"
+                % (capsule.capsule_type.lower(), capsule.identifier),
+                timestamp=True,
+            ),
+            color=ColorTheme.LOADING_COLOR,
+        ) as spinner:
+            capsule.wait_for_terminal_state(logger=partial(_spinner_logger, spinner))
+            logger(
+                f"💊 {capsule.capsule_type} {app_config.config['name']} ({capsule.identifier}) deployed successfully! You can access it at {capsule.status.out_of_cluster_url}",
+                color=ColorTheme.INFO_COLOR,
+                system_msg=True,
+            )
 
     except AppConfigError as e:
         click.echo(f"Error in app configuration: {e}", err=True)
@@ -593,9 +778,12 @@ def _parse_capsule_table(filtered_capsules):
 @click.pass_context
 def list(ctx, project, branch, name, tags, format, auth_type):
     """List apps in the Outerbounds Platform."""
-
+    capsule_api = CapsuleApi(
+        ctx.obj.api_url,
+        ctx.obj.perimeter,
+    )
     filtered_capsules = list_and_filter_capsules(
-        ctx.obj.api_url, ctx.obj.perimeter, project, branch, name, tags, auth_type, None
+        capsule_api, project, branch, name, tags, auth_type, None
     )
     if format == "json":
         click.echo(json.dumps(filtered_capsules, indent=4))
@@ -634,8 +822,9 @@ def delete(ctx, name, cap_id, project, branch, tags):
             "Atleast one of the options need to be provided. You can use --name, --id, --project, --branch, --tag"
         )
 
+    capsule_api = CapsuleApi(ctx.obj.api_url, ctx.obj.perimeter)
     filtered_capsules = list_and_filter_capsules(
-        ctx.obj.api_url, ctx.obj.perimeter, project, branch, name, tags, None, cap_id
+        capsule_api, project, branch, name, tags, None, cap_id
     )
 
     headers, table_data = _parse_capsule_table(filtered_capsules)
@@ -658,18 +847,22 @@ def delete(ctx, name, cap_id, project, branch, tags):
             return None
         name = x.get("spec", {}).get("displayName", "")
         id = x.get("id", "")
-        return click.style("💊 deleting %s [%s]" % (name, id), fg="red", bold=True)
+        return click.style(
+            "💊 deleting %s [%s]" % (name, id),
+            fg=ColorTheme.BAD_COLOR,
+            bold=True,
+        )
 
     with click.progressbar(
         filtered_capsules,
-        label=click.style("💊 Deleting apps...", fg="red", bold=True),
-        fill_char=click.style("█", fg="red", bold=True),
-        empty_char=click.style("░", fg="red", bold=True),
+        label=click.style("💊 Deleting apps...", fg=ColorTheme.BAD_COLOR, bold=True),
+        fill_char=click.style("█", fg=ColorTheme.BAD_COLOR, bold=True),
+        empty_char=click.style("░", fg=ColorTheme.BAD_COLOR, bold=True),
         item_show_func=item_show_func,
     ) as bar:
-        capsule_api = CapsuleApi(ctx.obj.api_url, ctx.obj.perimeter)
         for capsule in bar:
             capsule_api.delete(capsule.get("id"))
+            time.sleep(0.5 + random.random() * 2)  # delay to avoid rate limiting
 
 
 @app.command(help="Run an app locally (for testing).")
@@ -713,5 +906,363 @@ def run(ctx, **options):
         ctx.exit(1)
 
 
+@app.command(
+    help="Get detailed information about an app from the Outerbounds Platform."
+)
+@click.option("--name", type=str, help="Get info for app by name")
+@click.option("--id", "cap_id", type=str, help="Get info for app by id")
+@click.option(
+    "--format",
+    type=click.Choice(["json", "text"]),
+    help="Format the output",
+    default="text",
+)
+@click.pass_context
+def info(ctx, name, cap_id, format):
+    """Get detailed information about an app from the Outerbounds Platform."""
+    # Require either name or id
+    if not any([name is not None, cap_id is not None]):
+        raise AppConfigError(
+            "Either --name or --id must be provided to get app information."
+        )
+
+    # Ensure only one is provided
+    if name is not None and cap_id is not None:
+        raise AppConfigError("Please provide either --name or --id, not both.")
+
+    capsule_api = CapsuleApi(
+        ctx.obj.api_url,
+        ctx.obj.perimeter,
+    )
+
+    # First, find the capsule using list_and_filter_capsules
+    filtered_capsules = list_and_filter_capsules(
+        capsule_api, None, None, name, None, None, cap_id
+    )
+
+    if len(filtered_capsules) == 0:
+        identifier = name if name else cap_id
+        identifier_type = "name" if name else "id"
+        raise AppConfigError(f"No app found with {identifier_type}: {identifier}")
+
+    if len(filtered_capsules) > 1:
+        raise AppConfigError(
+            f"Multiple apps found with name: {name}. Please use --id to specify exactly which app you want info for."
+        )
+
+    # Get the capsule info
+    capsule = filtered_capsules[0]
+    capsule_id = capsule.get("id")
+
+    # Get detailed capsule info and workers
+    try:
+        detailed_capsule_info = capsule_api.get(capsule_id)
+        workers_info = capsule_api.get_workers(capsule_id)
+
+        if format == "json":
+            # Output in JSON format for piping to jq
+            info_data = {"capsule": detailed_capsule_info, "workers": workers_info}
+            click.echo(json.dumps(info_data, indent=4))
+        else:
+            # Output in text format
+            _display_capsule_info_text(detailed_capsule_info, workers_info)
+
+    except Exception as e:
+        raise AppConfigError(f"Error retrieving information for app {capsule_id}: {e}")
+
+
+def _display_capsule_info_text(capsule_info, workers_info):
+    """Display capsule information in a human-readable text format."""
+    spec = capsule_info.get("spec", {})
+    status = capsule_info.get("status", {}) or {}
+    metadata = capsule_info.get("metadata", {}) or {}
+
+    info_color = ColorTheme.INFO_COLOR
+    tl_color = ColorTheme.TL_HEADER_COLOR
+
+    def _key_style(key: str, value: str):
+        return "%s: %s" % (
+            click.style(
+                key,
+                fg=ColorTheme.INFO_KEY_COLOR,
+            ),
+            click.style(str(value), fg=ColorTheme.INFO_VALUE_COLOR, bold=True),
+        )
+
+    # Basic Info
+    click.secho("=== App Information ===", fg=tl_color, bold=True)
+    click.secho(_key_style("Name", spec.get("displayName", "N/A")), fg=info_color)
+    click.secho(_key_style("ID", capsule_info.get("id", "N/A")), fg=info_color)
+    click.secho(
+        _key_style("Version", capsule_info.get("version", "N/A")), fg=info_color
+    )
+    click.secho(
+        _key_style(
+            "Ready to Serve Traffic", str(status.get("readyToServeTraffic", False))
+        ),
+        fg=info_color,
+    )
+    click.secho(
+        _key_style("Update In Progress", str(status.get("updateInProgress", False))),
+        fg=info_color,
+    )
+    click.secho(
+        _key_style(
+            "Currently Served Version", str(status.get("currentlyServedVersion", "N/A"))
+        ),
+        fg=info_color,
+    )
+
+    # URLs
+    access_info = status.get("accessInfo", {}) or {}
+    out_cluster_url = access_info.get("outOfClusterURL")
+    in_cluster_url = access_info.get("inClusterURL")
+
+    if out_cluster_url:
+        click.secho(
+            _key_style("External URL", f"https://{out_cluster_url}"), fg=info_color
+        )
+    if in_cluster_url:
+        click.secho(
+            _key_style("Internal URL", f"https://{in_cluster_url}"), fg=info_color
+        )
+
+    # Resource Configuration
+    click.secho("\n=== Resource Configuration ===", fg=tl_color, bold=True)
+    resource_config = spec.get("resourceConfig", {})
+    click.secho(_key_style("CPU", resource_config.get("cpu", "N/A")), fg=info_color)
+    click.secho(
+        _key_style("Memory", resource_config.get("memory", "N/A")), fg=info_color
+    )
+    click.secho(
+        _key_style("Ephemeral Storage", resource_config.get("ephemeralStorage", "N/A")),
+        fg=info_color,
+    )
+    if resource_config.get("gpu"):
+        click.secho(_key_style("GPU", resource_config.get("gpu")), fg=info_color)
+
+    # Autoscaling
+    click.secho("\n=== Autoscaling Configuration ===", fg=tl_color, bold=True)
+    autoscaling_config = spec.get("autoscalingConfig", {})
+    click.secho(
+        _key_style("Min Replicas", str(autoscaling_config.get("minReplicas", "N/A"))),
+        fg=info_color,
+    )
+    click.secho(
+        _key_style("Max Replicas", str(autoscaling_config.get("maxReplicas", "N/A"))),
+        fg=info_color,
+    )
+    click.secho(
+        _key_style("Available Replicas", str(status.get("availableReplicas", "N/A"))),
+        fg=info_color,
+    )
+
+    # Auth Configuration
+    click.secho("\n=== Authentication Configuration ===", fg=tl_color, bold=True)
+    auth_config = spec.get("authConfig", {})
+    click.secho(
+        _key_style("Auth Type", auth_config.get("authType", "N/A")), fg=info_color
+    )
+    click.secho(
+        _key_style("Public Access", str(auth_config.get("publicToDeployment", "N/A"))),
+        fg=info_color,
+    )
+
+    # Tags
+    tags = spec.get("tags", [])
+    if tags:
+        click.secho("\n=== Tags ===", fg=tl_color, bold=True)
+        for tag in tags:
+            click.secho(
+                _key_style(str(tag.get("key", "N/A")), str(tag.get("value", "N/A"))),
+                fg=info_color,
+            )
+
+    # Metadata
+    click.secho("\n=== Metadata ===", fg=tl_color, bold=True)
+    click.secho(
+        _key_style("Created At", metadata.get("createdAt", "N/A")), fg=info_color
+    )
+    click.secho(
+        _key_style("Last Modified At", metadata.get("lastModifiedAt", "N/A")),
+        fg=info_color,
+    )
+    click.secho(
+        _key_style("Last Modified By", metadata.get("lastModifiedBy", "N/A")),
+        fg=info_color,
+    )
+
+    # Workers Information
+    click.secho("\n=== Workers Information ===", fg=tl_color, bold=True)
+    if not workers_info:
+        click.secho("No workers found", fg=info_color)
+    else:
+        click.secho(_key_style("Total Workers", str(len(workers_info))), fg=tl_color)
+
+        # Create a table for workers
+        workers_headers = [
+            "Worker ID",
+            "Phase",
+            "Version",
+            "Activity",
+            "Activity Data Available",
+        ]
+        workers_table_data = []
+
+        for worker in workers_info:
+            worker_id = worker.get("workerId", "N/A")
+            phase = worker.get("phase", "N/A")
+            version = worker.get("version", "N/A")
+            activity = str(worker.get("activity", "N/A"))
+            activity_data_available = str(worker.get("activityDataAvailable", False))
+
+            workers_table_data.append(
+                [
+                    worker_id[:20] + "..." if len(worker_id) > 23 else worker_id,
+                    phase,
+                    version[:10] + "..." if len(version) > 13 else version,
+                    activity,
+                    activity_data_available,
+                ]
+            )
+
+        print_table(workers_table_data, workers_headers)
+
+
+@app.command(help="Get logs for an app worker from the Outerbounds Platform.")
+@click.option("--name", type=str, help="Get logs for app by name")
+@click.option("--id", "cap_id", type=str, help="Get logs for app by id")
+@click.option("--worker-id", type=str, help="Get logs for specific worker")
+@click.option("--file", type=str, help="Save logs to file")
+@click.option(
+    "--previous",
+    is_flag=True,
+    help="Get logs from previous container instance",
+    default=False,
+)
+@click.pass_context
+def logs(ctx, name, cap_id, worker_id, file, previous):
+    """Get logs for an app worker from the Outerbounds Platform."""
+    # Require either name or id
+    if not any([name is not None, cap_id is not None]):
+        raise AppConfigError("Either --name or --id must be provided to get app logs.")
+
+    # Ensure only one is provided
+    if name is not None and cap_id is not None:
+        raise AppConfigError("Please provide either --name or --id, not both.")
+
+    capsule_api = CapsuleApi(
+        ctx.obj.api_url,
+        ctx.obj.perimeter,
+    )
+
+    # First, find the capsule using list_and_filter_capsules
+    filtered_capsules = list_and_filter_capsules(
+        capsule_api, None, None, name, None, None, cap_id
+    )
+
+    if len(filtered_capsules) == 0:
+        identifier = name if name else cap_id
+        identifier_type = "name" if name else "id"
+        raise AppConfigError(f"No app found with {identifier_type}: {identifier}")
+
+    if len(filtered_capsules) > 1:
+        raise AppConfigError(
+            f"Multiple apps found with name: {name}. Please use --id to specify exactly which app you want logs for."
+        )
+
+    capsule = filtered_capsules[0]
+    capsule_id = capsule.get("id")
+
+    # Get workers
+    try:
+        workers_info = capsule_api.get_workers(capsule_id)
+    except Exception as e:
+        raise AppConfigError(f"Error retrieving workers for app {capsule_id}: {e}")
+
+    if not workers_info:
+        raise AppConfigError(f"No workers found for app {capsule_id}")
+
+    # If worker_id not provided, show interactive selection
+    if not worker_id:
+        if len(workers_info) == 1:
+            # Only one worker, use it automatically
+            selected_worker = workers_info[0]
+            worker_id = selected_worker.get("workerId")
+            worker_phase = selected_worker.get("phase", "N/A")
+            worker_version = selected_worker.get("version", "N/A")[:10]
+            click.echo(
+                f"📋 Using the only available worker: {worker_id[:20]}... (phase: {worker_phase}, version: {worker_version}...)"
+            )
+        else:
+            # Multiple workers, show selection
+            click.secho(
+                "📋 Multiple workers found. Please select one:",
+                fg=ColorTheme.INFO_COLOR,
+                bold=True,
+            )
+
+            # Display workers in a table format for better readability
+            headers = ["#", "Worker ID", "Phase", "Version", "Activity"]
+            table_data = []
+
+            for i, worker in enumerate(workers_info, 1):
+                w_id = worker.get("workerId", "N/A")
+                phase = worker.get("phase", "N/A")
+                version = worker.get("version", "N/A")
+                activity = str(worker.get("activity", "N/A"))
+
+                table_data.append(
+                    [
+                        str(i),
+                        w_id[:30] + "..." if len(w_id) > 33 else w_id,
+                        phase,
+                        version[:15] + "..." if len(version) > 18 else version,
+                        activity,
+                    ]
+                )
+
+            print_table(table_data, headers)
+
+            # Create choices for the prompt
+            worker_choices = []
+            for i, worker in enumerate(workers_info, 1):
+                worker_choices.append(str(i))
+
+            selected_index = click.prompt(
+                click.style(
+                    "Select worker number", fg=ColorTheme.INFO_COLOR, bold=True
+                ),
+                type=click.Choice(worker_choices),
+            )
+
+            # Get the selected worker
+            selected_worker = workers_info[int(selected_index) - 1]
+            worker_id = selected_worker.get("workerId")
+
+    # Get logs for the selected worker
+    try:
+        logs_response = capsule_api.logs(capsule_id, worker_id, previous=previous)
+    except Exception as e:
+        raise AppConfigError(f"Error retrieving logs for worker {worker_id}: {e}")
+
+    # Format logs content
+    logs_content = "\n".join([log.get("message", "") for log in logs_response])
+
+    # Display or save logs
+    if file:
+        try:
+            with open(file, "w") as f:
+                f.write(logs_content)
+            click.echo(f"📁 Logs saved to {file}")
+        except Exception as e:
+            raise AppConfigError(f"Error saving logs to file {file}: {e}")
+    else:
+        if logs_content.strip():
+            click.echo(logs_content)
+        else:
+            click.echo("📝 No logs available for this worker.")
+
+
 # if __name__ == "__main__":
 #     cli()