feat: shell completion for jmp, jmp-admin, and j

.github/workflows/python-tests.yaml

@@ -72,11 +72,11 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y qemu-system-arm qemu-system-x86
 
-      - name: Install libgpiod-dev (Linux)
+      - name: Install libgpiod-dev and fish (Linux)
         if: runner.os == 'Linux'
         run: |
           sudo apt-get update
-          sudo apt-get install -y libgpiod-dev liblgpio-dev
+          sudo apt-get install -y libgpiod-dev liblgpio-dev fish
 
       - name: Install Renode (Linux)
         if: runner.os == 'Linux'
@@ -100,6 +100,11 @@ jobs:
         run: |
           brew install renode/tap/renode
 
+      - name: Install fish (macOS)
+        if: runner.os == 'macOS'
+        run: |
+          brew install fish
+
       - name: Cache Fedora Cloud images
         id: cache-fedora-cloud-images
         uses: actions/cache@v5

python/packages/jumpstarter-cli-admin/jumpstarter_cli_admin/__init__.py

@@ -3,6 +3,7 @@
 from jumpstarter_cli_common.opt import opt_log_level
 from jumpstarter_cli_common.version import version
 
+from .completion import completion
 from .create import create
 from .delete import delete
 from .get import get
@@ -16,6 +17,7 @@ def admin():
     """Jumpstarter Kubernetes cluster admin CLI tool"""
 
 
+admin.add_command(completion)
 admin.add_command(get)
 admin.add_command(create)
 admin.add_command(delete)

python/packages/jumpstarter-cli-admin/jumpstarter_cli_admin/completion.py

@@ -0,0 +1,10 @@
+from jumpstarter_cli_common.completion import make_completion_command
+
+
+def _get_admin():
+    from jumpstarter_cli_admin import admin
+
+    return admin
+
+
+completion = make_completion_command(_get_admin, "jmp-admin", "_JMP_ADMIN_COMPLETE")

python/packages/jumpstarter-cli-admin/jumpstarter_cli_admin/completion_test.py

@@ -0,0 +1,43 @@
+from click.testing import CliRunner
+
+from . import admin
+
+
+def test_completion_bash_produces_script_with_jmp_admin():
+    runner = CliRunner()
+    result = runner.invoke(admin, ["completion", "bash"])
+    assert result.exit_code == 0
+    assert len(result.output) > 0
+    assert "complete" in result.output.lower()
+    assert "jmp-admin" in result.output.lower()
+
+
+def test_completion_zsh_produces_compdef_for_jmp_admin():
+    runner = CliRunner()
+    result = runner.invoke(admin, ["completion", "zsh"])
+    assert result.exit_code == 0
+    assert len(result.output) > 0
+    assert "compdef" in result.output.lower()
+
+
+def test_completion_fish_produces_complete_command_for_jmp_admin():
+    runner = CliRunner()
+    result = runner.invoke(admin, ["completion", "fish"])
+    assert result.exit_code == 0
+    assert len(result.output) > 0
+    assert "complete" in result.output.lower()
+    assert "--command jmp-admin" in result.output.lower()
+
+
+def test_completion_missing_argument_exits_with_error():
+    runner = CliRunner()
+    result = runner.invoke(admin, ["completion"])
+    assert result.exit_code == 2
+    assert "Missing argument" in result.output or "bash" in result.output
+
+
+def test_completion_unsupported_shell_exits_with_error():
+    runner = CliRunner()
+    result = runner.invoke(admin, ["completion", "powershell"])
+    assert result.exit_code == 2
+    assert "Invalid value" in result.output or "powershell" in result.output

python/packages/jumpstarter-cli-common/jumpstarter_cli_common/completion.py

@@ -0,0 +1,19 @@
+from typing import Callable
+
+import click
+from click.shell_completion import get_completion_class
+
+
+def make_completion_command(cli_group_factory: Callable[[], click.Command], prog_name: str, complete_var: str):
+    @click.command("completion")
+    @click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]))
+    def completion(shell: str):
+        """Generate shell completion script."""
+        cli_group = cli_group_factory()
+        comp_cls = get_completion_class(shell)
+        if comp_cls is None:
+            raise click.ClickException(f"Unsupported shell: {shell}")
+        comp = comp_cls(cli_group, {}, prog_name, complete_var)
+        click.echo(comp.source())
+
+    return completion

