pow-cli 0.1.1__tar.gz → 0.2.0rc2__tar.gz

pow_cli-0.2.0rc2/CHANGELOG.md

@@ -0,0 +1,170 @@
+# Changelog
+
+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
+
+- **Custom ROS Dockerfile (`pow init`)**
+  - New `ros_dockerfile` config in `pow.toml` — point to a project-local Dockerfile that layers on top of the bundled `pow_simros_<distro>` base image
+  - New `ros_container_name` config in `pow.toml` — set a custom container/image name (defaults to `pow_simros`)
+  - `pow init` now builds the custom image automatically after the base image when `ros_dockerfile` is set
+  - `pow ros` launches the custom image when configured, otherwise falls back to the base image
+- **Version flag (`pow --version` / `pow -v`)** — quickly check the installed `pow-cli` version from the command line
+
+### Changed
+
+- Updated CLI description to *"Manage Isaac Sim projects and simplify the development workflow"*
+- Renamed status messages from *"Isaac ROS workspace"* to *"Isaac Sim ROS workspace"* for clarity
+- Container name is now read from `ros_container_name` config instead of being hard-coded
+
+---
+
+## [0.1.1] - 2026-06-14
+
+### Fixed
+
+- **ROS Docker container: `colcon build` fails for new packages** — The container
+  entrypoint now detects stale build artifacts (left from a host-path build) and
+  cleans `build/`, `install/`, and `log/` automatically before rebuilding.
+
+---
+
+## [0.1.0] - 2026-06-05
+
+First stable release of `pow-cli`, promoted from `0.1.0-rc.1` with documentation improvements.
+
+
+### Fixed
+
+- Installation guide referenced incorrect `pow-cli` version
+
+### Changed
+
+- Improved README wording, tagline, and Profiles section
+
+---
+
+## [0.1.0-rc.1] - 2026-05-11
+
+### Added
+
+- **Asset Management (`pow asset`)**
+  - `pow asset list` — list available Isaac Sim & Omniverse assets
+  - `pow asset add` — download and register assets into the local asset folder (only support `isaacsim_5_1_0` for now)
+  - `pow asset set / unset` — set/unset target local asset folder
+  - `pow asset info` — display current local asset folder information
+- **Linter (`pow lint`)**
+  - New `pow lint` and `pow lint --fix` commands for `.usda` files
+  - Detects absolute/relative local asset paths and rewrites them with correct aliases or asset urls (`user-home`, `pow-assets`)
+  - Rule for validating `simros_ws` relative paths
+- **ROS Integration (`pow ros`)**
+  - `pow ros` command to build, launch, and attach to ROS 2 Docker containers
+  - Verbose mode (`--verbose`) for runtime diagnostics
+  - Separate Dockerfiles for ROS Humble and Jazzy distributions
+  - Project `scripts/` directory mounted into the container
+  - PyTorch with CUDA support available inside the container
+  - `isaacsim_ros_ws` working directory configurable in `pow.toml`
+- **Runner Improvements**
+  - (experimental) `pow run --open <file>` option to open a USD stage on launch 
+  - Non-existent `ext_folders` entries are now silently skipped instead of auto-created
+- **Other**
+  - `pow python` command with `--profile` flag for running standalone app under specified version of Isaac Sim's Python
+  - `user-home` aliases automatically configured during `pow init`
+  - `usda/` folder added to default project structure
+  - `extends` support in `pow.toml` for profile-based configuration
+
+### Fixed
+
+- ROS Jazzy container build failure on Ubuntu 24.04
+- CUDA version pinned to 12.1 for deterministic ROS builds
+- `.ros` / `.ros2` mount and permission issues in the SimROS container
+- SimROS entrypoint no longer warns when host-user directory already exists
+- `pow run` no longer calls `open_stage` when no path is provided
+- `pow asset unset` no longer accidentally removes `user-home` alias
+- Duplicate and deprecated keys in generated `.vscode/settings.json`
+- `pow init` now respects existing `isaacsim_ros_ws` value in existing `pow.toml`
+- `pow ros` correctly attaches to an already-running container
+
+### Changed
+
+- Rewrite and refactor all core functionality of pow-cli
+- Move commands under group `pow sim` to root `pow` command instead
+- Remove pow-foxglove from repository 
+- ROS-related logic extracted into dedicated `ros_manager.py` module
+- CLI and core layers refactored for clearer separation of concerns
+
+## [0.1.0a3] - 2026-01-27
+
+### Fixed
+
+- Fixed incorrect Ubuntu base Docker image version in `pow sim init` ROS workspace setup. Now correctly uses Ubuntu 22.04 for ROS Humble and Ubuntu 24.04 for ROS Jazzy (previously hardcoded to 22.04 for both).
+
+## [0.1.0a2] - 2025-12-25
+
+### Fixed
+
+- `pow sim init` now allows overwriting existing VS Code settings to resolve Pylance `reportMissingImports` errors for Isaac Sim packages.
+- Fixed an issue where the `ros_enable` flag did not correctly disable ROS workspace sourcing when set to `false` in an existing `pow.toml`.
+
+## [0.1.0a1] - 2025-12-23
+
+### Added
+
+- Initial alpha release of Isaac Powerpack CLI (`pow`)
+- **Core CLI Structure**
+  - Main entry point with Click-based command group architecture
+  - Hierarchical command organization under `pow sim` namespace
+
+- **Simulation Commands (`pow sim`)**
+  - `pow sim run` - Run Isaac Sim applications with automatic environment setup
+    - Auto-discovery of project root via `pow.toml` configuration
+    - ROS 2 workspace sourcing support
+    - Isaac Sim setup file sourcing
+    - Configurable app path and extension loading
+  - `pow sim init` - Initialize Isaac Sim development environment
+    - VS Code settings generation for Isaac Sim development
+    - Asset browser cache fix utility
+    - Project configuration scaffolding
+  - `pow sim check` - Run Isaac Sim compatibility checker
+    - Validates system compatibility with Isaac Sim requirements
+  - `pow sim info` - Display Isaac Sim configuration information
+    - Show local assets path configuration (`-l, --local-assets` flag)
+
+- **Resource Management (`pow sim add`)**
+  - `pow sim add local-assets` - Configure local Isaac Sim assets
+    - Updates `isaacsim.exp.base.kit` with local asset paths
+    - Configures asset browser and content browser folders
+    - Supports versioned asset directories
+
+### Dependencies
+
+- `click>=8.1.7` - Command line interface framework
+- `toml>=0.10.2` - TOML configuration file parsing
+- Python 3.10+ required

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pow-cli
-Version: 0.1.1
+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.1.1 → 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.1.1 → 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 ROS workspace...")
+            status.update("[bold green]Cloning Isaac Sim ROS workspace...")
         elif state == "existed":
