pow-cli 0.2.0rc1__tar.gz → 0.2.0rc2__tar.gz

{pow_cli-0.2.0rc1 → pow_cli-0.2.0rc2}/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to the `pow-cli` package will be documented in this file.
 
+## [0.2.0-rc.2] - 2026-07-28
+
+### Added
+
+- **`pow sim`** — run Isaac Sim from any directory, with no project required: no `pyproject.toml` check and `pow.toml` is never read. Launches the default version (`5.1.0`, override with `-v/--version`) and forwards raw arguments straight to `isaac-sim.sh` (`pow sim -- --no-window`). The ROS 2 bridge environment is loaded by default (`--ros jazzy`); pass `--no-ros` to launch with the inherited environment instead
+- **`pow ros build`** — build the custom image from `ros_dockerfile` without re-running `pow init`; builds the `pow_simros_jazzy` base image first if it is missing, and supports `--no-cache`. `pow ros` is now a command group (bare `pow ros [args...]` usage is unchanged; `pow ros launch` is the explicit form)
+- **`ros_bridge` config in `pow.toml`** — choose which Isaac Sim internal ROS 2 bridge libs to load (`jazzy` or `humble`, default `jazzy`), i.e. which `exts/isaacsim.ros2.bridge/<distro>/lib` is added to `LD_LIBRARY_PATH` when `enable_ros = true`. Overridable per profile. Previously the bridge was inferred from the host Ubuntu version with no way to override it; an unsupported value is now rejected with a clear error
+- **Tab completion for the `pow init` ROS workspace path** — step 6's "Path to clone IsaacSim-ros_workspaces" prompt now completes filesystem paths on <kbd>Tab</kbd> like a shell: unique directories complete inline (no stray trailing space, so the next segment can be typed straight away), ambiguous prefixes list candidates, and `~` is kept in the stored path. Trailing separators and whitespace are trimmed before the value is written to `pow.toml`
+
+### Changed
+
+- **Breaking (vs 0.2.0-rc.1):** the `ros_container_name` config key was renamed to `ros_docker_image`. The container name is no longer configured directly — it is derived from the image name (`/` and `:` replaced with `_`), so default setups now get a container named `pow_simros_jazzy` instead of `pow_simros`
+- **Breaking (vs 0.2.0-rc.1):** ROS 2 Humble support was removed — the ROS workspace and docker integration now support Jazzy only (`Dockerfile.simros_humble` deleted). Isaac Sim itself still runs on Ubuntu 22.04 and 24.04; Jazzy workspaces build on both
+- **`pow init` no longer builds the Isaac Sim ROS workspace.** Step 6 only clones `IsaacSim-ros_workspaces`; the ROS 2 bridge comes from Isaac Sim's own prebuilt libs (selected by `ros_bridge`), so init is much faster and no longer runs a Docker build for the workspace. It reports the bridge distro in use instead of a build result
+- `pow init` no longer creates the `scripts/`, `.assets/`, and `standalone/` project folders (only `exts/`, `.modules/`, `usda/`). A manually created `scripts/` folder is still mounted into the ROS container when present
+- The `pow_simros_jazzy` image now resolves workspace dependencies with `rosdep install` at build time instead of building the workspace, and source-only packages (`topic_based_ros2_control`) are staged in `/opt/pow/extra_src` and copied into `/jazzy_ws/src` at container start, so the runtime volume mount no longer shadows them
+
+### Fixed
+
+- **`rosdep install` failed inside the Jazzy container** — three causes, all fixed (requires rebuilding the image): the Ubuntu 24.04 base image's stock `ubuntu` user took UID 1000 and collided with the mapped host user, so `HOME` pointed at `/home/ubuntu` while the host `~/.ros` was mounted at `/home/hostuser/.ros`; the per-user rosdep cache was empty because `rosdep update` had run as root at build time, giving "your rosdep installation has not been initialized"; and `ros-jazzy-ros-testing` was missing from the image
+- **`cpu_performance_mode` asked for the sudo password on every launch** — `pow run` / `pow python` now read the current CPU governor from `/sys/devices/system/cpu/cpu*/cpufreq/scaling_governor` first and run no `sudo` at all when it is already `performance`, so the password is normally needed once instead of every launch. When sudo credentials are still cached the governor is set without the "requires sudo" notice, and hosts without `cpupower` or without cpufreq support now report and skip rather than prompting for a password to no purpose. The interactive prompt itself is unchanged when the governor really has to be switched
+- **`ros2` tab completion inside the `pow_simros` container** — the entrypoint sourced ROS before exec'ing bash, which carried environment variables but not bash completion functions. Interactive shells now re-source `/opt/ros/jazzy/setup.bash` and the workspace overlay via `/etc/bash.bashrc`, so `ros2` / `colcon` autocomplete works without manually sourcing `setup.bash` (requires rebuilding the image)
+
+---
+
 ## [0.2.0-rc.1] - 2026-06-14
 
 ### Added

