Merge pull request #540 from duckietown:fix-error-loading-webview-and-security-issue-in-dts-code-editor-on-mac-devcontainer-DTSW-7328

Tuxliri · web-flow · commit 1fa1593e369c · 2025-11-06T14:22:16.000+11:00
Fix error loading lxs from devcontainer
diff --git a/devel/run/command.py b/devel/run/command.py
@@ -1,5 +1,6 @@
 import glob
 
+import argparse
 import json
 import os
 import shutil
@@ -17,6 +18,7 @@
     CANONICAL_ARCH
 )
 from dtproject.types import LayerContainers, ContainerConfiguration
+from utils.cli_utils import ensure_command_is_installed
 from utils.docker_utils import (
     DEFAULT_MACHINE,
     DOCKER_INFO,
@@ -34,17 +36,6 @@
 REMOTE_USER = "duckie"
 REMOTE_GROUP = "duckie"
 
-# Default ignore patterns for Mutagen sync
-MUTAGEN_DEFAULT_IGNORE = [
-    ".git/",
-    ".cache/",
-    "**/__pycache__/",
-    "build/",
-    "install/",
-    "log/",
-    ".vscode-server/",
-]
-
 
 class DTCommand(DTCommandAbs):
     help = "Runs the current project"
@@ -246,10 +237,10 @@ def command(shell, args: list, **kwargs):
                     local_srcs, destination_srcs = proj.code_paths(root)
                     # compile mountpoints
                     for local_src, destination_src in zip(local_srcs, destination_srcs):
-                        if parsed.read_only:
-                            cc_mountpoints.append((local_src, destination_src, "ro"))
-                        else:
+                        if parsed.read_write:
                             cc_mountpoints.append((local_src, destination_src, "rw"))
+                        else:
+                            cc_mountpoints.append((local_src, destination_src, "ro"))
 
                 # mount launchers
                 if not parsed.no_mount_launchers:
@@ -264,21 +255,15 @@ def command(shell, args: list, **kwargs):
                         if not os.path.isdir(local_launch):
                             continue
 
-                        # respect read-only setting for launcher mounts
-                        if parsed.read_only:
-                            cc_mountpoints.append((local_launch, destination_launch, "ro"))
-                        else:
-                            cc_mountpoints.append((local_launch, destination_launch, "rw"))
+                        cc_mountpoints.append((local_launch, destination_launch, "rw"))
                         # make sure the launchers are executable (local only)
                         if local:
                             # noinspection PyBroadException
                             try:
                                 _run_cmd(["chmod", "a+x", os.path.join(local_launch, "*")], shell=True)
                             except Exception:
-                                dtslogger.warning(
-                                    "An error occurred while making the launchers executable. "
-                                    "Things might not work as expected."
-                                )
+                                dtslogger.warning("An error occurred while making the launchers executable. "
+                                                  "Things might not work as expected.")
 
                 # mount libraries explicitly to support symlinks (local only)
                 if not parsed.no_mount_libraries and local:
@@ -294,10 +279,7 @@ def command(shell, args: list, **kwargs):
                                 os.makedirs(local_mountpoint, exist_ok=True)
                                 real_local_lib = os.path.realpath(local_lib)
                                 destination_lib: str = os.path.join(destination_src, "libraries", f"__{lib_name}")
-                                if parsed.read_only:
-                                    cc_mountpoints.append((real_local_lib, destination_lib, "ro"))
-                                else:
-                                    cc_mountpoints.append((real_local_lib, destination_lib, "rw"))
+                                cc_mountpoints.append((real_local_lib, destination_lib, "rw"))
 
         # create image name
         cc_image = project.image(
@@ -430,27 +412,28 @@ def command(shell, args: list, **kwargs):
 
         # sync
         if parsed.sync:
-            # route to `devel.sync` for managing Mutagen sessions
+            # TODO: this can just become a call to devel.sync
+            # only allowed when mounting remotely
             if parsed.machine == DEFAULT_MACHINE:
                 dtslogger.error("The option -s/--sync can only be used together with -H/--machine")
                 exit(2)
-            sync_args: List[str] = [
-                "-H", parsed.machine,
-                "-C", parsed.workdir,
-            ]
-            # propagate mounts
-            if parsed.mount is True:
-                sync_args += ["-M"]
-            elif isinstance(parsed.mount, str):
-                sync_args += ["-M", parsed.mount]
-            # propagate include-git for Mutagen
-            if getattr(parsed, "sync_include_git", False):
-                sync_args += ["--include-git"]
-            # propagate optional flush direction
-            if getattr(parsed, "sync_flush_direction", None):
-                sync_args += ["--flush-direction", parsed.sync_flush_direction]
-            # call devel.sync
-            shell.include.devel.sync.command(shell, sync_args)
+            # make sure rsync is installed
+            ensure_command_is_installed("rsync", dependant="dts devel run")
+            dtslogger.info(f"Syncing code with {parsed.machine.replace('.local', '')}...")
+            remote_path = f"{parsed.sync_user}@{parsed.machine}:{parsed.sync_destination.rstrip('/')}/"
+            # get projects' locations
+            projects_to_sync = [parsed.workdir] if parsed.mount is True else []
+            # sync secondary projects
+            if isinstance(parsed.mount, str):
+                projects_to_sync.extend(
+                    [os.path.abspath(os.path.join(os.getcwd(), p.strip())) for p in parsed.mount.split(",")]
+                )
+            # run rsync
+            for project_path in projects_to_sync:
+                cmd = (f"rsync --archive --delete --copy-links --chown={REMOTE_USER}:{REMOTE_GROUP} "
+                       f"\"{project_path}\" \"{remote_path}\"")
+                _run_cmd(cmd, shell=True)
+            dtslogger.info(f"Code synced!")
 
         # run
         if parsed.configuration is None:
diff --git a/devel/run/configuration.py b/devel/run/configuration.py
@@ -179,19 +179,6 @@ def parser(cls, *args, **kwargs) -> Optional[argparse.ArgumentParser]:
             default=DEFAULT_REMOTE_SYNC_LOCATION,
             help="Location of the synced code on the remote server"
         )
-        parser.add_argument(
-            "--sync-flush-direction",
-            default=None,
-            choices=("alpha-to-beta", "beta-to-alpha"),
-            help="After ensuring Mutagen sessions, perform a one-shot flush in this direction",
-        )
-        parser.add_argument(
-            "--sync-include-git",
-            dest="sync_include_git",
-            default=False,
-            action="store_true",
-            help="Include the .git directory in remote sync",
-        )
         parser.add_argument(
             "--net",
             "--network_mode",
@@ -213,20 +200,11 @@ def parser(cls, *args, **kwargs) -> Optional[argparse.ArgumentParser]:
             default=None,
             help="Overrides 'version' (usually taken to be branch name)"
         )
-        # Mount mode: read-only available, but default remains read-write
         parser.add_argument(
-            "-RO",
-            "--read-only",
-            dest="read_only",
+            "-RW",
+            "--read_write",
             default=False,
             action="store_true",
-            help="Mount the project in read-only mode",
-        )
-        parser.add_argument(
-            "--read-write",
-            "--rw",
-            dest="read_only",
-            action="store_false",
             help="Mount the project in read-write mode",
         )
         parser.add_argument("docker_args", nargs="*", default=[])
diff --git a/devel/sync/command.py b/devel/sync/command.py
@@ -1,30 +1,15 @@
 import argparse
 import os
 import subprocess
-from typing import List, Optional
 
 from dt_shell import DTCommandAbs, dtslogger
 from utils.cli_utils import ensure_command_is_installed
 from utils.docker_utils import DEFAULT_MACHINE
 from utils.misc_utils import sanitize_hostname
 from utils.multi_command_utils import MultiCommand
-from utils.mutagen_sync import MutagenSync, MutagenError, ensure_min_version, sanitize_session_name
-from utils.ssh_setup import ensure_ssh_for_host
-from devel.run.command import REMOTE_USER as DEFAULT_REMOTE_USER
 
-# Default host path on the robot to mirror code into (bind-mount this in containers)
-REMOTE_SYNC_CODE_LOCATION = "/code"
-
-# Default ignore patterns for sync (by default .git is ignored; can be included via --include-git)
-DEFAULT_IGNORE: List[str] = [
-    ".git/",
-    ".cache/",
-    "**/__pycache__/",
-    "build/",
-    "install/",
-    "log/",
-    ".vscode-server/",
-]
+DEFAULT_REMOTE_USER = "duckie"
+REMOTE_RSYNC_CODE_LOCATION = "/tmp/code"
 
 
 class DTCommand(DTCommandAbs):
@@ -53,97 +38,25 @@ def command(shell, args: list, **kwargs):
         # ---
         # sync
         if parsed.machine == DEFAULT_MACHINE:
-            # only allowed when targeting a remote machine
-            dtslogger.error("This command requires -H/--machine to specify the remote host")
+            # only allowed when mounting remotely
+            dtslogger.error("The option -s/--sync can only be used together with -H/--machine")
             exit(2)
-        # Ensure SSH key-based auth is configured for the target
-        robot_name: Optional[str] = None
-        # If the given machine is like NAME.local, derive NAME
-        try:
-            if parsed.machine.endswith('.local'):
-                robot_name = parsed.machine.split('.', 1)[0]
-            elif '.' not in parsed.machine:
-                # likely MagicDNS short name
-                robot_name = parsed.machine
-        except Exception:
-            pass
-        try:
-            ensure_ssh_for_host(parsed.machine, user=DEFAULT_REMOTE_USER, robot_name=robot_name)
-        except Exception as e:
-            # Non-fatal: we proceed; SSH may still prompt if needed
-            dtslogger.warning(f"SSH setup encountered an issue: {e}")
-        # make sure Mutagen is installed
-        ensure_command_is_installed(
-            "mutagen",
-            dependant="dts devel run",
-            custom_msg=(
-                "Please install it with:\n"
-                "    curl -sS https://webi.sh/mutagen | sh\n"
-                "    source ~/.config/envman/PATH.env\n"
-                "and try again."
-            ),
-        )
-        # pre-flight version check
-        try:
-            ensure_min_version("0.17.0")
-        except MutagenError as e:
-            # Older Mutagen versions work with plain-text parsing; continue with a warning
-            dtslogger.warning(str(e))
-        dtslogger.info(f"Ensuring Mutagen sync to {parsed.machine.replace('.local', '')}...")
+        # make sure rsync is installed
+        ensure_command_is_installed("rsync")
+        dtslogger.info(f"Syncing code with {parsed.machine.replace('.local', '')}...")
+        remote_path = f"{DEFAULT_REMOTE_USER}@{parsed.machine}:{REMOTE_RSYNC_CODE_LOCATION}/"
         # get projects' locations
         projects_to_sync = [parsed.workdir] if parsed.mount is True else []
         # sync secondary projects
         if isinstance(parsed.mount, str):
             projects_to_sync.extend(
                 [os.path.abspath(os.path.join(os.getcwd(), p.strip())) for p in parsed.mount.split(",")]
             )
-        # create or reuse sessions
-        sessions = []
+        # run rsync
         for project_path in projects_to_sync:
-            project_path = os.path.abspath(project_path)
-            project_name = os.path.basename(project_path.rstrip("/"))
-            session_name = sanitize_session_name(f"dts-sync-{project_name}-{parsed.machine}")
-            # ensure remote directory exists
-            remote_host_dir = os.path.join(REMOTE_SYNC_CODE_LOCATION, project_name)
-            _run_cmd([
-                "ssh",
-                f"{DEFAULT_REMOTE_USER}@{parsed.machine}",
-                f"mkdir -p '{remote_host_dir}'"
-            ])
-            # build Mutagen endpoints
-            alpha = project_path
-            beta = f"ssh://{DEFAULT_REMOTE_USER}@{parsed.machine}//{remote_host_dir.lstrip('/')}"
-            try:
-                sync = MutagenSync(name=session_name)
-                # Determine ignore paths (optionally include .git)
-                ignore_paths = list(DEFAULT_IGNORE)
-                if getattr(parsed, "include_git", False):
-                    ignore_paths = [p for p in ignore_paths if p != ".git/"]
-                session = sync.ensure_session(
-                    alpha=alpha,
-                    beta=beta,
-                    ignore_paths=ignore_paths,
-                    max_staging_file_size="64MiB",
-                )
-                dtslogger.info(f"Session ready: {session.name} ({session.identifier})")
-                sessions.append((sync, session))
-            except MutagenError as e:
-                dtslogger.error(str(e))
-                exit(2)
-        # optional flush
-        if parsed.flush_direction:
-            for sync, _ in sessions:
-                try:
-                    sync.flush(parsed.flush_direction)
-                except MutagenError as e:
-                    dtslogger.warning(f"Flush failed for {sync.name}: {e}")
-            dtslogger.info(f"One-shot flush requested: {parsed.flush_direction}")
-        # optional monitor (monitor the first session)
-        if parsed.monitor and sessions:
-            dtslogger.info("Monitoring Mutagen session. Press Ctrl-C to stop...")
-            sessions[0][0].monitor()
-        else:
-            dtslogger.info("Mutagen sync configured. Use 'mutagen sync monitor' to watch events.")
+            cmd = f"rsync --archive {project_path} {remote_path}"
+            _run_cmd(cmd, shell=True)
+        dtslogger.info(f"Code synced!")
 
     @staticmethod
     def complete(shell, word, line):
diff --git a/devel/sync/configuration.py b/devel/sync/configuration.py
@@ -36,24 +36,5 @@ def parser(cls, *args, **kwargs) -> Optional[argparse.ArgumentParser]:
             help="Whether to mount the current project into the container. "
                  "Pass a comma-separated list of paths to mount multiple projects",
         )