python/packages/jumpstarter-cli-common/jumpstarter_cli_common/completion_test.py

@@ -0,0 +1,75 @@
+from unittest.mock import patch
+
+import click
+from click.testing import CliRunner
+
+from .completion import make_completion_command
+
+PROG_NAME = "testcli"
+COMPLETE_VAR = "_TESTCLI_COMPLETE"
+
+
+def _make_test_group():
+    @click.group()
+    def cli():
+        pass
+
+    return cli
+
+
+def _make_test_cli_with_completion():
+    @click.group()
+    def cli():
+        pass
+
+    cli.add_command(make_completion_command(_make_test_group, PROG_NAME, COMPLETE_VAR))
+    return cli
+
+
+def test_completion_bash_produces_completion_script():
+    cli = _make_test_cli_with_completion()
+    runner = CliRunner()
+    result = runner.invoke(cli, ["completion", "bash"])
+    assert result.exit_code == 0
+    assert "complete" in result.output.lower()
+    assert PROG_NAME in result.output.lower()
+
+
+def test_completion_zsh_produces_compdef():
+    cli = _make_test_cli_with_completion()
+    runner = CliRunner()
+    result = runner.invoke(cli, ["completion", "zsh"])
+    assert result.exit_code == 0
+    assert "compdef" in result.output.lower()
+
+
+def test_completion_fish_produces_complete_command():
+    cli = _make_test_cli_with_completion()
+    runner = CliRunner()
+    result = runner.invoke(cli, ["completion", "fish"])
+    assert result.exit_code == 0
+    assert "complete" in result.output.lower()
+    assert f"--command {PROG_NAME}" in result.output.lower()
+
+
+def test_completion_missing_argument_exits_with_error():
+    cli = _make_test_cli_with_completion()
+    runner = CliRunner()
+    result = runner.invoke(cli, ["completion"])
+    assert result.exit_code == 2
+
+
+def test_completion_unsupported_shell_exits_with_error():
+    cli = _make_test_cli_with_completion()
+    runner = CliRunner()
+    result = runner.invoke(cli, ["completion", "powershell"])
+    assert result.exit_code == 2
+
+
+def test_completion_raises_when_get_completion_class_returns_none():
+    with patch("jumpstarter_cli_common.completion.get_completion_class", return_value=None):
+        cli = _make_test_cli_with_completion()
+        runner = CliRunner()
+        result = runner.invoke(cli, ["completion", "bash"])
+        assert result.exit_code == 1
+        assert "Unsupported shell" in result.output

python/packages/jumpstarter-cli/jumpstarter_cli/completion.py

@@ -1,15 +1,10 @@
-import click
-from click.shell_completion import get_completion_class
+from jumpstarter_cli_common.completion import make_completion_command
 
 
-@click.command("completion")
-@click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]))
-def completion(shell: str):
-    """Generate shell completion script."""
+def _get_jmp():
     from jumpstarter_cli.jmp import jmp
 
-    comp_cls = get_completion_class(shell)
-    if comp_cls is None:
-        raise click.ClickException(f"Unsupported shell: {shell}")
-    comp = comp_cls(jmp, {}, "jmp", "_JMP_COMPLETE")
-    click.echo(comp.source())
+    return jmp
+
+
+completion = make_completion_command(_get_jmp, "jmp", "_JMP_COMPLETE")

python/packages/jumpstarter-cli/jumpstarter_cli/completion_test.py

@@ -1,5 +1,3 @@
-from unittest.mock import patch
-
 from click.testing import CliRunner
 
 from .jmp import jmp
@@ -43,11 +41,3 @@ def test_completion_unsupported_shell():
     result = runner.invoke(jmp, ["completion", "powershell"])
     assert result.exit_code == 2
     assert "Invalid value" in result.output or "powershell" in result.output
-
-
-def test_completion_raises_when_get_completion_class_returns_none():
-    with patch("jumpstarter_cli.completion.get_completion_class", return_value=None):
-        runner = CliRunner()
-        result = runner.invoke(jmp, ["completion", "bash"])
-        assert result.exit_code == 1
-        assert "Unsupported shell" in result.output

python/packages/jumpstarter-cli/jumpstarter_cli/j.py

@@ -1,12 +1,15 @@
 import concurrent.futures._base