-            status.update("[bold yellow]Isaac 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 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,
             )
@@ -356,13 +347,38 @@ def _step6_ros_integration(
     else:
         console.print(f"   [green]✔[/green] Docker image {simros_label} built successfully.")
 
+    # 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_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)
+            except Exception as e:
+                console.print(f"   [bold red]❌ Custom ROS Build Error:[/bold red] {e}")
+                console.print("   [yellow]⊖[/yellow] Skipping remaining steps due to build error.")
+                raise SystemExit(1)
+
+        console.print(
+            f"   [green]✔[/green] Custom Docker image [bold]{custom_image}[/bold] "
+            f"built from [dim]{custom_dockerfile}[/dim]."
+        )
+
     return True, display_path
 
 
 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.1.1 → 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.1.1 → pow_cli-0.2.0rc2}/pow_cli/cli/main.py

@@ -7,14 +7,24 @@ 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
 
 
 @click.group()
+@click.version_option(
+    None,
+    "-v",
+    "--version",
+    package_name="pow-cli",
+    prog_name="pow",
+    message="%(prog)s %(version)s",
+    help="Show the pow CLI version.",
+)
 def pow_group():
-    """Isaac Powerpack CLI for Isaac ROS and Isaac Sim development."""
+    """Manage Isaac Sim projects and simplify the development workflow."""
     pass
 
 
@@ -23,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.1.1 → 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)