-        parser.add_argument(
-            "--monitor",
-            default=False,
-            action="store_true",
-            help="After ensuring sessions, monitor sync activity (Ctrl-C to stop)",
-        )
-        parser.add_argument(
-            "--flush-direction",
-            default=None,
-            choices=("alpha-to-beta", "beta-to-alpha"),
-            help="After ensuring sessions, perform a one-shot flush in this direction",
-        )
-        parser.add_argument(
-            "--include-git",
-            dest="include_git",
-            default=False,
-            action="store_true",
-            help="Include the .git directory in the sync",
-        )
         # ---
         return parser
diff --git a/setup/mkcert/command.py b/setup/mkcert/command.py
@@ -19,6 +19,7 @@
 
 MKCERT_VERSION = "1.4.4"
 LOCAL_DOMAIN = "localhost"
+LOCAL_IP = "127.0.0.1"
 
 
 class DTCommand(DTCommandAbs):
@@ -146,9 +147,9 @@ def command(shell: DTShell, args):
 
         # - make domain certificate
         if not ssl_exists:
-            dtslogger.info(f"Creating local certificate for the domain '{LOCAL_DOMAIN}'...")
+            dtslogger.info(f"Creating local certificate for the domain '{LOCAL_DOMAIN}' and {LOCAL_IP} ...")
             cmd: List[str] = DTCommand._mkcert_command(
-                "-cert-file", ssl_cert, "-key-file", ssl_key, LOCAL_DOMAIN
+                "-cert-file", ssl_cert, "-key-file", ssl_key, LOCAL_DOMAIN, LOCAL_IP
             )
             dtslogger.debug(f"Running command:\n\t$ {cmd}\n\tenv: {cmd_env}\n")
             out = subprocess.check_output(cmd, env=env, stderr=STDOUT).decode("utf-8")
