fix(robotcode): make the wrapper work in VS Code

Running or debugging tests through a wrapper did not work from the
editor, where robotcode runs from a bundled path instead of being
installed in the interpreter. Two things are fixed:

- The debug launcher no longer applies the wrapper itself; it forwards a
  launch.json wrapper to robotcode as --wrapper and lets robotcode apply
  it (so a launch.json wrapper still overrides the profile's).

- When robotcode re-executes itself under the wrapper it re-runs through
  the same entry it was started from (--launcher-script) instead of
  python -m robotcode.cli, which the bundled interpreter cannot import.
  ROBOTCODE_BUNDLED_ROBOTCODE_MAIN is deliberately not used for this: VS
  Code sets it in every terminal, so it would divert a directly started
  robotcode to the bundled copy.

Author: d-biehl

packages/debugger/src/robotcode/debugger/launcher/server.py

@@ -3,6 +3,7 @@
 import asyncio
 import itertools
 import os
+import shlex
 import sys
 from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional
@@ -11,7 +12,6 @@
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
 from robotcode.jsonrpc2.server import JsonRPCServer
-from robotcode.plugin.click_helper.wrappable import WRAPPER_APPLIED_ENV
 from robotcode.robot.utils import RF_VERSION
 
 from ..cli import DEBUGGER_DEFAULT_PORT, DEBUGPY_DEFAULT_PORT
@@ -44,6 +44,32 @@
 from .client import DAPClient, DAPClientError
 
 
+def _build_robotcode_run_args(
+    python: str,
+    debugger_script: List[str],
+    profiles: Optional[List[str]],
+    paths: Optional[List[str]],
+    wrapper: Optional[List[str]],
+    robot_code_args: Optional[List[str]],
+) -> List[str]:
+    """Build the ``robotcode … debug`` command line.
+
+    A ``wrapper`` from the launch request (VS Code ``robotcode.debug.launchWrapper``)
+    is forwarded to robotcode as ``--wrapper``; robotcode applies it itself (and
+    ``--wrapper`` overrides the profile's ``wrapper``). Without one nothing is added
+    and robotcode resolves its profile ``wrapper`` alone.
+    """
+    return [
+        python,
+        *debugger_script,
+        *itertools.chain.from_iterable(["-p", p] for p in profiles or []),
+        *itertools.chain.from_iterable(["-dp", p] for p in paths or []),
+        *(["--wrapper", shlex.join(wrapper)] if wrapper else []),
+        *(robot_code_args or []),
+        "debug",
+    ]
+
+
 class OutputProtocol(asyncio.SubprocessProtocol):
     def __init__(self, parent: LauncherDebugAdapterProtocol) -> None:
         super().__init__()
@@ -147,14 +173,9 @@ async def _launch(
 
         debugger_script = ["-m", "robotcode.cli"] if self.debugger_script is None else [str(Path(self.debugger_script))]
 
-        robotcode_run_args = [
-            python or sys.executable,
-            *debugger_script,
-            *itertools.chain.from_iterable(["-p", p] for p in profiles or []),
-            *itertools.chain.from_iterable(["-dp", p] for p in paths or []),
-            *(robotCodeArgs or []),
-            "debug",
-        ]
+        robotcode_run_args = _build_robotcode_run_args(
+            python or sys.executable, debugger_script, profiles, paths, wrapper, robotCodeArgs
+        )
 
         if no_debug:
             robotcode_run_args += ["--no-debug"]
@@ -242,14 +263,6 @@ async def _launch(
 
         env = {k: ("" if v is None else str(v)) for k, v in env.items()} if env else {}
 
-        # A wrapper from the launch request (VS Code `robotcode.debug.launchWrapper`)
-        # takes precedence: prefix the run command with it and mark the environment
-        # so the spawned robotcode process does NOT re-wrap from its own profile or
-        # `--wrapper`.
-        if wrapper:
-            robotcode_run_args = [*wrapper, *robotcode_run_args]
-            env[WRAPPER_APPLIED_ENV] = "1"
-
         if console in ["integratedTerminal", "externalTerminal"]:
             await self.send_request_async(
                 RunInTerminalRequest(

src/robotcode/cli/__init__.py

@@ -116,7 +116,17 @@ def _maybe_reexec_under_wrapper(
     else:
         return
 
-    command = [*wrapper, sys.executable, "-m", "robotcode.cli", *sys.argv[1:]]
+    # Rebuild the invocation the way this process was actually started, so the
+    # re-exec finds robotcode even when it runs from a bundled path (VS Code) and
+    # is not installed in the interpreter. `launcher_script` is set only when we
+    # were started through a bundled entry (its `__main__` sets it) or an explicit
+    # `--launcher-script`; otherwise robotcode is importable directly and
+    # `-m robotcode.cli` is correct. We deliberately do NOT consult the
+    # ROBOTCODE_BUNDLED_ROBOTCODE_MAIN env var: VS Code sets it in every terminal,
+    # so a directly started robotcode would be diverted to the bundled copy.
+    # Mirrors the debug launcher's `debugger_script` handling.
+    entry = [str(app.config.launcher_script)] if app.config.launcher_script else ["-m", "robotcode.cli"]
+    command = [*wrapper, sys.executable, *entry, *sys.argv[1:]]
     app.verbose(lambda: "Re-executing under wrapper: " + " ".join(command))
 
     os.environ[WRAPPER_APPLIED_ENV] = "1"

tests/robotcode/cli/test_wrapper.py

@@ -42,6 +42,25 @@ def _write_wrapper(path: Path) -> Path:
     return path
 
 
+# A wrapper that records the command line it was handed (into "<path>.argv"),
+# then runs it — used to inspect how the re-exec reconstructed the invocation.
+_RECORDER_PY = (
+    "import os, sys\n"
+    "with open(__file__ + '.argv', 'w', encoding='utf-8') as f:\n"
+    "    f.write(' '.join(sys.argv[1:]))\n"
+    "os.execv(sys.argv[1], sys.argv[1:])\n"
+)
+
+
+def _write_recorder(path: Path) -> Path:
+    path.write_text(_RECORDER_PY, encoding="utf-8")
+    return path
+
+
+def _recorded_argv(recorder: Path) -> str:
+    return Path(str(recorder) + ".argv").read_text(encoding="utf-8")
+
+
 def _calls(wrapper: Path) -> List[str]:
     marker = Path(str(wrapper) + ".called")
     return marker.read_text(encoding="utf-8").splitlines() if marker.exists() else []
@@ -113,8 +132,8 @@ def test_wrappable_command_runs_through_the_profile_wrapper(project: Path) -> No
 
 @requires_posix_exec
 def test_guard_env_suppresses_wrapping(project: Path) -> None:
-    """When an outer layer (the VS Code launcher applying its DAP wrapper) has
-    already set ROBOTCODE_WRAPPER_APPLIED, the inner process must not wrap."""
+    """The re-exec sets ROBOTCODE_WRAPPER_APPLIED before replacing the process,
+    so a robotcode that already runs under a wrapper must not wrap again."""
     wrapper = project / "wrap.py"
     result = _run_robotcode(
         project,
@@ -155,3 +174,76 @@ def test_non_wrappable_command_is_not_wrapped(project: Path) -> None:
     # `discover` only parses files; it must never run through the wrapper.
     _run_robotcode(project, ["-p", "x11", "discover", "all", "suite.robot"])
     assert _calls(wrapper) == []
+
+
+@requires_posix_exec
+def test_reexec_goes_through_the_launcher_script(project: Path, tmp_path: Path) -> None:
+    """When robotcode was started through a bundled entry (`--launcher-script` /
+    the bundled `__main__`), the re-exec must reuse that entry — not
+    `python -m robotcode.cli`, which a bundled interpreter can't import."""
+    bundled_main = tmp_path / "bundled_main.py"  # stand-in for the bundled entry
+    bundled_main.write_text("from robotcode.cli import robotcode\n\nrobotcode()\n", encoding="utf-8")
+    recorder = _write_recorder(project / "record.py")
+
+    result = _run_robotcode(
+        project,
+        [
+            "--launcher-script",
+            str(bundled_main),
+            "--wrapper",
+            f"{shlex.quote(sys.executable)} {shlex.quote(str(recorder))}",
+            "-p",
+            "x11",
+            "run",
+            "suite.robot",
+        ],
+    )
+    assert result.returncode == 0, result.stderr
+    recorded = _recorded_argv(recorder)
+    assert str(bundled_main) in recorded  # re-exec went through the launcher script
+    assert "-m robotcode.cli" not in recorded
+
+
+@requires_posix_exec
+def test_direct_start_ignores_bundled_main_env(project: Path, tmp_path: Path) -> None:
+    """A directly started robotcode (no `--launcher-script`) must NOT be diverted
+    to the bundled copy just because ROBOTCODE_BUNDLED_ROBOTCODE_MAIN is set — the
+    extension sets that in every VS Code terminal."""
+    broken = tmp_path / "must_not_run.py"
+    broken.write_text("import sys\nsys.exit('the bundled entry must not be used here')\n", encoding="utf-8")
+    recorder = _write_recorder(project / "record.py")
+
+    result = _run_robotcode(
+        project,
+        ["--wrapper", f"{shlex.quote(sys.executable)} {shlex.quote(str(recorder))}", "-p", "x11", "run", "suite.robot"],
+        env={**os.environ, "ROBOTCODE_BUNDLED_ROBOTCODE_MAIN": str(broken)},
+    )
+    assert result.returncode == 0, result.stderr  # succeeded => the broken bundled entry was not used
+    recorded = _recorded_argv(recorder)
+    assert "-m robotcode.cli" in recorded  # used the direct module entry
+    assert str(broken) not in recorded
+
+
+@requires_posix_exec
+def test_wrapper_propagates_the_run_exit_code(project: Path) -> None:
+    """The wrapper must not swallow the run's exit code (contract rule #1)."""
+    (project / "fail.robot").write_text("*** Test Cases ***\nFails\n    Should Be Equal    1    2\n", encoding="utf-8")
+    result = _run_robotcode(project, ["-p", "x11", "run", "fail.robot"])
+    assert result.returncode != 0  # the failure propagated through the wrapper
+    assert _calls(project / "wrap.py") == ["xephyr"]  # and it did run through the wrapper
+
+
+# --- these paths return before any re-exec, so they run on every platform ----
+
+
+def test_wrapper_ignored_and_warns_on_non_wrappable_command(project: Path) -> None:
+    result = _run_robotcode(project, ["--wrapper", "xvfb-run", "discover", "all", "suite.robot"])
+    assert _calls(project / "wrap.py") == []  # discover never runs through the wrapper
+    assert "Ignoring --wrapper" in result.stderr
+
+
+def test_no_wrapper_overrides_wrapper_with_a_warning(project: Path) -> None:
+    result = _run_robotcode(project, ["-p", "x11", "--no-wrapper", "--wrapper", "xvfb-run", "run", "suite.robot"])
+    assert result.returncode == 0, result.stderr
+    assert _calls(project / "wrap.py") == []  # --no-wrapper wins, nothing is wrapped
+    assert "Ignoring --wrapper" in result.stderr

tests/robotcode/debugger/__init__.py

@@ -0,0 +1,35 @@
+"""Tests for the debug launcher building the `robotcode … debug` command line.
+
+Covers how a wrapper from the launch request (VS Code
+`robotcode.debug.launchWrapper`) is forwarded: the launcher does not apply it
+itself, it hands it to robotcode as `--wrapper` and lets robotcode apply it.
+"""
+
+import shlex
+
+from robotcode.debugger.launcher.server import _build_robotcode_run_args
+
+
+def test_forwards_wrapper_as_a_cli_option() -> None:
+    args = _build_robotcode_run_args("python", ["-m", "robotcode.cli"], ["ci"], None, ["xvfb-run", "-a"], None)
+
+    assert args[-1] == "debug"
+    assert "--wrapper" in args
+    i = args.index("--wrapper")
+    assert args[i + 1] == "xvfb-run -a"  # the list is shlex-joined into a single arg
+    assert i < args.index("debug")  # a group option, before the subcommand
+
+
+def test_no_wrapper_option_without_a_wrapper() -> None:
+    args = _build_robotcode_run_args("python", ["-m", "robotcode.cli"], ["ci"], None, None, None)
+
+    assert "--wrapper" not in args
+    assert args[-1] == "debug"
+
+
+def test_wrapper_round_trips_through_shlex() -> None:
+    # A path with spaces must survive the join → robotcode's shlex.split.
+    args = _build_robotcode_run_args("python", ["-m", "robotcode.cli"], None, None, ["./x 11.sh", "-a"], None)
+
+    joined = args[args.index("--wrapper") + 1]
+    assert shlex.split(joined) == ["./x 11.sh", "-a"]