{pow_cli-0.2.0rc1 → pow_cli-0.2.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pow-cli
-Version: 0.2.0rc1
+Version: 0.2.0rc2
 Summary: Command line interface for Isaac Powerpack
 Author: Titiwat Munintravong, Isaac Powerpack Contributors
 License-Expression: Apache-2.0

{pow_cli-0.2.0rc1 → pow_cli-0.2.0rc2}/pow_cli/cli/asset.py

@@ -307,7 +307,6 @@ def list_cmd():
     console.print()
     try:
         from ..core.asset_manager import REGISTRIES
-        from itertools import groupby
 
         target_groups = set()
         for r in REGISTRIES:

{pow_cli-0.2.0rc1 → pow_cli-0.2.0rc2}/pow_cli/cli/init.py

@@ -6,11 +6,10 @@ from pathlib import Path
 import click
 from rich.panel import Panel
 from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
-from rich.prompt import Confirm, Prompt
-from rich.text import Text
+from rich.prompt import Confirm
 
+from ..common.prompt import ask_path
 from ..common.utils import console
-from ..core.models.pow_config import PowConfig
 from ..core.initializer import Initializer
 from ..core.ros_manager import RosManager
 
@@ -63,7 +62,7 @@ def _step1_check_config(global_dir_name: str) -> bool:
     """Print config header and verify pyproject.toml exists. Return False to abort."""
     if not Path("pyproject.toml").exists():
         console.print(
-            "\n[bold red][1/8] ❌ Error:[/bold red] pyproject.toml not found. "
+            "\n[bold red][1/10] ❌ Error:[/bold red] pyproject.toml not found. "
             "Please run this command in a valid project directory."
         )
         return False
@@ -260,7 +259,7 @@ def _step6_ros_integration(
         ws_path = forced_ws
         console.print(f"   Using existing workspace path from pow.toml: [bold green]{ws_path}[/bold green]")
     else:
-        ws_path = Prompt.ask(
+        ws_path = ask_path(
             "   Path to clone IsaacSim-ros_workspaces",
             default=default_ws,
         )
@@ -277,28 +276,19 @@ def _step6_ros_integration(
     console.print(f"   [dim]Workspace path:[/dim] {display_path}")
 
     ros_cloned = False
-    ros_already_built = False
 
     def ros_status_callback(state):
-        nonlocal ros_cloned, ros_already_built
+        nonlocal ros_cloned
         if state == "cloning":
             ros_cloned = True
             status.update("[bold green]Cloning Isaac Sim ROS workspace...")
         elif state == "existed":
-            status.update("[bold yellow]Isaac Sim ROS workspace already exists. Checking build...")
-        elif state == "built":
-            ros_already_built = True
-            status.update("[bold yellow]Docker build already complete.")
-        elif state == "building":
-            status.update("[bold green]Docker build: Isaac Sim ROS workspace...")
-        elif state.startswith("building:"):
-            line = state[len("building:"):]
-            status.update(f"[bold green]Docker build:[/bold green] [dim]{line[:80]}[/dim]")
+            status.update("[bold yellow]Isaac Sim ROS workspace already exists.")
 
     # Resolve the tilde path for actual filesystem operations
     resolved_ws = Path(ws_path).expanduser()
 
-    ros_build_failed = False
+    ros_setup_failed = False
 
     with console.status("Preparing ROS workspace...") as status:
         try:
@@ -307,11 +297,11 @@ def _step6_ros_integration(
                 ws_path=resolved_ws,
             )
         except Exception as e:
-            ros_build_failed = True
+            ros_setup_failed = True
             console.print(f"   [bold red]❌ ROS Setup Error:[/bold red] {e}")
 
-    if ros_build_failed:
-        console.print("   [yellow]⊖[/yellow] Skipping remaining steps due to ROS build error.")
+    if ros_setup_failed:
+        console.print("   [yellow]⊖[/yellow] Skipping remaining steps due to ROS setup error.")
         raise SystemExit(1)
 
     if ros_cloned:
@@ -319,11 +309,12 @@ def _step6_ros_integration(
     else:
         console.print(f"   [yellow]✔[/yellow] IsaacSim-ros_workspaces already available in [dim]{display_path}[/dim]")
 
-    distro_label = f"ROS [bold]{ros_res['ros_distro']}[/bold] (Ubuntu {ros_res['ubuntu_version']})"
-    if ros_already_built:
-        console.print(f"   [yellow]✔[/yellow] Docker build already complete for {distro_label}.")
-    else:
-        console.print(f"   [green]✔[/green] Docker build complete for {distro_label}.")
+    bridge_distro = ros_mgr.config.ros_bridge
+    console.print(
+        f"   [green]✔[/green] ROS bridge: [bold]{bridge_distro}[/bold] "
+        f"(ros_bridge in pow.toml, host Ubuntu {ros_res['ubuntu_version']}) "
+        f"via Isaac Sim internal libs."
+    )
 
     # Build pow_simros Docker image
     simros_already_built = False
@@ -341,7 +332,7 @@ def _step6_ros_integration(
 
     with console.status("Building pow_simros image...") as simros_status:
         try:
-            simros_res = ros_mgr.build_simros_image(
+            ros_mgr.build_simros_image(
                 status_callback=simros_status_callback,
                 ws_path=resolved_ws,
             )
@@ -359,7 +350,7 @@ def _step6_ros_integration(
     # Build custom ROS image layered on top of pow_simros_<distro>
     custom_dockerfile = ros_mgr.config.ros_dockerfile
     if custom_dockerfile:
-        custom_image = ros_mgr.config.ros_container_name
+        custom_image = ros_mgr.config.ros_docker_image
 
         def custom_status_callback(state):
             if state == "custom_building":
@@ -387,7 +378,7 @@ def _step6_ros_integration(
 def _step7_project_structure(initializer: Initializer):
     """Create local project folders and .gitignore."""
     console.print("[bold blue][7/10] 🏗️ Project Structure:[/bold blue] Creating local folders...")
-    local_folders = ["exts", "scripts", ".modules", ".assets", "standalone", "usda"]
+    local_folders = ["exts", ".modules", "usda"]
 
     with Progress(
         SpinnerColumn(),

{pow_cli-0.2.0rc1 → pow_cli-0.2.0rc2}/pow_cli/cli/lint.py

@@ -5,8 +5,6 @@ from pathlib import Path
 import click
 from rich.markup import escape
 from rich.panel import Panel
-from rich.table import Table
-from rich.text import Text
 
 from ..common.utils import console
 from ..core.linter import AliasConfig, lint_file, fix_file, scan_directory

{pow_cli-0.2.0rc1 → pow_cli-0.2.0rc2}/pow_cli/cli/main.py

@@ -7,7 +7,8 @@ from .init import init_cmd
 from .check import check_cmd
 from .lint import lint_group
 from .run import run_cmd
-from .ros import ros_cmd
+from .sim import sim_cmd
+from .ros import ros_group
 from .python import python_cmd
 from .asset import asset_group
 
@@ -32,6 +33,7 @@ pow_group.add_command(init_cmd)
 pow_group.add_command(check_cmd)
 pow_group.add_command(lint_group)
 pow_group.add_command(run_cmd)
-pow_group.add_command(ros_cmd)
+pow_group.add_command(sim_cmd)
+pow_group.add_command(ros_group)
 pow_group.add_command(python_cmd)
 pow_group.add_command(asset_group)

pow_cli-0.2.0rc2/pow_cli/cli/ros.py

@@ -0,0 +1,155 @@
+"""Ros command implementation."""
+
+import click
+from rich.panel import Panel
+from ..common.utils import console
+from ..core.ros_manager import RosManager
+
+
+def _launch_container(extra_args, verbose: bool):
+    """Launch or attach to the ROS container, rendering errors as panels."""
+    try:
+        RosManager.run_simros_container(extra_args=extra_args, verbose=verbose)
+    except click.ClickException:
+        raise
+    except Exception as e:
+        console.print(
+            Panel(
+                f"[bold red]✘[/bold red]  {e}",
+                title="[bold red]ROS Error[/bold red]",
+                border_style="red",
+            )
+        )
+        raise SystemExit(1)
+
+
+class RosGroup(click.Group):
+    """Group that falls through to `launch` for unrecognized arguments."""
+
+    def resolve_command(self, ctx, args):
+        if args and self.get_command(ctx, args[0]) is not None:
+            return super().resolve_command(ctx, args)
+        launch = self.get_command(ctx, "launch")
+        return launch.name, launch, args
+
+
+@click.group(
+    name="ros",
+    cls=RosGroup,
+    invoke_without_command=True,
+    context_settings={"ignore_unknown_options": True},
+)
+@click.pass_context
+def ros_group(ctx: click.Context):
+    """Launch or manage the ROS docker container.
+
+    Without a subcommand, launches an interactive session in the container
+    running the image from `ros_docker_image` in pow.toml (or attaches to it
+    if it is already running).  Unrecognized arguments are forwarded as the
+    container command (default: /bin/bash), e.g. `pow ros ros2 topic list`.
+
+    \b
+    Subcommands:
+      launch  Explicitly launch the container (same as bare `pow ros`).
+      build   Build the custom image from `ros_dockerfile`.
+
+    \b
+    Requires:
+      - ROS integration enabled in pow.toml (enable_ros = true).
+      - The pow_simros Docker image built via `pow init`.
+    """
+    if ctx.invoked_subcommand is None:
+        _launch_container(None, False)
+
+
+@ros_group.command(
+    name="launch",
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
+)
+@click.option("--verbose", "-v", is_flag=True, default=False, help="Show detailed feedback during container launch.")
+@click.pass_context
+def launch_cmd(ctx: click.Context, verbose: bool):
+    """Launch the ROS container, forwarding extra args as the container command."""
+    _launch_container(ctx.args or None, verbose)
+
+
+@ros_group.command(name="build")
+@click.option("--no-cache", is_flag=True, default=False, help="Build without using the Docker layer cache.")
+def build_cmd(no_cache: bool):
+    """Build the custom ROS image from `ros_dockerfile` in pow.toml."""
+    ros_mgr = RosManager()
+    config = ros_mgr.config
+
+    if config.project_root is None:
+        raise click.ClickException("Not initialized. Run `pow init` first.")
+
+    if not config.ros_dockerfile:
+        console.print(
+            "[yellow]No `ros_dockerfile` set in pow.toml; nothing to build.[/yellow]\n"
+            f"The bundled [bold]pow_simros_{config.ros_distro}[/bold] image is built by `pow init`."
+        )
+        return
+
+    base_image = f"pow_simros_{config.ros_distro}"
+    if not RosManager.image_exists(base_image):
+        distro_ws = config.ros_ws_path / f"{config.ros_distro}_ws"
+        if not distro_ws.exists():
+            raise click.ClickException(
+                f"Base image '{base_image}' not found and the ROS workspace "
+                f"'{distro_ws}' does not exist.\n"
+                "Run `pow init` first to set up the ROS workspace."
+            )
+
+        console.print(f"[yellow]Base image '{base_image}' not found — building it first.[/yellow]")
+
+        def simros_status_callback(state):
+            if state == "simros_building":
+                base_status.update(f"[bold green]Building base image '{base_image}'...")
+            elif state.startswith("simros_building:"):
+                line = state[len("simros_building:"):]
+                base_status.update(f"[bold green]{base_image} build:[/bold green] [dim]{line[:80]}[/dim]")
+
+        with console.status(f"Building base image '{base_image}'...") as base_status:
+            try:
+                ros_mgr.build_simros_image(status_callback=simros_status_callback)
+            except Exception as e:
+                console.print(
+                    Panel(
+                        f"[bold red]✘[/bold red]  {e}",
+                        title="[bold red]ROS Build Error[/bold red]",
+                        border_style="red",
+                    )
+                )
+                raise SystemExit(1)
+
+        console.print(f"[green]✔[/green] Base Docker image [bold]{base_image}[/bold] built successfully.")
+
+    custom_image = config.ros_docker_image
+
+    def custom_status_callback(state):
+        if state == "custom_building":
+            custom_status.update(f"[bold green]Building custom image '{custom_image}'...")
+        elif state.startswith("custom_building:"):
+            line = state[len("custom_building:"):]
+            custom_status.update(f"[bold green]custom build:[/bold green] [dim]{line[:80]}[/dim]")
+
+    with console.status(f"Building custom image '{custom_image}'...") as custom_status:
+        try:
+            ros_mgr.build_custom_ros_image(
+                status_callback=custom_status_callback,
+                no_cache=no_cache,
+            )
+        except Exception as e:
+            console.print(
+                Panel(
+                    f"[bold red]✘[/bold red]  {e}",
+                    title="[bold red]ROS Build Error[/bold red]",
+                    border_style="red",
+                )
+            )
+            raise SystemExit(1)
+
+    console.print(
+        f"[green]✔[/green] Custom Docker image [bold]{custom_image}[/bold] "
+        f"built from [dim]{config.ros_dockerfile}[/dim]."
+    )

{pow_cli-0.2.0rc1 → pow_cli-0.2.0rc2}/pow_cli/cli/run.py

@@ -1,8 +1,6 @@
 """Run command implementation."""
 
 import click
-from rich.panel import Panel
-from ..common.utils import console
 from ..core.runner import Runner
 
 @click.command(

pow_cli-0.2.0rc2/pow_cli/cli/sim.py

@@ -0,0 +1,67 @@
+"""Sim command implementation."""
+
+import click
+from rich.panel import Panel
+from ..common.utils import console
+from ..core.models.pow_config import PowConfig
+from ..core.runner import Runner
+
+
+@click.command(
+    name="sim",
+    context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
+)
+@click.option(
+    "-v",
+    "--version",
+    "sim_version",
+    default=PowConfig.ISAACSIM_VERSION,
+    show_default=True,
+    help="Isaac Sim version to run.",
+)
+@click.option(
+    "--ros",
+    "ros_bridge",
+    type=click.Choice(PowConfig.SUPPORTED_ROS_BRIDGES),
+    default=PowConfig.ROS_BRIDGE,
+    show_default=True,
+    help="ROS 2 bridge distro to load into the environment.",
+)
+@click.option(
+    "--no-ros",
+    is_flag=True,
+    default=False,
+    help="Launch without the ROS 2 bridge environment.",
+)
+@click.pass_context
+def sim_cmd(ctx: click.Context, sim_version: str, ros_bridge: str, no_ros: bool):
+    """Run Isaac Sim from any directory, ignoring pow.toml.
+
+    \b
+    Unlike `pow run` this needs no project: no pyproject.toml is required and
+    pow.toml is never read. Every unrecognized argument is forwarded verbatim
+    to .pow/isaacsim/<version>/isaac-sim.sh.
+
+    \b
+    Examples:
+      pow sim
+      pow sim --no-ros
+      pow sim -- --no-window --/renderer/enabled=gpu
+    """
+    try:
+        Runner.run_sim(
+            version=sim_version,
+            ros_bridge=None if no_ros else ros_bridge,
+            extra_args=ctx.args,
+        )
+    except click.ClickException:
+        raise
+    except Exception as e:
+        console.print(
+            Panel(
+                f"[bold red]✘[/bold red]  {e}",
+                title="[bold red]Sim Error[/bold red]",
+                border_style="red",
+            )
+        )
+        raise SystemExit(1)

pow_cli-0.2.0rc2/pow_cli/common/prompt.py

@@ -0,0 +1,136 @@
+"""Interactive prompts with shell-style TAB path completion."""
+
+import glob
+import os
+import re
+from contextlib import contextmanager
+from pathlib import Path
+
+from rich.prompt import Prompt
+
+from .utils import console
+
+# ANSI SGR sequences must be hidden from readline's column arithmetic, otherwise
+# the cursor lands in the wrong place after a completion redisplay.
+_ANSI_RE = re.compile(r"(\x1b\[[0-9;]*m)")
+
+
+def complete_path(text: str, dirs_only: bool = False) -> list[str]:
+    """Return the filesystem completions for *text*, shell style.
+
+    Directories come back with a trailing separator, and a leading ``~`` is
+    preserved so the completed value stays tilde-relative.
+    """
+    expanded = os.path.expanduser(text)
+    matches = glob.glob(expanded + "*")
+
+    if dirs_only:
+        matches = [m for m in matches if os.path.isdir(m)]
+
+    matches = [m + os.sep if os.path.isdir(m) else m for m in matches]
+
+    if text.startswith("~"):
+        home = str(Path.home())
+        matches = [
+            "~" + m[len(home):] if m.startswith(home) else m
+            for m in matches
+        ]
+
+    return sorted(matches)
+
+
+@contextmanager
+def _path_completion(dirs_only: bool = False):
+    """Install a path completer on readline for the duration of one prompt.
+
+    ``readline`` is imported lazily: importing it changes ``input()`` behaviour
+    process-wide, which should not happen just because some other command was
+    run.  Yields ``True`` when completion is active, ``False`` when readline is
+    unavailable (no completion, prompt still works).
+    """
+    try:
+        import readline
+    except ImportError:
+        yield False
+        return
+
+    matches: list[str] = []
+
+    def completer(text: str, state: int):
+        nonlocal matches
+        if state == 0:
+            # Delims are "\n" (see below), so `text` is the whole line and each
+            # match replaces it entirely.  rstrip() absorbs any stray trailing
+            # space.
+            matches = complete_path(text.rstrip(), dirs_only=dirs_only)
+            if len(matches) == 1 and matches[0].endswith(os.sep):
+                # readline appends a space after a *unique* match and Python
+                # exposes no way to turn that off.  For a directory that would
+                # strand the cursor behind a space; duplicating the match makes
+                # it non-unique, so the inserted text is exactly the path and
+                # the next segment can be typed straight away, shell style.
+                # Files keep the space, which is what a shell does too.
+                matches = matches * 2
+        return matches[state] if state < len(matches) else None
+
+    prev_completer = readline.get_completer()
+    prev_delims = readline.get_completer_delims()
+
+    # Breaking words on "\n" only (never present in a line) makes the whole line
+    # the completion word.  The default delims include "/", "~" and "-", which
+    # would hand the completer useless fragments; this also lets paths with
+    # spaces complete correctly.
+    readline.set_completer_delims("\n")
+    readline.set_completer(completer)
+
+    # uv-managed CPython links libedit, which needs its own binding syntax.
+    if "libedit" in (readline.__doc__ or ""):
+        readline.parse_and_bind("bind ^I rl_complete")
+    else:
+        readline.parse_and_bind("tab: complete")
+
+    try:
+        yield True
+    finally:
+        readline.set_completer(prev_completer)
+        readline.set_completer_delims(prev_delims)
+
+
+class PathPrompt(Prompt):
+    """A :class:`rich.prompt.Prompt` whose input line completes paths on TAB."""
+
+    dirs_only: bool = False
+
+    @classmethod
+    def get_input(cls, console, prompt, password: bool, stream=None) -> str:
+        if password or stream is not None:
+            return super().get_input(console, prompt, password, stream=stream)
+
+        # Hand the rendered prompt to input() rather than printing it first:
+        # readline needs to know the prompt to redraw the line after listing
+        # matches, otherwise the prompt vanishes on the first ambiguous TAB.
+        with console.capture() as capture:
+            console.print(prompt, end="")
+        rendered = _ANSI_RE.sub("\x01\\1\x02", capture.get())
+
+        with _path_completion(dirs_only=cls.dirs_only):
+            return input(rendered)
+
+
+class _DirPrompt(PathPrompt):
+    dirs_only = True
+
+
+def ask_path(message: str, *, default: str, dirs_only: bool = True) -> str:
+    """Ask for a filesystem path, completing it with TAB like a shell does.
+
+    Trailing whitespace and a trailing separator are stripped, since TAB
+    completion makes both common and the value is stored as-is in pow.toml.
+    """
+    prompt_cls = _DirPrompt if dirs_only else PathPrompt
+    value = prompt_cls.ask(message, default=default, console=console).strip()
+
+    if len(value) > 1:
+        value = value.rstrip(os.sep)
+
+    return value