add CLI support for Shell driver methods

so that they show up in jmp shell.

Author: michalskrivanek

packages/jumpstarter-driver-shell/README.md

@@ -63,3 +63,53 @@ methods will be generated dynamically, and they will be available as follows:
 
     :returns: A tuple(stdout, stderr, return_code)
 ```
+
+## CLI Usage
+
+The shell driver also provides a CLI when using `jmp shell`. All configured methods become available as CLI commands, except for methods starting with `_` which are considered private and hidden from the end user:
+
+```console
+$ jmp shell --exporter shell-exporter
+$ j shell
+Usage: j shell [OPTIONS] COMMAND [ARGS]...
+
+  Shell command executor
+
+Commands:
+  env_var  Execute the env_var shell method
+  ls       Execute the ls shell method
+  method2  Execute the method2 shell method
+  method3  Execute the method3 shell method
+```
+
+### CLI Command Usage
+
+Each configured method becomes a CLI command with the following options:
+
+```console
+$ j shell ls --help
+Usage: j shell ls [OPTIONS] [ARGS]...
+
+  Execute the ls shell method
+
+Options:
+  -e, --env TEXT  Environment variables in KEY=VALUE format
+  --help          Show this message and exit.
+```
+
+### Examples
+
+```console
+# Execute simple commands
+$ j shell ls
+file1.txt  file2.txt  directory/
+
+# Pass arguments to shell methods
+$ j shell method3 "first arg" "second arg"
+Hello World first arg
+Hello World second arg
+
+# Set environment variables
+$ j shell env_var arg1 arg2 --env ENV_VAR=myvalue
+arg1,arg2,myvalue
+```

packages/jumpstarter-driver-shell/jumpstarter_driver_shell/client.py

@@ -1,5 +1,7 @@
 from dataclasses import dataclass
 
+import click
+
 from jumpstarter.client import DriverClient
 
 
@@ -25,3 +27,52 @@ def _check_method_exists(self, method):
     def __getattr__(self, name):
         self._check_method_exists(name)
         return lambda *args, **kwargs: tuple(self.call("call_method", name, kwargs, *args))
+
+    def cli(self):
+        """Create CLI interface for dynamically configured shell methods"""
+        @click.group
+        def base():
+            """Shell command executor"""
+            pass
+
+        # Get available methods from the driver
+        if self._methods is None:
+            self._methods = self.call("get_methods")
+
+        # Create a command for each configured method (excluding private methods starting with _)
+        for method_name in self._methods:
+            self._add_method_command(base, method_name)
+
+        return base
+
+    def _add_method_command(self, group, method_name):
+        """Add a Click command for a specific shell method"""
+        @group.command(name=method_name)
+        @click.argument('args', nargs=-1)
+        @click.option('--env', '-e', multiple=True,
+                     help='Environment variables in KEY=VALUE format')
+        def method_command(args, env):
+            # Parse environment variables
+            env_dict = {}
+            for env_var in env:
+                if '=' in env_var:
+                    key, value = env_var.split('=', 1)
+                    env_dict[key] = value
+                else:
+                    raise click.BadParameter(f"Invalid --env value '{env_var}'. Use KEY=VALUE.")
+
+            # Call the method
+            stdout, stderr, returncode = self.call("call_method", method_name, env_dict, *args)
+
+            # Display results
+            if stdout:
+                click.echo(stdout, nl=not stdout.endswith("\n"))
+            if stderr:
+                click.echo(stderr, err=True, nl=not stderr.endswith("\n"))
+
+            # Exit with the same return code as the shell command
+            if returncode != 0:
+                raise click.exceptions.Exit(returncode)
+
+        # Update the docstring dynamically
+        method_command.__doc__ = f"Execute the {method_name} shell method"

packages/jumpstarter-driver-shell/jumpstarter_driver_shell/driver_test.py

@@ -47,3 +47,94 @@ def test_unknown_method(client):
         assert "method unknown not found in" in str(e)
     else:
         raise AssertionError("Expected AttributeError")
+
+
+def test_cli_interface(client):
+    """Test that the CLI interface is created with all methods"""
+    cli = client.cli()
+
+    # Check that it's a Click group
+    assert hasattr(cli, 'commands')
+
+    # Check that all configured methods are available as commands
+    expected_methods = {"echo", "env", "multi_line", "exit1", "stderr"}
+    available_commands = set(cli.commands.keys())
+
+    assert expected_methods == available_commands, f"Expected {expected_methods}, got {available_commands}"
+
+
+def test_cli_method_execution(client):
+    """Test that CLI methods can be executed"""
+    cli = client.cli()
+
+    # Test that we can get the echo command
+    echo_command = cli.commands.get('echo')
+    assert echo_command is not None
+    assert echo_command.name == 'echo'
+
+
+def test_cli_includes_all_methods():
+    """Test that CLI includes all methods, including those starting with _"""
+    from .driver import Shell
+    from jumpstarter.common.utils import serve
+
+    shell_instance = Shell(
+        log_level="DEBUG",
+        methods={
+            "method1": "echo method1",
+            "method2": "echo method2",
+            "method3": "echo method3",
+        },
+    )
+
+    with serve(shell_instance) as test_client:
+        cli = test_client.cli()
+        available_commands = set(cli.commands.keys())
+
+        # All methods should be available
+        expected_methods = {"method1", "method2", "method3"}
+        assert available_commands == expected_methods, f"Expected {expected_methods}, got {available_commands}"
+
+
+def test_cli_exit_codes():
+    """Test that CLI commands preserve shell command exit codes"""
+    import click
+
+    from .driver import Shell
+    from jumpstarter.common.utils import serve
+
+    # Create a shell instance with methods that have different exit codes
+    shell_instance = Shell(
+        log_level="DEBUG",
+        methods={
+            "success": "exit 0",
+            "fail_1": "exit 1",
+            "fail_42": "exit 42",
+        },
+    )
+
+    with serve(shell_instance) as test_client:
+        cli = test_client.cli()
+
+        # Test successful command (exit 0) - should not raise
+        success_cmd = cli.commands['success']
+        try:
+            success_cmd.callback([], [])  # Call with empty args and env
+        except click.exceptions.Exit:
+            raise AssertionError("Success command should not raise Exit exception") from None
+
+        # Test command that exits with code 1 - should raise Exit(1)
+        fail1_cmd = cli.commands['fail_1']
+        try:
+            fail1_cmd.callback([], [])
+            raise AssertionError("Command should have raised Exit exception")
+        except click.exceptions.Exit as e:
+            assert e.exit_code == 1
+
+        # Test command that exits with code 42 - should raise Exit(42)
+        fail42_cmd = cli.commands['fail_42']
+        try:
+            fail42_cmd.callback([], [])
+            raise AssertionError("Command should have raised Exit exception")
+        except click.exceptions.Exit as e:
+            assert e.exit_code == 42

packages/jumpstarter-driver-shell/pyproject.toml

@@ -6,7 +6,7 @@ readme = "README.md"
 authors = [{ name = "Miguel Angel Ajo", email = "miguelangel@ajo.es" }]
 requires-python = ">=3.11"
 license = "Apache-2.0"
-dependencies = ["anyio>=4.6.2.post1", "jumpstarter"]
+dependencies = ["anyio>=4.6.2.post1", "jumpstarter", "click>=8.1.7.2"]
 
 [project.entry-points."jumpstarter.drivers"]
 Shell = "jumpstarter_driver_shell.driver:Shell"