meshagent-cli 0.51.5__tar.gz → 0.52.0__tar.gz

{meshagent_cli-0.51.5 → meshagent_cli-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshagent-cli
-Version: 0.51.5
+Version: 0.52.0
 Summary: CLI for Meshagent
 License-Expression: Apache-2.0
 Project-URL: Documentation, https://docs.meshagent.com
@@ -22,8 +22,8 @@ Requires-Dist: openpyxl~=3.1
 Requires-Dist: xlsxwriter~=3.2
 Requires-Dist: pathspec<2,>=1.0.3
 Requires-Dist: zstandard~=0.25.0
-Requires-Dist: meshagent-llm-proxy==0.51.5
-Requires-Dist: meshagent-codex==0.51.5
+Requires-Dist: meshagent-llm-proxy==0.52.0
+Requires-Dist: meshagent-codex==0.52.0
 Requires-Dist: rich~=14.3.0
 Requires-Dist: sounddevice~=0.5
 Requires-Dist: textual<9.0,>=8.2.3
@@ -32,23 +32,23 @@ Requires-Dist: prompt-toolkit~=3.0.52
 Requires-Dist: ascii-magic~=2.3
 Requires-Dist: pillow~=11.3.0
 Provides-Extra: all
-Requires-Dist: meshagent-agents[all]==0.51.5; extra == "all"
-Requires-Dist: meshagent-api[all]==0.51.5; extra == "all"
-Requires-Dist: meshagent-commoncrawl==0.51.5; extra == "all"
-Requires-Dist: meshagent-scrapy==0.51.5; extra == "all"
-Requires-Dist: meshagent-computers==0.51.5; extra == "all"
-Requires-Dist: meshagent-openai==0.51.5; extra == "all"
-Requires-Dist: meshagent-anthropic==0.51.5; extra == "all"
-Requires-Dist: meshagent-otel==0.51.5; extra == "all"
-Requires-Dist: meshagent-mcp==0.51.5; extra == "all"
-Requires-Dist: meshagent-tools==0.51.5; extra == "all"
+Requires-Dist: meshagent-agents[all]==0.52.0; extra == "all"
+Requires-Dist: meshagent-api[all]==0.52.0; extra == "all"
+Requires-Dist: meshagent-commoncrawl==0.52.0; extra == "all"
+Requires-Dist: meshagent-scrapy==0.52.0; extra == "all"
+Requires-Dist: meshagent-computers==0.52.0; extra == "all"
+Requires-Dist: meshagent-openai==0.52.0; extra == "all"
+Requires-Dist: meshagent-anthropic==0.52.0; extra == "all"
+Requires-Dist: meshagent-otel==0.52.0; extra == "all"
+Requires-Dist: meshagent-mcp==0.52.0; extra == "all"
+Requires-Dist: meshagent-tools==0.52.0; extra == "all"
 Requires-Dist: supabase-auth~=2.28.0; extra == "all"
 Requires-Dist: prompt-toolkit~=3.0.52; extra == "all"
 Provides-Extra: mcp-service
-Requires-Dist: meshagent-agents[all]==0.51.5; extra == "mcp-service"
-Requires-Dist: meshagent-api==0.51.5; extra == "mcp-service"
-Requires-Dist: meshagent-mcp==0.51.5; extra == "mcp-service"
-Requires-Dist: meshagent-tools==0.51.5; extra == "mcp-service"
+Requires-Dist: meshagent-agents[all]==0.52.0; extra == "mcp-service"
+Requires-Dist: meshagent-api==0.52.0; extra == "mcp-service"
+Requires-Dist: meshagent-mcp==0.52.0; extra == "mcp-service"
+Requires-Dist: meshagent-tools==0.52.0; extra == "mcp-service"
 Requires-Dist: supabase-auth~=2.28.0; extra == "mcp-service"
 Dynamic: license-file
 

{meshagent_cli-0.51.5 → meshagent_cli-0.52.0}/meshagent/cli/cli.py

@@ -216,6 +216,11 @@ app.add_lazy_command(
     module="meshagent.cli.routes",
     help="Manage routes for your project",
 )
+app.add_lazy_command(
+    name="custom-domain",
+    module="meshagent.cli.custom_domains",
+    help="Manage custom domains for project routes",
+)
 app.add_lazy_command(
     name="registry",
     module="meshagent.cli.registry",

{meshagent_cli-0.51.5 → meshagent_cli-0.52.0}/meshagent/cli/cli_test.py

@@ -54,6 +54,7 @@ def test_root_help_lists_create_and_doctor_but_hides_legacy_command_namespaces()
     assert "│ doctor" in result.output
     assert "│ iam" in result.output
     assert "│ service-account" in result.output
+    assert "│ custom-domain" in result.output
     assert "│ init" not in result.output
     assert "│ api-key" not in result.output
     assert "│ launch" in result.output
@@ -79,6 +80,8 @@ def test_root_registers_create_and_doctor_as_visible_commands() -> None:
     assert registrations["iam"].hidden is False
     assert registrations["service-account"].module == "meshagent.cli.service_accounts"
     assert registrations["service-account"].hidden is False
+    assert registrations["custom-domain"].module == "meshagent.cli.custom_domains"
+    assert registrations["custom-domain"].hidden is False
     assert "init" not in registrations
     assert "api-key" not in registrations
 

{meshagent_cli-0.51.5 → meshagent_cli-0.52.0}/meshagent/cli/containers.py

@@ -365,9 +365,15 @@ async def _drain_stream_plain(stream, *, show_progress: bool = True):
 
     t1 = asyncio.create_task(_logs())
     t2 = asyncio.create_task(_prog())
+    completed = False
     try:
-        return await stream
+        result = await stream
+        completed = True
+        return result
     finally:
+        if not completed:
+            t1.cancel()
+            t2.cancel()
         await asyncio.gather(t1, t2, return_exceptions=True)
 
 
@@ -511,8 +517,10 @@ async def _drain_stream_pretty(stream):
         t_logs = asyncio.create_task(_logs())
         t_prog = asyncio.create_task(_prog())
         t_ui = asyncio.create_task(_refresh())
+        completed = False
         try:
             result = await stream
+            completed = True
             return result
         finally:
             # Hide any still-visible tasks (e.g., indeterminate ones with total=None)
@@ -520,10 +528,11 @@ async def _drain_stream_pretty(stream):
                 progress.update(tid, visible=False)
             live.update(render())
 
-            for t in (t_logs, t_prog):
-                await t
-
+            if not completed:
+                t_logs.cancel()
+                t_prog.cancel()
             t_ui.cancel()
+            await asyncio.gather(t_logs, t_prog, t_ui, return_exceptions=True)
 
 
 async def _with_client(

{meshagent_cli-0.51.5 → meshagent_cli-0.52.0}/meshagent/cli/containers_test.py

@@ -323,6 +323,38 @@ async def test_drain_stream_plain_strips_cri_log_prefixes(
     assert capsys.readouterr().out == "step 1\nstep 2\n"
 
 
+@pytest.mark.asyncio
+async def test_drain_stream_plain_cancels_consumers_when_stream_is_cancelled() -> None:
+    consumers_cancelled = 0
+
+    class _BlockingStream:
+        async def _consume(self):
+            nonlocal consumers_cancelled
+            try:
+                await asyncio.Future()
+                yield None
+            finally:
+                consumers_cancelled += 1
+
+        def logs(self):
+            return self._consume()
+
+        def progress(self):
+            return self._consume()
+
+        def __await__(self):
+            return asyncio.Future().__await__()
+
+    task = asyncio.create_task(containers._drain_stream_plain(_BlockingStream()))
+    await asyncio.sleep(0)
+    task.cancel()
+
+    with pytest.raises(asyncio.CancelledError):
+        await asyncio.wait_for(task, timeout=0.5)
+
+    assert consumers_cancelled == 2
+
+
 @pytest.mark.asyncio
 async def test_stream_build_job_logs_and_wait_for_exit_uses_build_log_stream(
     monkeypatch: pytest.MonkeyPatch,

meshagent_cli-0.52.0/meshagent/cli/custom_domains.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import json
+from typing import Annotated, Literal
+
+import typer
+from aiohttp import ClientResponseError
+from rich import print
+
+from meshagent.api.client import (
+    CustomDomain,
+    CustomDomainDnsRecord,
+    CustomDomainsPage,
+)
+from meshagent.cli import async_typer
+from meshagent.cli.common_options import OutputFormatOption, ProjectIdOption
+from meshagent.cli.helper import get_client, print_json_table, resolve_project_id
+
+
+app = async_typer.AsyncTyper(help="Manage custom domains for project routes")
+
+
+def _record(record: CustomDomainDnsRecord | None) -> str:
+    if record is None:
+        return ""
+    return f"{record.name} {record.type} {record.data}"
+
+
+def _custom_domain_row(custom_domain: CustomDomain) -> dict[str, object]:
+    return {
+        "domain": custom_domain.domain,
+        "phase": custom_domain.phase,
+        "available": custom_domain.available,
+        "dns_authorization": _record(custom_domain.dns_authorization_record),
+        "route_dns": ", ".join(
+            _record(record) for record in custom_domain.routing_records
+        ),
+        "certificate": custom_domain.certificate_state or "",
+    }
+
+
+def _print_custom_domains(
+    custom_domains: list[CustomDomain], *, output_format: str
+) -> None:
+    if output_format == "json":
+        print(
+            json.dumps(
+                {
+                    "custom_domains": [
+                        item.model_dump(mode="json", exclude_none=True)
+                        for item in custom_domains
+                    ]
+                },
+                indent=2,
+            )
+        )
+        return
+    print_json_table(
+        [_custom_domain_row(item) for item in custom_domains],
+        "domain",
+        "phase",
+        "available",
+        "dns_authorization",
+        "route_dns",
+        "certificate",
+    )
+
+
+@app.async_command("create")
+async def create_custom_domain(
+    *,
+    project_id: ProjectIdOption,
+    domain: Annotated[
+        str,
+        typer.Argument(help="Exact domain or wildcard such as *.example.com"),
+    ],
+    o: OutputFormatOption = "table",
+) -> None:
+    """Register an immutable custom domain and begin certificate provisioning."""
+    project_id = await resolve_project_id(project_id=project_id)
+    client = await get_client()
+    try:
+        custom_domain = await client.create_custom_domain(
+            project_id=project_id,
+            domain=domain,
+        )
+    finally:
+        await client.close()
+    _print_custom_domains([custom_domain], output_format=o)
+
+
+@app.async_command("get")
+async def get_custom_domain(
+    *,
+    project_id: ProjectIdOption,
+    domain: Annotated[str, typer.Argument(help="Exact registered domain")],
+    o: OutputFormatOption = "table",
+) -> None:
+    """Show availability and the DNS records that must be published."""
+    project_id = await resolve_project_id(project_id=project_id)
+    client = await get_client()
+    try:
+        try:
+            custom_domain = await client.get_custom_domain(
+                project_id=project_id,
+                domain=domain,
+            )
+        except ClientResponseError as error:
+            if error.status == 404:
+                print(f"[red]Custom domain not found:[/] {domain}")
+                raise typer.Exit(code=1) from error
+            raise
+    finally:
+        await client.close()
+    _print_custom_domains([custom_domain], output_format=o)
+
+
+@app.async_command("list")
+async def list_custom_domains(
+    *,
+    project_id: ProjectIdOption,
+    filter: Annotated[
+        str | None,
+        typer.Option("--filter", help="Lowercase contains filter"),
+    ] = None,
+    count: Annotated[
+        int,
+        typer.Option("--count", help="Maximum number of domains to return"),
+    ] = 100,
+    view: Annotated[
+        Literal["my", "all"],
+        typer.Option("--view", help="List directly accessible domains or all domains"),
+    ] = "my",
+    o: OutputFormatOption = "table",
+) -> None:
+    """List registered custom domains and certificate availability."""
+    project_id = await resolve_project_id(project_id=project_id)
+    client = await get_client()
+    custom_domains: list[CustomDomain] = []
+    continuation_token: str | None = None
+    try:
+        while len(custom_domains) < count:
+            page: CustomDomainsPage = await client.list_custom_domains(
+                project_id=project_id,
+                count=min(count - len(custom_domains), 100),
+                continuation_token=continuation_token,
+                filter=filter,
+                view=view,
+            )
+            custom_domains.extend(page.custom_domains)
+            continuation_token = page.continuation_token
+            if continuation_token is None:
+                break
+    finally:
+        await client.close()
+    _print_custom_domains(custom_domains[:count], output_format=o)
+
+
+@app.async_command("delete")
+async def delete_custom_domain(
+    *,
+    project_id: ProjectIdOption,
+    domain: Annotated[str, typer.Argument(help="Exact registered domain")],
+) -> None:
+    """Delete a custom domain after all covered routes have been removed."""
+    project_id = await resolve_project_id(project_id=project_id)
+    client = await get_client()
+    try:
+        try:
+            await client.delete_custom_domain(project_id=project_id, domain=domain)
+        except ClientResponseError as error:
+            if error.status == 404:
+                print(f"[red]Custom domain not found:[/] {domain}")
+                raise typer.Exit(code=1) from error
+            if error.status == 409:
+                print(f"[red]Custom domain is still assigned to a route:[/] {domain}")
+                raise typer.Exit(code=1) from error
+            raise
+    finally:
+        await client.close()
+    print(f"[green]Custom domain deletion requested:[/] {domain}")

meshagent_cli-0.52.0/meshagent/cli/custom_domains_test.py

@@ -0,0 +1,137 @@
+from datetime import datetime, timezone
+
+import pytest
+
+from meshagent.api.client import CustomDomain, CustomDomainsPage
+from meshagent.cli import custom_domains
+from meshagent.cli.testing import CliRunner
+
+
+def _domain(*, domain: str = "docs.example.com", available: bool = False):
+    return CustomDomain.model_validate(
+        {
+            "domain": domain,
+            "project_id": "resolved-project",
+            "phase": "available" if available else "pending_dns",
+            "available": available,
+            "dns_authorization_record": {
+                "name": "_acme-challenge.example.com.",
+                "type": "CNAME",
+                "data": "authorization.example.net.",
+            },
+            "routing_records": [{"name": "@", "type": "A", "data": "203.0.113.10"}],
+            "certificate_state": "ACTIVE" if available else "PROVISIONING",
+            "created_at": datetime(2026, 8, 31, tzinfo=timezone.utc),
+        }
+    )
+
+
+def test_custom_domain_help_exposes_immutable_resource_commands() -> None:
+    result = CliRunner().invoke(custom_domains.app, ["--help"])
+
+    assert result.exit_code == 0
+    assert "create" in result.output
+    assert "get" in result.output
+    assert "list" in result.output
+    assert "delete" in result.output
+    assert "update" not in result.output
+
+
+@pytest.mark.asyncio
+async def test_create_prints_dns_and_availability(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[dict[str, str]] = []
+    printed_tables: list[tuple[list[dict[str, object]], tuple[str, ...]]] = []
+
+    class _FakeClient:
+        async def create_custom_domain(self, *, project_id: str, domain: str):
+            calls.append({"project_id": project_id, "domain": domain})
+            return _domain(domain=domain)
+
+        async def close(self) -> None:
+            pass
+
+    async def fake_get_client():
+        return _FakeClient()
+
+    async def fake_resolve_project_id(*, project_id: str | None) -> str:
+        assert project_id == "project-1"
+        return "resolved-project"
+
+    monkeypatch.setattr(custom_domains, "get_client", fake_get_client)
+    monkeypatch.setattr(custom_domains, "resolve_project_id", fake_resolve_project_id)
+    monkeypatch.setattr(
+        custom_domains,
+        "print_json_table",
+        lambda rows, *columns: printed_tables.append((rows, columns)),
+    )
+
+    await custom_domains.create_custom_domain(
+        project_id="project-1",
+        domain="docs.example.com",
+        o="table",
+    )
+
+    assert calls == [{"project_id": "resolved-project", "domain": "docs.example.com"}]
+    assert printed_tables[0][0][0]["available"] is False
+    assert "_acme-challenge.example.com." in str(
+        printed_tables[0][0][0]["dns_authorization"]
+    )
+    assert "203.0.113.10" in str(printed_tables[0][0][0]["route_dns"])
+
+
+@pytest.mark.asyncio
+async def test_list_follows_continuation_tokens(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[str | None] = []
+    printed: list[object] = []
+
+    class _FakeClient:
+        async def list_custom_domains(
+            self,
+            *,
+            project_id: str,
+            count: int,
+            continuation_token: str | None,
+            filter: str | None,
+            view: str,
+        ) -> CustomDomainsPage:
+            assert project_id == "resolved-project"
+            assert filter == "example"
+            assert view == "my"
+            calls.append(continuation_token)
+            if continuation_token is None:
+                return CustomDomainsPage(
+                    custom_domains=[_domain(domain="a.example.com")],
+                    continuation_token="next",
+                )
+            return CustomDomainsPage(
+                custom_domains=[_domain(domain="b.example.com", available=True)]
+            )
+
+        async def close(self) -> None:
+            pass
+
+    async def fake_get_client():
+        return _FakeClient()
+
+    async def fake_resolve_project_id(*, project_id: str | None) -> str:
+        return "resolved-project"
+
+    monkeypatch.setattr(custom_domains, "get_client", fake_get_client)
+    monkeypatch.setattr(custom_domains, "resolve_project_id", fake_resolve_project_id)
+    monkeypatch.setattr(custom_domains, "print", printed.append)
+
+    await custom_domains.list_custom_domains(
+        project_id="project-1",
+        filter="example",
+        count=2,
+        view="my",
+        o="json",
+    )
+
+    assert calls == [None, "next"]
+    assert '"a.example.com"' in str(printed[0])
+    assert '"b.example.com"' in str(printed[0])