devlift-cli 0.1.0__py3-none-any.whl

devlift_cli/commands/auth.py

@@ -0,0 +1,180 @@
+"""login / logout / whoami / configure."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+
+from devlift_cli.api.context import get_context
+from devlift_cli.auth import oauth, storage
+from devlift_cli.config import Profile, list_profiles, load_profile, save_profile
+from devlift_cli.context import Invocation
+from devlift_cli.errors import EXIT_NOT_FOUND, CliError
+from devlift_cli.render import output
+from devlift_cli.render.output import kv_table, rows_table
+
+
+def login(ctx: typer.Context, no_browser: bool = typer.Option(False, "--no-browser", help="Print the sign-in URL instead of opening a browser.")):
+    """Sign in to DevLift through your browser."""
+    inv: Invocation = ctx.obj
+    existing = storage.load(inv.profile.name)
+    creds = oauth.login(inv.profile.base_url, existing=existing, open_browser=not no_browser, echo=output.info)
+    storage.save(inv.profile.name, creds)
+    who = get_context(inv.api)
+    output.success(f"Signed in as {who.email or who.user_code} ({who.tenant_name or who.tenant_code}) on profile '{inv.profile.name}'.")
+
+
+def logout(ctx: typer.Context):
+    """Sign out and forget the stored credentials for this profile."""
+    inv: Invocation = ctx.obj
+    creds = storage.load(inv.profile.name)
+    if creds:
+        oauth.revoke(inv.profile.base_url, creds)
+    removed = storage.clear(inv.profile.name)
+    output.info("Signed out." if removed else "Nothing to sign out of.")
+
+
+def whoami(ctx: typer.Context):
+    """Show who you are signed in as, and what the server enables."""
+    inv: Invocation = ctx.obj
+    who = get_context(inv.api)
+    data = who.model_dump()
+    data["profile"] = inv.profile.name
+    data["base_url"] = inv.profile.base_url
+    if inv.debug:
+        data["token_source"] = "DEVLIFT_TOKEN" if inv.api.tokens.from_environment else storage.backend_name()
+
+    def table(d):
+        enabled = ", ".join(sorted(k for k, v in d["features"].items() if v)) or "none"
+        return kv_table([
+            ("User", f"{d.get('email') or ''} ({d['user_code']})"),
+            ("Tenant", f"{d.get('tenant_name') or ''} ({d['tenant_code']})"),
+            ("Profile", d["profile"]),
+            ("Backend", d["base_url"]),
+            ("Dashboard", d.get("frontend_base_url") or ""),
+            ("Features", enabled),
+            *([("Token source", d["token_source"])] if "token_source" in d else []),
+        ])
+
+    inv.emit(data, table)
+
+
+profile_app = typer.Typer(help="Profiles: which backend commands talk to.", no_args_is_help=True)
+
+
+def _profile_rows() -> list[dict]:
+    current = load_profile().name
+    return [
+        {"name": name, "base_url": p.get("base_url"), "output": p.get("output", "table"), "default": name == current}
+        for name, p in list_profiles().items()
+    ]
+
+
+def _profiles_table(rows: list[dict]):
+    return rows_table(
+        ["Profile", "Backend", "Output", "Default"],
+        [(r["name"], r.get("base_url"), r.get("output", "table"), "*" if r["default"] else "") for r in rows],
+    )
+
+
+@profile_app.command("list")
+def profile_list(ctx: typer.Context):
+    """List profiles. The default one is starred."""
+    inv: Invocation = ctx.obj
+    inv.emit(_profile_rows(), _profiles_table)
+
+
+@profile_app.command("show")
+def profile_show(ctx: typer.Context):
+    """Show the profile this shell is currently using, and why."""
+    inv: Invocation = ctx.obj
+    from_env = os.environ.get("DEVLIFT_PROFILE")
+    url_override = os.environ.get("DEVLIFT_BASE_URL")
+    data = {
+        "name": inv.profile.name,
+        "base_url": inv.profile.base_url,
+        "output": inv.profile.output,
+        "chosen_by": "DEVLIFT_PROFILE" if from_env else "the saved default",
+        # An exported DEVLIFT_BASE_URL silently beats the profile's own URL and
+        # is the usual cause of "signed in to X, but this command targets Y".
+        "base_url_overridden_by_env": bool(url_override),
+    }
+    inv.emit(data, lambda d: kv_table([
+        ("Profile", d["name"]),
+        ("Backend", d["base_url"] + ("  (from DEVLIFT_BASE_URL)" if d["base_url_overridden_by_env"] else "")),
+        ("Output", d["output"]),
+        ("Chosen by", d["chosen_by"]),
+    ]))
+
+
+@profile_app.command("use")
+def profile_use(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., help="Profile to switch to (see `devlift profile list`)."),
+):
+    """Switch to a profile, for this and every later command."""
+    inv: Invocation = ctx.obj
+    profiles = list_profiles()
+    if name not in profiles:
+        known = ", ".join(sorted(profiles)) or "none yet"
+        raise CliError(
+            f"No profile named '{name}'.",
+            EXIT_NOT_FOUND,
+            hint=f"Known profiles: {known}. Create one with: devlift --profile {name} configure --base-url <url>",
+        )
+
+    saved = profiles[name]
+    save_profile(
+        Profile(name=name, base_url=(saved.get("base_url") or "").rstrip("/"), output=saved.get("output") or "table"),
+        make_default=True,
+    )
+    output.success(f"Now using profile '{name}' ({saved.get('base_url')}).")
+
+    # A switch that leaves you signed out of the new backend looks like a
+    # broken switch, so say it here rather than at the next command's exit 2.
+    if not storage.load(name):
+        output.info(f"Not signed in on '{name}' yet. Run: devlift login")
+    if os.environ.get("DEVLIFT_PROFILE") and os.environ["DEVLIFT_PROFILE"] != name:
+        output.warn(
+            f"DEVLIFT_PROFILE is set to '{os.environ['DEVLIFT_PROFILE']}' in this shell and overrides the default. "
+            f"Run: unset DEVLIFT_PROFILE"
+        )
+    if os.environ.get("DEVLIFT_BASE_URL"):
+        output.warn(
+            f"DEVLIFT_BASE_URL is set to '{os.environ['DEVLIFT_BASE_URL']}' and overrides every profile's backend. "
+            "Run: unset DEVLIFT_BASE_URL"
+        )
+
+
+def configure(
+    ctx: typer.Context,
+    base_url: str | None = typer.Option(None, "--base-url", help="DevLift backend, e.g. http://localhost:8000"),
+    default_output: str | None = typer.Option(None, "--default-output", help="table | json | yaml"),
+    make_default: bool = typer.Option(False, "--default", help="Make this the default profile."),
+    show: bool = typer.Option(False, "--list", help="List profiles and exit."),
+):
+    """Create or change a profile (use --profile NAME to pick which)."""
+    inv: Invocation = ctx.obj
+    if show:
+        profiles = list_profiles()
+        current = load_profile().name
+        data = [{"name": n, **p, "default": n == current} for n, p in profiles.items()]
+        inv.emit(data, lambda d: rows_table(["Profile", "Backend", "Output", "Default"], [(r["name"], r.get("base_url"), r.get("output", "table"), "*" if r["default"] else "") for r in d]))
+        return
+    if default_output and default_output not in output.FORMATS:
+        raise typer.BadParameter(f"--default-output must be one of {', '.join(output.FORMATS)}")
+    if not base_url and not default_output and not make_default:
+        if not inv.interactive:
+            raise typer.BadParameter("Pass --base-url and/or --default-output.")
+        from rich.prompt import Prompt
+
+        base_url = Prompt.ask("DevLift backend URL", default=inv.profile.base_url, console=output.err_console)
+        default_output = Prompt.ask("Default output", choices=list(output.FORMATS), default=inv.profile.output, console=output.err_console)
+    profile = Profile(
+        name=inv.profile.name,
+        base_url=(base_url or inv.profile.base_url).rstrip("/"),
+        output=default_output or inv.profile.output,
+    )
+    save_profile(profile, make_default=make_default)
+    output.success(f"Profile '{profile.name}' saved: {profile.base_url} (output {profile.output}).")

devlift_cli/commands/catalog.py

@@ -0,0 +1,187 @@
+"""The things you pick from: applications, environments, regions, resource
+types, resource groups, services."""
+
+from __future__ import annotations
+
+import typer
+
+from devlift_cli.api import catalog
+from devlift_cli.context import Invocation
+from devlift_cli.render import output
+from devlift_cli.render.output import kv_table, rows_table
+from devlift_cli.resolve import allowlist
+from devlift_cli.resolve.names import ENVIRONMENTS, Resolver
+
+applications_app = typer.Typer(help="Applications (products) in your tenant.", no_args_is_help=True)
+environments_app = typer.Typer(help="Environments and where each application can be placed.", no_args_is_help=True)
+regions_app = typer.Typer(help="Regions you can place resources in.", no_args_is_help=True)
+resource_types_app = typer.Typer(help="Infrastructure types DevLift knows about.", no_args_is_help=True)
+resource_groups_app = typer.Typer(help="Resource groups (the permission boundary for services).", no_args_is_help=True)
+services_app = typer.Typer(help="Services in your tenant.", no_args_is_help=True)
+
+_NO_CACHE = typer.Option(False, "--no-cache", help="Refetch instead of using the short-lived local cache.")
+_ALL = typer.Option(False, "--all", help="Everything the backend reports, without the placement allowlist.")
+
+
+def _resolver(inv: Invocation, no_cache: bool) -> Resolver:
+    return Resolver(inv.api, inv.profile.name, use_cache=not no_cache)
+
+
+def _hidden(before: int, after: int) -> None:
+    """Say when the allowlist removed rows, so the absence is never a mystery."""
+    if after < before:
+        output.info(f"{before - after} of {before} hidden by the placement allowlist; --all shows everything.")
+
+
+@applications_app.command("list")
+def applications_list(ctx: typer.Context, active_only: bool = typer.Option(False, "--active", help="Only active applications."), show_all: bool = _ALL, no_cache: bool = _NO_CACHE):
+    """List applications that have a real placement (see section 5)."""
+    inv: Invocation = ctx.obj
+    res = _resolver(inv, no_cache)
+    apps = res.applications()
+    if active_only:
+        apps = [a for a in apps if a.get("is_active")]
+    if not show_all:
+        before = len(apps)
+        apps = allowlist.filter_applications(apps, res.placements(), res.tenant_code())
+        _hidden(before, len(apps))
+    inv.emit(apps, lambda d: rows_table(
+        ["Name", "Code", "Services", "Groups", "Status"],
+        [(a.get("application_name"), a.get("application_code"), a.get("services_count"), a.get("resource_groups_count"), a.get("status")) for a in d],
+    ))
+
+
+@environments_app.command("list")
+def environments_list(ctx: typer.Context, app: str | None = typer.Option(None, "--app", "--product", help="Only this application."), show_all: bool = _ALL, no_cache: bool = _NO_CACHE):
+    """List environments, and for each application the regions it can use."""
+    inv: Invocation = ctx.obj
+    res = _resolver(inv, no_cache)
+    app_code = res.application(app)["application_code"] if app else None
+    rows = res.regions_for(app_code)
+    if not show_all:
+        before = len(rows)
+        rows = allowlist.filter_placements(rows, res.tenant_code())
+        _hidden(before, len(rows))
+    grouped: dict[tuple[str, str], list[str]] = {}
+    for r in rows:
+        grouped.setdefault((r["product"], r["environment"]), []).append(r["region"])
+    data = [
+        {"application": product, "environment": env, "regions": sorted(regions)}
+        for (product, env), regions in sorted(grouped.items(), key=lambda kv: (kv[0][0], ENVIRONMENTS.index(kv[0][1]) if kv[0][1] in ENVIRONMENTS else 99))
+    ]
+    inv.emit(data, lambda d: rows_table(["Application", "Environment", "Regions"], [(r["application"], r["environment"], ", ".join(r["regions"])) for r in d]))
+
+
+@regions_app.command("list")
+def regions_list(
+    ctx: typer.Context,
+    app: str | None = typer.Option(None, "--app", "--product", help="Only placements of this application."),
+    env: str | None = typer.Option(None, "--env", help="Only this environment."),
+    vendor: str | None = typer.Option(None, "--vendor", help="Show the cloud vendor's raw region list instead (e.g. aws)."),
+    for_service: str | None = typer.Option(None, "--for", help="Only regions that offer this: s3 | sqs | dynamo | eks | gateway | database."),
+    show_all: bool = _ALL,
+    no_cache: bool = _NO_CACHE,
+):
+    """List the regions (placements) available to you. These are the --region values.
+
+    Filtered by the placement allowlist (section 5), which is narrower than
+    what the backend reports. `--for s3` narrows further to one service, the
+    same check a create command makes. `--all` skips the filter.
+    """
+    inv: Invocation = ctx.obj
+    if vendor:
+        regions = catalog.list_vendor_regions(inv.api, vendor)
+        inv.emit(regions, lambda d: rows_table(["Name", "Code", "Identifier"], [(r.get("name"), r.get("code"), r.get("region_identifier")) for r in d]))
+        return
+    res = _resolver(inv, no_cache)
+    app_code = res.application(app)["application_code"] if app else None
+    environment = res.environment(env) if env else None
+    rows = res.regions_for(app_code, environment)
+    if not show_all:
+        before = len(rows)
+        rows = allowlist.filter_placements(rows, res.tenant_code(), for_service.strip().lower() if for_service else None)
+        _hidden(before, len(rows))
+    seen = {}
+    for r in rows:
+        seen.setdefault(r["geo_loc_mst_code"], {"region": r["region"], "geo_loc_mst_code": r["geo_loc_mst_code"], "placements": []})
+        seen[r["geo_loc_mst_code"]]["placements"].append(f"{r['product']}/{r['environment']}")
+    data = sorted(seen.values(), key=lambda r: r["region"] or "")
+    inv.emit(data, lambda d: rows_table(["Region", "Code", "Available in"], [(r["region"], r["geo_loc_mst_code"], ", ".join(r["placements"])) for r in d]))
+
+
+@resource_types_app.command("list")
+def resource_types_list(ctx: typer.Context, family: str | None = typer.Option(None, "--family", help="Filter by family (compute, storage, network, …)."), no_cache: bool = _NO_CACHE):
+    """List infrastructure types."""
+    inv: Invocation = ctx.obj
+    types = _resolver(inv, no_cache).infrastructure_types()
+    if family:
+        types = [t for t in types if (t.get("infra_family") or "").lower() == family.lower()]
+    inv.emit(types, lambda d: rows_table(["Name", "Code", "Vendor", "Family"], [(t.get("name"), t.get("code"), t.get("infra_vendor"), t.get("infra_family")) for t in d]))
+
+
+@resource_groups_app.command("list")
+def resource_groups_list(ctx: typer.Context, app: str | None = typer.Option(None, "--app", "--product", help="Only groups of this application."), show_all: bool = _ALL, no_cache: bool = _NO_CACHE):
+    """List resource groups. Services are created inside one.
+
+    Only groups of applications you can actually place something in, so the
+    list matches what `eks create` will accept. Two applications can each
+    have a group of the same name, and seeing both with no way to tell them
+    apart is worse than seeing only the one that applies.
+    """
+    inv: Invocation = ctx.obj
+    res = _resolver(inv, no_cache)
+    groups = res.resource_groups()
+    if app:
+        code = res.application(app)["application_code"]
+        groups = [g for g in groups if g.get("applications_mst_code") == code]
+    elif not show_all:
+        before = len(groups)
+        allowed = {r["application_code"] for r in allowlist.filter_placements(res.placements(), res.tenant_code())}
+        if allowed:
+            groups = [g for g in groups if g.get("applications_mst_code") in allowed]
+        _hidden(before, len(groups))
+    inv.emit(groups, lambda d: rows_table(["Name", "Code", "Application", "Kind", "Services"], [(g.get("name"), g.get("code"), g.get("application_name"), g.get("kind"), g.get("services_count")) for g in d]))
+
+
+@services_app.command("list")
+def services_list(
+    ctx: typer.Context,
+    app: str | None = typer.Option(None, "--app", "--product", help="Only services of this application."),
+    search: str | None = typer.Option(None, "--search", help="Name contains this text."),
+    no_cache: bool = _NO_CACHE,
+):
+    """List services."""
+    inv: Invocation = ctx.obj
+    res = _resolver(inv, no_cache)
+    services = res.services()
+    if app:
+        code = res.application(app)["application_code"]
+        services = [s for s in services if s.get("application_code") == code]
+    if search:
+        services = [s for s in services if search.lower() in (s.get("service_name") or "").lower()]
+    inv.emit(services, lambda d: rows_table(
+        ["Name", "Application", "Resource group", "Type", "Public", "Status"],
+        [(s.get("service_name"), s.get("application_name"), s.get("resource_group_name"), s.get("service_type"), "yes" if s.get("is_public_facing") else "", s.get("status")) for s in d],
+    ))
+
+
+@services_app.command("describe")
+def services_describe(ctx: typer.Context, service: str = typer.Argument(..., help="Service name or code."), no_cache: bool = _NO_CACHE):
+    """Show one service: owner, application, resource group, counts."""
+    inv: Invocation = ctx.obj
+    found = _resolver(inv, no_cache).service(service)
+    detail = catalog.get_service(inv.api, found["service_code"])
+    inv.emit(detail, lambda d: kv_table([
+        ("Name", d.get("service_name")),
+        ("Code", d.get("service_code")),
+        ("Description", d.get("description")),
+        ("Application", f"{d.get('application_name')} ({d.get('application_code')})"),
+        ("Resource group", f"{d.get('resource_group_name')} ({d.get('resource_group_kind')})"),
+        ("Type", d.get("service_type")),
+        ("Public facing", "yes" if d.get("is_public_facing") else "no"),
+        ("Status", d.get("status")),
+        ("Owner", f"{d.get('owner_name') or ''} {('<' + d['owner_email'] + '>') if d.get('owner_email') else ''}".strip()),
+        ("Infrastructure", d.get("infrastructure_count")),
+        ("Alerts", f"{d.get('alerts_configured')}/{d.get('alerts_total')}"),
+        ("Created", d.get("created_at")),
+    ], title=d.get("service_name")))

devlift_cli/commands/clusters.py

@@ -0,0 +1,108 @@
+"""devlift clusters … — the EKS and ECS clusters services can be placed on."""
+
+from __future__ import annotations
+
+import typer
+
+from devlift_cli.api import infra_list
+from devlift_cli.commands.manual import section_command
+from devlift_cli.context import Invocation
+from devlift_cli.errors import InputError
+from devlift_cli.render import output
+from devlift_cli.render.output import rows_table
+from devlift_cli.resolve import allowlist
+from devlift_cli.resolve.names import Resolver
+
+clusters_app = typer.Typer(help="EKS and ECS clusters (the --cluster values).", no_args_is_help=True)
+
+_TYPES = {"eks": "eks_infrastructuretype_ref", "ecs": "ecs_ec2_infrastructuretype_ref"}
+# The placement-allowlist service key each cluster type is listed under.
+_SERVICE_OF = {"EKS": allowlist.SERVICE_EKS, "ECS EC2": "ecs"}
+
+
+def _placeable(res: Resolver, rows: list[dict]) -> list[dict]:
+    """Keep clusters in a placement a service could really be created in.
+
+    Two filters, the same pair every create goes through: the backend only
+    reports placements this deployment serves, and the allowlist says which
+    of those offer that kind of service. A cluster outside both is real but
+    unusable from here, which is why it is hidden rather than listed.
+    """
+    placements = res.placements()
+    tenant = res.tenant_code()
+    allowed: dict[str, set] = {}
+    for service in set(_SERVICE_OF.values()):
+        allowed[service] = {
+            (p["application_code"], p["environment"], p["geo_loc_mst_code"])
+            for p in allowlist.filter_placements(placements, tenant, service)
+        }
+
+    kept = []
+    for row in rows:
+        service = _SERVICE_OF.get(row.get("cluster_type") or "")
+        if service is None:
+            continue
+        keys = allowed[service]
+        here = (row.get("environment"), row.get("geo_loc_mst_code"))
+        app = row.get("applications_mst_code")
+        if app:
+            match = (app, *here) in keys
+        else:                                   # tenant-level: any product will do
+            match = any((e, g) == here for _, e, g in keys)
+        if match:
+            kept.append(row)
+    return kept
+
+
+@clusters_app.command("list")
+def clusters_list(
+    ctx: typer.Context,
+    app: str | None = typer.Option(None, "--app", "--product", help="Only clusters of this application (tenant-level ones are always shown)."),
+    env: str | None = typer.Option(None, "--env", help="Only this environment."),
+    region: str | None = typer.Option(None, "--region", help="Only this region."),
+    kind: str | None = typer.Option(None, "--type", help="eks | ecs. Both when omitted."),
+    search: str | None = typer.Option(None, "--search", help="Match on the cluster name."),
+    show_all: bool = typer.Option(False, "--all", help="Every cluster the backend reports, without the placement filter."),
+):
+    """List the clusters a service can run on.
+
+    Narrowed to placements this deployment serves and the placement allowlist
+    permits, so a cluster listed here is one a service could actually be
+    created on. `--all` shows everything the backend reports.
+
+    "Registered" is the flag that matters within that: only a registered
+    cluster may take a new service, and `eks create` will not offer the
+    others. A cluster with no application is tenant-level and is the fallback
+    for every product that has none of its own.
+    """
+    inv: Invocation = ctx.obj
+    res = Resolver(inv.api, inv.profile.name)
+    if kind and kind.strip().lower() not in _TYPES:
+        raise InputError("--type must be eks or ecs.")
+    app_code = res.application(app)["application_code"] if app else None
+    rows = infra_list.list_clusters(
+        inv.api,
+        infra_type=_TYPES[kind.strip().lower()] if kind else None,
+        environment=res.environment(env) if env else None,
+        geo_loc_mst_code=None,
+        search=search,
+    )
+    if region:
+        wanted = region.strip().lower()
+        rows = [r for r in rows if wanted in (str(r.get("geo_loc_name", "")).lower(), str(r.get("geo_loc_mst_code", "")).lower())]
+    if app_code:
+        rows = [r for r in rows if r.get("applications_mst_code") in (app_code, None)]
+    if not show_all:
+        before = len(rows)
+        rows = _placeable(res, rows)
+        if before > len(rows):
+            output.info(f"{before - len(rows)} of {before} hidden: not a placement this deployment offers; --all shows everything.")
+    inv.emit(rows, lambda d: rows_table(
+        ["Cluster", "Type", "Environment", "Region", "Application", "Registered", "Status", "Code"],
+        [(r.get("cluster_name") or r.get("name"), r.get("cluster_type"), r.get("environment"),
+          r.get("geo_loc_name") or r.get("geo_loc_mst_code"), r.get("application_name") or "tenant-level",
+          "yes" if r.get("is_registered") else "no", r.get("status"), r.get("code")) for r in d],
+    ))
+
+
+clusters_app.command("manual")(section_command("clusters"))

devlift_cli/commands/deployment.py

@@ -0,0 +1,77 @@
+"""devlift deployment … and devlift queue …"""
+
+from __future__ import annotations
+
+import typer
+
+from devlift_cli.commands.manual import section_command
+from devlift_cli.api import deployments as deployments_api
+from devlift_cli.api import infra
+from devlift_cli.context import Invocation
+from devlift_cli.ops.status import deployment_detail, history_table, print_deployment
+from devlift_cli.render.output import kv_table, rows_table
+from devlift_cli.resolve.names import Resolver
+
+deployment_app = typer.Typer(help="Deployments: history and progress, as the dashboard's tracker shows them.", no_args_is_help=True)
+queue_app = typer.Typer(help="Your transaction queue (what is waiting to deploy).", no_args_is_help=True)
+
+
+@deployment_app.command("list")
+def deployment_list(
+    ctx: typer.Context,
+    status: str | None = typer.Option(None, "--status", help="running | completed | failed | timedout"),
+    app: str | None = typer.Option(None, "--app", "--product", help="Only this application."),
+    env: str | None = typer.Option(None, "--env", help="Only this environment."),
+    mine: bool = typer.Option(False, "--mine", help="Only deployments you started."),
+    limit: int = typer.Option(20, "--limit", help="How many (1-100)."),
+):
+    """List deployments, newest first."""
+    inv: Invocation = ctx.obj
+    res = Resolver(inv.api, inv.profile.name)
+    user_code = None
+    if mine:
+        from devlift_cli.api.context import get_context
+        user_code = get_context(inv.api).user_code
+    rows, total = deployments_api.history(
+        inv.api,
+        status=status.upper() if status else None,
+        application_code=res.application(app)["application_code"] if app else None,
+        environment=res.environment(env) if env else None,
+        user_code=user_code,
+        limit=max(1, min(limit, 100)),
+    )
+    if total > len(rows):
+        from devlift_cli.render import output
+        output.info(f"Showing {len(rows)} of {total}.")
+    inv.emit(rows, history_table)
+
+
+@deployment_app.command("status")
+def deployment_status(
+    ctx: typer.Context,
+    workflow_id: str = typer.Argument(..., help="Workflow id printed by a create, update or deploy command."),
+    do_wait: bool = typer.Option(False, "--wait", help="Keep polling until it finishes."),
+):
+    """Show a deployment: status, pull request, resources and pipeline stages."""
+    inv: Invocation = ctx.obj
+    detail = deployment_detail(inv, workflow_id, do_wait=do_wait)
+
+    def table(d):
+        print_deployment(d)
+        return kv_table([])
+    inv.emit(detail, table)
+
+
+@queue_app.command("list")
+def queue_list(ctx: typer.Context, env: str | None = typer.Option(None, "--env", help="Only this environment.")):
+    """List your queue items (pending, approved, PR raised)."""
+    inv: Invocation = ctx.obj
+    environment = Resolver(inv.api, inv.profile.name).environment(env) if env else None
+    items = infra.list_queue(inv.api, environment)
+    inv.emit(items, lambda d: rows_table(
+        ["Item", "Name", "Kind", "Case", "Status", "Updated"],
+        [(i.get("code"), i.get("display_name"), i.get("table_name"), i.get("case_ref_code"), i.get("status"), str(i.get("status_last_updated_at") or "")[:19]) for i in d],
+    ))
+
+
+deployment_app.command("manual")(section_command("deployment, queue"))