@@ -159,7 +160,7 @@ def command(shell: DTShell, args):
             assert exists(ssl_cert)
             assert exists(ssl_key)
             # ---
-            dtslogger.info(f"A new certificate for the domain '{LOCAL_DOMAIN}' was created.")
+            dtslogger.info(f"A new certificate for the domains '{LOCAL_DOMAIN}' and '{LOCAL_IP}' was created.")
         else:
             dtslogger.info(f"Existing domain certificate found in [{ssl_dir}]")
             
diff --git a/utils/cli_utils.py b/utils/cli_utils.py
@@ -76,7 +76,7 @@ def ask_confirmation(message, default="n", question="Do you confirm?", choices=N
                 return r
 
 
-def ensure_command_is_installed(command, dependant: Optional[str] = None, custom_msg = None):
+def ensure_command_is_installed(command, dependant: Optional[str] = None):
     command_path: Optional[str] = which(command)
     if command_path is None:
         extra: str = ""
@@ -87,8 +87,6 @@ def ensure_command_is_installed(command, dependant: Optional[str] = None, custom
         The command '{command}' is required{extra}. Please, install it before continuing.
 
         """
-        if msg:
-            msg += "\n" + custom_msg + "\n"
         raise UserError(msg)
     else:
         dtslogger.debug(f"Command '{command}' found: {command_path}")
diff --git a/utils/mutagen_sync.py b/utils/mutagen_sync.py
diff --git a/utils/ssh_setup.py b/utils/ssh_setup.py