+import os
 import sys
 from contextlib import ExitStack
 from typing import cast
 
+import anyio
 import click
 from anyio import create_task_group, get_cancelled_exc_class, run, to_thread
 from anyio.from_thread import BlockingPortal
 from click.exceptions import Exit as ClickExit
+from jumpstarter_cli_common.completion import make_completion_command
 from jumpstarter_cli_common.exceptions import (
     ClickExceptionRed,
     async_handle_exceptions,
@@ -19,6 +22,29 @@
 from jumpstarter.common.exceptions import EnvironmentVariableNotSetError
 from jumpstarter.utils.env import env_async
 
+j_completion = make_completion_command(lambda: click.Group("j"), "j", "_J_COMPLETE")
+
+
+_COMPLETION_TIMEOUT_SECONDS = 5
+
+
+async def _j_shell_complete():
+    try:
+        with anyio.fail_after(_COMPLETION_TIMEOUT_SECONDS):
+            async with BlockingPortal() as portal:
+                with ExitStack() as stack:
+                    async with env_async(portal, stack) as client:
+
+                        def _run_completion():
+                            try:
+                                client.cli()(standalone_mode=False)
+                            except SystemExit:
+                                pass
+
+                        await to_thread.run_sync(_run_completion, abandon_on_cancel=True)
+    except TimeoutError:
+        pass
+
 
 async def j_async():
     @async_handle_exceptions
@@ -60,6 +86,12 @@ async def cli():
 
 def j():
     traceback.install()
+    if len(sys.argv) >= 2 and sys.argv[1] == "completion":
+        j_completion(args=sys.argv[2:])
+        return
+    if "_J_COMPLETE" in os.environ:
+        run(_j_shell_complete)
+        return
     run(j_async)
 
 

python/packages/jumpstarter-cli/jumpstarter_cli/j_completion_test.py

@@ -0,0 +1,73 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import anyio
+from anyio import run
+from click.testing import CliRunner
+
+from .j import _COMPLETION_TIMEOUT_SECONDS, _j_shell_complete, j_completion
+
+
+def test_j_completion_bash_produces_script():
+    runner = CliRunner()
+    result = runner.invoke(j_completion, ["bash"])
+    assert result.exit_code == 0
+    assert "complete" in result.output.lower()
+    assert "_J_COMPLETE" in result.output
+
+
+def test_j_completion_zsh_produces_compdef():
+    runner = CliRunner()
+    result = runner.invoke(j_completion, ["zsh"])
+    assert result.exit_code == 0
+    assert "compdef" in result.output.lower()
+
+
+def test_j_completion_fish_produces_complete_command():
+    runner = CliRunner()
+    result = runner.invoke(j_completion, ["fish"])
+    assert result.exit_code == 0
+    assert "complete" in result.output.lower()
+    assert "--command j" in result.output.lower()
+
+
+def test_j_completion_no_args_exits_with_error():
+    runner = CliRunner()
+    result = runner.invoke(j_completion, [])
+    assert result.exit_code == 2
+
+
+def test_j_completion_unsupported_shell_exits_with_error():
+    runner = CliRunner()
+    result = runner.invoke(j_completion, ["powershell"])
+    assert result.exit_code == 2
+
+
+def test_j_shell_complete_handles_system_exit_cleanly():
+    mock_cli_group = MagicMock()
+    mock_cli_group.side_effect = SystemExit(0)
+    mock_client = MagicMock()
+    mock_client.cli.return_value = mock_cli_group
+
+    with patch("jumpstarter_cli.j.env_async") as mock_env:
+        mock_env.return_value.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_env.return_value.__aexit__ = AsyncMock(return_value=False)
+        run(_j_shell_complete)
+        mock_client.cli.assert_called_once()
+        mock_cli_group.assert_called_once()
+
+
+def test_j_shell_complete_returns_empty_on_timeout():
+    from contextlib import asynccontextmanager
+
+    @asynccontextmanager
+    async def slow_env(*args, **kwargs):
+        await anyio.sleep(_COMPLETION_TIMEOUT_SECONDS + 1)
+        yield MagicMock()
+
+    with patch("jumpstarter_cli.j.env_async", slow_env):
+        result = run(_j_shell_complete)
+        assert result is None
+
+
+def test_completion_timeout_is_positive():
+    assert _COMPLETION_TIMEOUT_SECONDS > 0