hector-cli 0.5.0__tar.gz → 0.7.0__tar.gz

{hector_cli-0.5.0 → hector_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hector-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: YAML-driven Renode + Verilator simulation orchestrator for embedded hardware CI
 Home-page: https://hector-ci.com
 Author: Nemesis
@@ -206,10 +206,11 @@ the CLI natively with `pip` and let hector launch real per-step containers.
 | `hector run --gather-execution-metrics boardA --gather-execution-metrics boardB` | Enable profiler for selected machines |
 | `hector run --renode-version 1.16.1` | Override the Renode version from `.hector.yaml` |
 | `hector run --renode-image my-renode:dev` | Use a specific (e.g. self-built) Renode Docker image |
+| `hector run --docker-args '-v /opt/tools:/opt/tools'` | Add extra flags (mounts, env, …) to every `docker run` |
 | `hector run --renode-dir /cache/renode` | Use/cache the Renode source checkout at this path (only fetched when needed) |
 | `hector run --renode-integration-dir /cache/integration` | Likewise for the verilator-integration checkout |
 | `hector run --no-docker` | Use locally installed `renode` / `renode-test` instead of Docker |
-| `hector run --workspace-mount /mnt` | Override the container path the project root is mounted at |
+| `hector run --workspace-mount /mnt` | Mount the hectorfile's folder at this container path and execute there |
 | `hector run --snapshot path/to/snapshot.save` | Load a snapshot instead of booting from the resc |
 | `hector run --snapshot snap.save --renode-version 1.16.1` | Load a snapshot without a `.hector.yaml` |
 | `hector test` | Run the `tests:` section; exit 1 on any failure |
@@ -482,6 +483,32 @@ hector run --renode-args '--console'
 hector run --renode-args '--hide-log --config my.conf'
 ```
 
+#### Paths and working directory
+
+Everything a hectorfile executes — `build:` steps, `shell` tests, Renode and `renode-test` — runs **in the hectorfile's folder**, and paths written in the file (`firmware:`, `platform:`, module `source:`, test `file:` / `snapshot:`, `file:` mappings, `artifacts:`, paths inside scripts and `commands:`) are **relative to that folder**. So `hector test -f boards/nucleo/.hector.yaml` behaves the same as running `hector test` inside `boards/nucleo/`.
+
+The directory you run hector from is mounted into the container (at the same path), and the container's working directory (`-w`) is the hectorfile's folder. If the hectorfile lives **outside** the directory you run from (`hector test -f ../other/.hector.yaml`), its folder is mounted as well, at its own path. (With [`--workspace-mount`](#overriding-the-workspace-mount-path---workspace-mount) the hectorfile's folder is mounted at the given path instead.) A path like `../shared/board.repl` works as long as it lands inside one of those mounts — for anything else, add a mount with [`docker_args`](#extra-docker-flags---docker-args). Under `--no-docker` the processes simply run with the hectorfile's folder as their cwd.
+
+Paths given on the **command line** (`--output`, `--snapshot`, `--test-file`, `--artifacts`, `--renode-dir`, …) stay relative to where you run hector, and `.hector/` is still created there.
+
+#### Extra Docker flags (`--docker-args`)
+
+Add your own flags to every `docker run` hector starts — Renode, robot tests, `shell` tests, `build:` steps and module builds — e.g. to mount more directories or set environment variables. Declare them in `.hector.yaml` as a string or a list:
+
+```yaml
+docker_args:
+  - -v /opt/toolchains:/opt/toolchains:ro
+  - -e LICENSE_SERVER=10.0.0.5
+```
+
+or pass them on the command line, where they are **appended** to the config's:
+
+```bash
+hector test --docker-args '-v /data/firmware:/data/firmware'
+```
+
+Use absolute host paths for `-v` (Docker treats a bare name as a named volume). Ignored under `--no-docker`.
+
 #### Container networking
 
 Every container hector starts — the Renode emulation (`run`), robot tests, `shell` tests, `build:` steps and module builds — runs with `--net=host`. GDB servers (`--debug`), `tcp:` mappings and anything a step listens on are reachable from the host on the same port, and steps can reach host services on `localhost`. No port publishing is involved.
@@ -545,12 +572,15 @@ An existing directory is reused as-is; a missing one is cloned into. The locatio
 
 #### Overriding the workspace mount path (`--workspace-mount`)
 
-By default the project root is bind-mounted into the container at the **same absolute path** as on the host (e.g. `/home/user/projects/myboard`), so paths look identical inside and outside the container. Override this only if the host path is unavailable at that location inside the image:
+By default everything is bind-mounted into the container at the **same absolute path** as on the host (e.g. `/home/user/projects/myboard`), so paths look identical inside and outside the container. `--workspace-mount PATH` instead mounts the **hectorfile's folder** at `PATH`, and that's where every step, Renode and `renode-test` execute:
 
 ```bash
-hector run --workspace-mount /workspace
+hector run --workspace-mount /workspace                              # . → /workspace
+hector test -f boards/nucleo/.hector.yaml --workspace-mount /workspace  # boards/nucleo → /workspace
 ```
 
+When you run from a different folder than the hectorfile's (the second line), that folder — where `.hector/` and `--output` live — is additionally mounted at its own path, unless it's already inside the hectorfile's folder.
+
 **Cannot be combined with `--no-docker`** — if you are running locally there is no container mount to configure.
 
 ### Selecting a matrix combination (`--job`)
@@ -625,6 +655,7 @@ The configuration lives in `.hector.yaml`.
 | `version` | No | Schema version (currently `"0.1"`). Warns if unrecognised. |
 | `renode_version` | Yes¹ | Renode version, no leading `v` (e.g. `1.16.1`). Selects both the git tag for cloning and the Docker image tag. |
 | `renode_image` | Yes¹ | Full Renode Docker image to use instead of `antmicro/renode:<renode_version>` (e.g. a self-built `my-renode:dev`). See [custom Renode image](#using-a-custom-renode-image---renode-image). |
+| `docker_args` | No | Extra `docker run` flags (string or list) for every container, e.g. more `-v` mounts. See [extra Docker flags](#extra-docker-flags---docker-args). |
 | `arguments` | No | Scalar defaults, overridable by env var or `--set`. |
 | `build` | No | Pre-sim shell steps run once per job in containers (compile firmware, fetch/generate files, …). Interpolated with the job's arguments/matrix variables. |
 | `matrix` | No | Cross-product job expansion. |

{hector_cli-0.5.0 → hector_cli-0.7.0}/README.md

@@ -176,10 +176,11 @@ the CLI natively with `pip` and let hector launch real per-step containers.
 | `hector run --gather-execution-metrics boardA --gather-execution-metrics boardB` | Enable profiler for selected machines |
 | `hector run --renode-version 1.16.1` | Override the Renode version from `.hector.yaml` |
 | `hector run --renode-image my-renode:dev` | Use a specific (e.g. self-built) Renode Docker image |
+| `hector run --docker-args '-v /opt/tools:/opt/tools'` | Add extra flags (mounts, env, …) to every `docker run` |
 | `hector run --renode-dir /cache/renode` | Use/cache the Renode source checkout at this path (only fetched when needed) |
 | `hector run --renode-integration-dir /cache/integration` | Likewise for the verilator-integration checkout |
 | `hector run --no-docker` | Use locally installed `renode` / `renode-test` instead of Docker |
-| `hector run --workspace-mount /mnt` | Override the container path the project root is mounted at |
+| `hector run --workspace-mount /mnt` | Mount the hectorfile's folder at this container path and execute there |
 | `hector run --snapshot path/to/snapshot.save` | Load a snapshot instead of booting from the resc |
 | `hector run --snapshot snap.save --renode-version 1.16.1` | Load a snapshot without a `.hector.yaml` |
 | `hector test` | Run the `tests:` section; exit 1 on any failure |
@@ -452,6 +453,32 @@ hector run --renode-args '--console'
 hector run --renode-args '--hide-log --config my.conf'
 ```
 
+#### Paths and working directory
+
+Everything a hectorfile executes — `build:` steps, `shell` tests, Renode and `renode-test` — runs **in the hectorfile's folder**, and paths written in the file (`firmware:`, `platform:`, module `source:`, test `file:` / `snapshot:`, `file:` mappings, `artifacts:`, paths inside scripts and `commands:`) are **relative to that folder**. So `hector test -f boards/nucleo/.hector.yaml` behaves the same as running `hector test` inside `boards/nucleo/`.
+
+The directory you run hector from is mounted into the container (at the same path), and the container's working directory (`-w`) is the hectorfile's folder. If the hectorfile lives **outside** the directory you run from (`hector test -f ../other/.hector.yaml`), its folder is mounted as well, at its own path. (With [`--workspace-mount`](#overriding-the-workspace-mount-path---workspace-mount) the hectorfile's folder is mounted at the given path instead.) A path like `../shared/board.repl` works as long as it lands inside one of those mounts — for anything else, add a mount with [`docker_args`](#extra-docker-flags---docker-args). Under `--no-docker` the processes simply run with the hectorfile's folder as their cwd.
+
+Paths given on the **command line** (`--output`, `--snapshot`, `--test-file`, `--artifacts`, `--renode-dir`, …) stay relative to where you run hector, and `.hector/` is still created there.
+
+#### Extra Docker flags (`--docker-args`)
+
+Add your own flags to every `docker run` hector starts — Renode, robot tests, `shell` tests, `build:` steps and module builds — e.g. to mount more directories or set environment variables. Declare them in `.hector.yaml` as a string or a list:
+
+```yaml
+docker_args:
+  - -v /opt/toolchains:/opt/toolchains:ro
+  - -e LICENSE_SERVER=10.0.0.5
+```
+
+or pass them on the command line, where they are **appended** to the config's:
+
+```bash
+hector test --docker-args '-v /data/firmware:/data/firmware'
+```
+
+Use absolute host paths for `-v` (Docker treats a bare name as a named volume). Ignored under `--no-docker`.
+
 #### Container networking
 
 Every container hector starts — the Renode emulation (`run`), robot tests, `shell` tests, `build:` steps and module builds — runs with `--net=host`. GDB servers (`--debug`), `tcp:` mappings and anything a step listens on are reachable from the host on the same port, and steps can reach host services on `localhost`. No port publishing is involved.
@@ -515,12 +542,15 @@ An existing directory is reused as-is; a missing one is cloned into. The locatio
 
 #### Overriding the workspace mount path (`--workspace-mount`)
 
-By default the project root is bind-mounted into the container at the **same absolute path** as on the host (e.g. `/home/user/projects/myboard`), so paths look identical inside and outside the container. Override this only if the host path is unavailable at that location inside the image:
+By default everything is bind-mounted into the container at the **same absolute path** as on the host (e.g. `/home/user/projects/myboard`), so paths look identical inside and outside the container. `--workspace-mount PATH` instead mounts the **hectorfile's folder** at `PATH`, and that's where every step, Renode and `renode-test` execute:
 
 ```bash
-hector run --workspace-mount /workspace
+hector run --workspace-mount /workspace                              # . → /workspace
+hector test -f boards/nucleo/.hector.yaml --workspace-mount /workspace  # boards/nucleo → /workspace
 ```
 
+When you run from a different folder than the hectorfile's (the second line), that folder — where `.hector/` and `--output` live — is additionally mounted at its own path, unless it's already inside the hectorfile's folder.
+
 **Cannot be combined with `--no-docker`** — if you are running locally there is no container mount to configure.
 
 ### Selecting a matrix combination (`--job`)
@@ -595,6 +625,7 @@ The configuration lives in `.hector.yaml`.
 | `version` | No | Schema version (currently `"0.1"`). Warns if unrecognised. |
 | `renode_version` | Yes¹ | Renode version, no leading `v` (e.g. `1.16.1`). Selects both the git tag for cloning and the Docker image tag. |
 | `renode_image` | Yes¹ | Full Renode Docker image to use instead of `antmicro/renode:<renode_version>` (e.g. a self-built `my-renode:dev`). See [custom Renode image](#using-a-custom-renode-image---renode-image). |
+| `docker_args` | No | Extra `docker run` flags (string or list) for every container, e.g. more `-v` mounts. See [extra Docker flags](#extra-docker-flags---docker-args). |
 | `arguments` | No | Scalar defaults, overridable by env var or `--set`. |
 | `build` | No | Pre-sim shell steps run once per job in containers (compile firmware, fetch/generate files, …). Interpolated with the job's arguments/matrix variables. |
 | `matrix` | No | Cross-product job expansion. |

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/commands/base.py

@@ -59,6 +59,12 @@ def add_common_arguments(parser):
              "image, e.g. a self-built one: my-renode:dev). Overrides renode_image / "
              "renode_version from .hector.yaml.",
     )
+    parser.add_argument(
+        "--docker-args", metavar="ARGS", dest="docker_args", default="",
+        help="Extra flags added to every `docker run` hector starts, e.g. more mounts "
+             "(--docker-args '-v /opt/tools:/opt/tools -e FOO=1'). Appended to "
+             "docker_args from .hector.yaml.",
+    )
     parser.add_argument(
         "--renode-dir", metavar="PATH", dest="renode_dir", default=None,
         help="Location of the Renode source checkout (only fetched when a config builds "
@@ -104,8 +110,8 @@ def add_common_arguments(parser):
     )
     docker_mode.add_argument(
         "--workspace-mount", metavar="PATH", dest="workspace_mount", default=None,
-        help="Container path where the project root is bind-mounted "
-             "(default: same absolute path as on the host).",
+        help="Mount the hectorfile's folder at this container path and execute there "
+             "(default: everything is mounted at its own host path).",
     )
 
 

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/core.py

@@ -67,7 +67,7 @@ class Registry:
 # ==========================================================================
 # CONSTANTS
 # ==========================================================================
-TOOL_VERSION = "0.5.0"
+TOOL_VERSION = "0.7.0"
 SUPPORTED_SCHEMA_VERSIONS = {"0.1"}
 
 RENODE_REPO_URL = "https://github.com/renode/renode.git"
@@ -78,8 +78,16 @@ ARTIFACTS_DIR = ".hector"          # everything we generate/clone lives here (gi
 # hosts we mirror the host cwd, so paths look identical in and out; on Windows the host
 # path (C:\...) is not a valid Linux path, so use a fixed POSIX mount point and translate.
 WORKSPACE_MOUNT = "/workspace" if os.name == "nt" else os.getcwd()
-NO_DOCKER = False                  # when True, call renode/renode-test directly on host
+# Host directory bind-mounted at WORKSPACE_MOUNT. None = the cwd; --workspace-mount
+# sets it to the config's directory, so the mount point is where execution happens.
+WORKSPACE_ROOT = None
+NO_DOCKER = False                 # when True, call renode/renode-test directly on host
 EXTRA_MOUNTS = []                  # dep dirs outside the workspace, bind-mounted 1:1 into every container
+DOCKER_ARGS = []                   # user flags (docker_args: + --docker-args) added to every `docker run`
+# Host directory of the config file being executed. Paths written in the config resolve
+# against it, and scripts / Renode run with it as their working directory. None = cwd
+# (no config loaded, e.g. `run --snapshot` without one).
+CONFIG_DIR = None
 LIBOPENLIBM_NAME = "libopenlibm-Linux-x86_64.a"
 
 DEFAULT_QUANTUM = "0.00001"        # 10 us; applied when any hub is present
@@ -119,10 +127,20 @@ def host_uid_gid():
     return None
 
 
+def workspace_root():
+    """Host directory mounted at WORKSPACE_MOUNT (see WORKSPACE_ROOT)."""
+    return os.path.realpath(WORKSPACE_ROOT or os.getcwd())
+
+
 def to_container_path(host_path):
     abs_path = os.path.realpath(host_path)
-    root = os.path.realpath(os.getcwd())
+    root = workspace_root()
     if os.path.commonpath([abs_path, root]) != root:
+        # Dirs outside the workspace registered in EXTRA_MOUNTS (the config's dir or the
+        # cwd, a shared Renode cache) are mounted 1:1, so their paths are valid as-is.
+        for m in EXTRA_MOUNTS:
+            if os.path.commonpath([abs_path, m]) == m:
+                return abs_path
         raise ValueError(
             f"Path '{host_path}' resolves outside the project root '{root}'. Everything used "
             f"at runtime must live under the project folder (mounted at '{WORKSPACE_MOUNT}')."
@@ -130,7 +148,7 @@ def to_container_path(host_path):
     # The container is always Linux: build a POSIX path under WORKSPACE_MOUNT (this is a
     # no-op on Linux, where WORKSPACE_MOUNT is the cwd and os.sep is already '/').
     rel = os.path.relpath(abs_path, root).replace(os.sep, "/")
-    return posixpath.join(WORKSPACE_MOUNT, rel)
+    return WORKSPACE_MOUNT if rel == "." else posixpath.join(WORKSPACE_MOUNT, rel)
 
 
 def register_dependency_mount(host_dir):
@@ -140,13 +158,12 @@ def register_dependency_mount(host_dir):
     Dirs under the workspace are already covered by the workspace mount, so they map via
     to_container_path. An out-of-tree dir (e.g. a shared cache) is registered in
     EXTRA_MOUNTS and used at its own absolute path inside the container."""
-    abs_dir = os.path.realpath(host_dir)
-    root = os.path.realpath(os.getcwd())
-    if os.path.commonpath([abs_dir, root]) == root:
-        return to_container_path(host_dir)
-    if abs_dir not in EXTRA_MOUNTS:
+    try:
+        return to_container_path(host_dir)    # already reachable through some mount
+    except ValueError:
+        abs_dir = os.path.realpath(host_dir)
         EXTRA_MOUNTS.append(abs_dir)
-    return abs_dir
+        return abs_dir
 
 
 def container_path_for(host_path):
@@ -166,13 +183,34 @@ def container_to_host(container_path):
     if container_path != WORKSPACE_MOUNT and not container_path.startswith(WORKSPACE_MOUNT + "/"):
         raise ValueError(f"'{container_path}' is not under {WORKSPACE_MOUNT}.")
     rel = posixpath.relpath(container_path, WORKSPACE_MOUNT).replace("/", os.sep)
-    host = os.path.realpath(os.path.join(os.getcwd(), rel))
-    root = os.path.realpath(os.getcwd())
+    root = workspace_root()
+    host = os.path.realpath(os.path.join(root, rel))
     if os.path.commonpath([host, root]) != root:
         raise ValueError(f"'{container_path}' maps outside the project root.")
     return host
 
 
+def config_dir():
+    """Host directory config-relative paths resolve against (see CONFIG_DIR)."""
+    return CONFIG_DIR or os.getcwd()
+
+
+def from_config(path):
+    """Resolve a path written in the config against the config file's directory.
+    Absolute paths (host or container, e.g. an interpolated ${RENODE_DIR}) and URLs
+    are returned unchanged."""
+    if not path or os.path.isabs(path) or path.startswith("/") or "://" in path:
+        return path
+    return os.path.normpath(os.path.join(config_dir(), path))
+
+
+def execution_dir():
+    """Working directory for everything hector executes (build/shell steps, Renode,
+    renode-test): the config's directory — as a container path under Docker, a host
+    path under --no-docker."""
+    return config_dir() if NO_DOCKER else to_container_path(config_dir())
+
+
 def split_host_container(path):
     if path == WORKSPACE_MOUNT or path.startswith(WORKSPACE_MOUNT + "/"):
         return container_to_host(path), path

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/docker.py

@@ -48,16 +48,17 @@ def _user_flags():
 
 
 def _workspace_mount():
-    return ["-v", f"{os.getcwd()}:{core.WORKSPACE_MOUNT}", "-w", core.WORKSPACE_MOUNT]
+    return ["-v", f"{core.workspace_root()}:{core.WORKSPACE_MOUNT}", "-w", core.execution_dir()]
 
 
 def _extra_mounts():
-    """Bind-mount out-of-tree dependency dirs (e.g. a shared Renode source cache) 1:1, so
-    containers reach them at the same path they have on the host. Empty for the common case."""
+    """Bind-mount out-of-tree dirs (the config's dir, a shared Renode source cache) 1:1,
+    so containers reach them at the same path they have on the host, then append the
+    user's own `docker run` flags (extra -v mounts, --env, ...). Empty for the common case."""
     args = []
     for d in core.EXTRA_MOUNTS:
         args += ["-v", f"{d}:{d}"]
-    return args
+    return args + core.DOCKER_ARGS
 
 
 # Every container shares the host's network stack: GDB servers, tcp: mappings and
@@ -93,7 +94,7 @@ def _runtime_flags(runtime):
 def run_build(script, image):
     """Run a build script in the container as root (for apt-get + cmake)."""
     if core.NO_DOCKER:
-        subprocess.run(["bash", "-c", script], check=True)
+        subprocess.run(["bash", "-c", script], check=True, cwd=core.execution_dir())
         return
     subprocess.run(
         ["docker", "run", "--rm", *_HOST_NETWORK, "-u", "0:0",
@@ -131,14 +132,17 @@ def run_in_container(script, image, live=False):
     fail on the first error.
 
     Backs the `shell` test type and the `build:` steps. Normally a one-off container of
-    `image`; under --no-docker the script runs directly on the host (the image is moot)."""
+    `image`; under --no-docker the script runs directly on the host (the image is moot).
+    Either way it runs in the config's directory (core.execution_dir)."""
+    cwd = None
     if core.NO_DOCKER:
         cmd = ["bash", "-c", f"set -ex\n{script}"]
+        cwd = core.execution_dir()
     else:
         cmd = ["docker", "run", "--rm", *_HOST_NETWORK, *_workspace_mount(),
                *_extra_mounts(), *_user_flags(), image, "sh", "-c", f"set -ex\n{script}"]
     if live:
-        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, cwd=cwd,
                                 stderr=subprocess.STDOUT, text=True)
         lines = []
         for line in proc.stdout:
@@ -146,7 +150,8 @@ def run_in_container(script, image, live=False):
             lines.append(line)
         proc.wait()
         return "".join(lines), proc.returncode == 0
-    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+                          cwd=cwd)
     if proc.stdout:
         print(proc.stdout, end="")
     return proc.stdout, proc.returncode == 0
@@ -158,12 +163,13 @@ def build_renode_argv(resc_filename, image, extra_args=None, runtime=None):
 
     Returning the command (instead of running it) is what lets the `export` command
     print it verbatim and keeps run_renode a one-liner around this builder.
-    runtime: aggregated RuntimeOptions whose docker flags (caps/devices/root) are added."""
+    runtime: aggregated RuntimeOptions whose docker flags (caps/devices/root) are added.
+    The resc path is made absolute: Renode runs in the config's directory, not the cwd."""
     if core.NO_DOCKER:
-        return ["renode", resc_filename] + (extra_args or [])
+        return ["renode", os.path.abspath(resc_filename)] + (extra_args or [])
     return ["docker", "run", "-it", "--rm", *_xdisplay_args(), *_HOST_NETWORK,
             *_workspace_mount(), *_extra_mounts(), *_user_flags(), *_runtime_flags(runtime),
-            image, "renode", resc_filename] + (extra_args or [])
+            image, "renode", to_container_path(resc_filename)] + (extra_args or [])
 
 
 def run_renode(resc_filename, image, extra_args=None, output_dir="results", runtime=None):
@@ -172,7 +178,8 @@ def run_renode(resc_filename, image, extra_args=None, output_dir="results", runt
     runtime: aggregated RuntimeOptions whose docker flags (caps/devices/root) are added."""
     if not core.NO_DOCKER:
         os.makedirs(os.path.join(os.getcwd(), output_dir), exist_ok=True)
-    subprocess.run(build_renode_argv(resc_filename, image, extra_args, runtime))
+    subprocess.run(build_renode_argv(resc_filename, image, extra_args, runtime),
+                   cwd=core.execution_dir() if core.NO_DOCKER else None)
 
 
 def run_renode_test(robot_file_host, image, results_dir_host,
@@ -186,12 +193,14 @@ def run_renode_test(robot_file_host, image, results_dir_host,
     """
     os.makedirs(results_dir_host, exist_ok=True)
     if core.NO_DOCKER:
-        cmd = ["renode-test", robot_file_host, "-r", results_dir_host]
+        # Absolute paths: renode-test runs in the config's directory, not the cwd.
+        cmd = ["renode-test", os.path.abspath(robot_file_host),
+               "-r", os.path.abspath(results_dir_host)]
         if resc_host_path:
-            cmd += ["--variable", f"RESC:{resc_host_path}"]
+            cmd += ["--variable", f"RESC:{os.path.abspath(resc_host_path)}"]
         if extra_args:
             cmd += extra_args
-        result = subprocess.run(cmd)
+        result = subprocess.run(cmd, cwd=core.execution_dir())
         return result.returncode == 0
     flags = ["-it"] if interactive else []
     display = _xdisplay_args() if interactive else []

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/generator.py

@@ -262,7 +262,7 @@ def snapshot_resc(snapshot_container_path, debug_config=None, no_start=False):
 # ARTIFACT COLLECTION
 # ==========================================================================
 
-def collect_artifacts(patterns, output_dir, job_index=None):
+def collect_artifacts(patterns, output_dir, job_index=None, base_dir="."):
     """Sweep the global artifact glob patterns and copy matches into
     <output_dir>/artifacts/ so a single directory can be uploaded by CI / read by a
     dashboard.
@@ -270,6 +270,8 @@ def collect_artifacts(patterns, output_dir, job_index=None):
     patterns   : list of glob strings (top-level 'artifacts:' or --artifacts override)
     output_dir : the run output directory (--output)
     job_index  : 1-based job number; prefixes copied filenames to avoid cross-job clashes
+    base_dir   : directory relative patterns resolve against (the config's directory
+                 for 'artifacts:', the cwd for --artifacts)
 
     Returns the list of collected destination paths (relative to cwd).
     """
@@ -283,7 +285,7 @@ def collect_artifacts(patterns, output_dir, job_index=None):
     collected, seen = [], set()
     header_shown = False
     for pattern in patterns:
-        for src in sorted(_match_artifacts(pattern, dest_root)):
+        for src in sorted(_match_artifacts(pattern, dest_root, base_dir)):
             real = os.path.realpath(src)
             if real in seen or not os.path.isfile(real):
                 continue
@@ -308,19 +310,19 @@ def collect_artifacts(patterns, output_dir, job_index=None):
     return collected
 
 
-def _match_artifacts(pattern, dest_root):
-    """Resolve one artifact glob pattern to a list of host paths.
+def _match_artifacts(pattern, dest_root, base_dir="."):
+    """Resolve one artifact glob pattern (relative to base_dir) to a list of host paths.
 
-    A bare filename pattern (no '/', e.g. '*.xml') searches the whole project tree
+    A bare filename pattern (no '/', e.g. '*.xml') searches the whole base_dir tree
     recursively, pruning hidden dirs (.hector, .git, …) and the artifacts output dir —
     so 'results/junit.xml' is found without sweeping the bundled Renode clone.
     A pattern with a path component ('results/*.bin', 'logs/**/*.log') is passed to
     glob as-is, so explicit directories and '**' behave normally.
     """
     if "/" in pattern or os.sep in pattern:
-        return glob.glob(pattern, recursive=True)
+        return glob.glob(os.path.join(base_dir, pattern), recursive=True)
     matches = []
-    for root, dirs, files in os.walk("."):
+    for root, dirs, files in os.walk(base_dir):
         dirs[:] = [d for d in dirs
                    if not d.startswith(".")
                    and os.path.realpath(os.path.join(root, d)) != dest_root]

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/mappings.py

@@ -33,7 +33,7 @@ YAML then accepts:   mappings: |\n  boardA.eth0 -> tap:tap0
 from dataclasses import dataclass, field
 from typing import List
 
-from .core import Registry, RuntimeOptions, parse_endpoint, to_container_path
+from .core import Registry, RuntimeOptions, from_config, parse_endpoint, to_container_path
 from .generator import queue_command
 
 MAPPING_BACKENDS = Registry("mapping backend")
@@ -55,7 +55,7 @@ def file_backend(_node_name, peripheral, param, _node_config):
     if not param:
         raise ValueError("'file' backend requires a path (file:<path>).")
     return MappingResult(
-        machine_cmd=f"{peripheral} CreateFileBackend @{to_container_path(param)} true",
+        machine_cmd=f"{peripheral} CreateFileBackend @{to_container_path(from_config(param))} true",
     )
 
 

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/modules.py

@@ -14,7 +14,7 @@ import shutil
 from dataclasses import dataclass
 
 from .core import (ARTIFACTS_DIR, LIBOPENLIBM_NAME, Registry,
-                   container_path_for, host_uid_gid, split_host_container,
+                   container_path_for, from_config, host_uid_gid, split_host_container,
                    to_container_path)
 from .docker import run_build
 
@@ -46,7 +46,7 @@ def build_renode_verilator(module_name, module_config, ctx):
     if not source:
         raise ValueError(f"Module '{module_name}' is missing required 'source'.")
 
-    source_host, source_container = split_host_container(source)
+    source_host, source_container = split_host_container(from_config(source))
     if not os.path.isdir(source_host):
         raise FileNotFoundError(f"Module '{module_name}': source dir not found: {source} ({source_host})")
 
@@ -113,7 +113,7 @@ def build_csharp(module_name, module_config, ctx):
     if not source:
         raise ValueError(f"Module '{module_name}' is missing required 'source'.")
 
-    source_host, _ = split_host_container(source)
+    source_host, _ = split_host_container(from_config(source))
 
     # ---- raw .cs: Renode compiles it at load time (bundled Roslyn) — no SDK, no build ----
     if source_host.endswith(".cs"):

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/pipeline.py

@@ -47,6 +47,9 @@ from .validator import print_issues, validate_config
 # The config file every command reads/writes. Overridable with -f/--file; set by
 # apply_global_flags before any config is loaded.
 CONFIG_PATH = ".hector.yaml"
+# --workspace-mount given: mount the config's directory (where execution happens) at
+# that path, instead of the cwd. Set by apply_global_flags, applied once the config loads.
+MOUNT_CONFIG_DIR = False
 
 
 def apply_global_flags(args):
@@ -60,7 +63,9 @@ def apply_global_flags(args):
         global CONFIG_PATH
         CONFIG_PATH = path
     if getattr(args, "workspace_mount", None):
+        global MOUNT_CONFIG_DIR
         _core.WORKSPACE_MOUNT = args.workspace_mount
+        MOUNT_CONFIG_DIR = True
     if getattr(args, "no_docker", False) or os.environ.get("HECTOR_NO_DOCKER"):
         _core.NO_DOCKER = True
         _core.WORKSPACE_MOUNT = os.getcwd()
@@ -104,9 +109,26 @@ def load_config_or_exit():
     if v is not None and str(v) not in SUPPORTED_SCHEMA_VERSIONS:
         print(f"[WARN] .hector.yaml 'version: {v}' is not in supported versions "
               f"({', '.join(sorted(SUPPORTED_SCHEMA_VERSIONS))}). Proceeding anyway.")
+    _set_config_dir(config_path)
     return config
 
 
+def _set_config_dir(config_path):
+    """Make the config's directory the base for its paths and the working directory of
+    everything executed (see core.CONFIG_DIR), and make sure both it and the cwd (where
+    .hector/ and --output live) are reachable from the container.
+
+    By default the cwd is the workspace mount and a config dir outside it is mounted
+    1:1 as well. With --workspace-mount, the config dir is mounted at that path instead
+    (so execution happens there) and a cwd outside it is the one mounted 1:1."""
+    _core.CONFIG_DIR = os.path.realpath(os.path.dirname(os.path.abspath(config_path)))
+    if MOUNT_CONFIG_DIR:
+        _core.WORKSPACE_ROOT = _core.CONFIG_DIR
+        _core.register_dependency_mount(os.getcwd())
+    else:
+        _core.register_dependency_mount(_core.CONFIG_DIR)
+
+
 _VERSION_TAG_RE = re.compile(r"^v?\d+\.\d+\.\d+$")
 
 
@@ -138,6 +160,16 @@ def resolve_renode_image(config, args):
     return (f"v{normalized}" if normalized else None), image
 
 
+def apply_docker_args(config, args):
+    """Collect the user's extra `docker run` flags — the config's `docker_args:` (a
+    string or a list of strings) followed by --docker-args — into core.DOCKER_ARGS."""
+    raw = config.get("docker_args") or []
+    flags = []
+    for item in ([raw] if isinstance(raw, str) else raw):
+        flags += shlex.split(str(item))
+    _core.DOCKER_ARGS = flags + shlex.split(getattr(args, "docker_args", "") or "")
+
+
 def _resolve_set_overrides(args):
     overrides = {}
     for kv in (getattr(args, "set_args", None) or []):
@@ -166,6 +198,7 @@ def build_job_config(action, config, args, *, test_mode=False):
     """Assemble a JobConfig from parsed args — the shared run / test / export path:
     pin the image, prepare the framework (lazily), resolve arguments + artifacts."""
     git_tag, docker_image = resolve_renode_image(config, args)
+    apply_docker_args(config, args)
 
     # Clone Renode only when the config actually needs the source; otherwise skip it
     # entirely (a ~200 MB clone) and leave the framework vars empty.
@@ -186,8 +219,14 @@ def build_job_config(action, config, args, *, test_mode=False):
 
     resolved_args = resolve_arguments(config.get("arguments", {}),
                                       overrides=_resolve_set_overrides(args))
-    artifacts_cfg = (args.artifacts if getattr(args, "artifacts", None)
-                     else as_lines(config.get("artifacts", [])))
+    # --artifacts globs are relative to where hector runs; the config's own 'artifacts:'
+    # to the config's directory (like every other path written in the config).
+    if getattr(args, "artifacts", None):
+        artifacts_cfg, artifacts_base = args.artifacts, os.getcwd()
+    else:
+        artifacts_cfg = as_lines(config.get("artifacts", []))
+        artifacts_base = _core.config_dir()
+    test_file = getattr(args, "test_file", None)
     return JobConfig(
         config=config,
         fw_vars=fw_vars,
@@ -196,7 +235,8 @@ def build_job_config(action, config, args, *, test_mode=False):
         action=action,
         test_mode=test_mode,
         debug_args=getattr(args, "debug", None) or [],
-        test_file=getattr(args, "test_file", None),
+        # Absolute so it isn't re-resolved against the config's directory.
+        test_file=os.path.abspath(test_file) if test_file else None,
         reporter_names=_resolve_reporters(getattr(args, "reporters", None)),
         renode_args=shlex.split(getattr(args, "renode_args", "") or ""),
         renode_test_args=shlex.split(getattr(args, "renode_test_args", "") or ""),
@@ -208,6 +248,7 @@ def build_job_config(action, config, args, *, test_mode=False):
         output_dir=getattr(args, "output", "results"),
         gather_metrics=getattr(args, "gather_execution_metrics", None),
         artifacts=artifacts_cfg,
+        artifacts_base=artifacts_base,
     )
 
 
@@ -241,6 +282,7 @@ def snapshot_fastpath(args):
         print(f"[ERROR] Snapshot not found: {args.snapshot}", file=sys.stderr)
         sys.exit(1)
     _, docker_image = resolve_renode_image({}, args)
+    apply_docker_args({}, args)
     resc_root = os.path.join(ARTIFACTS_DIR, "resc")
     os.makedirs(resc_root, exist_ok=True)
     # No .hector.yaml here, so debug machine names come straight from --debug.
@@ -485,6 +527,7 @@ class JobConfig:
     output_dir: str = "results"
     gather_metrics: list = None
     artifacts: list = field(default_factory=list)
+    artifacts_base: str = "."           # directory the artifact globs resolve against
 
 
 @dataclass
@@ -757,7 +800,8 @@ def run_job(i, total_jobs, job_context, cfg):
         # Global glob patterns (top-level 'artifacts:' or --artifacts), interpolated
         # with this job's context so matrix variables resolve.
         artifact_patterns = as_lines(interpolate(list(cfg.artifacts), context))
-        collect_artifacts(artifact_patterns, cfg.output_dir, i + 1)
+        collect_artifacts(artifact_patterns, cfg.output_dir, i + 1,
+                          base_dir=cfg.artifacts_base)
 
     except Exception as exc:
         result["passed"] = False

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/runners.py

@@ -20,7 +20,7 @@ import time
 from dataclasses import dataclass, field
 
 from . import core as _core
-from .core import ARTIFACTS_DIR, Registry, to_container_path
+from .core import ARTIFACTS_DIR, Registry, from_config, to_container_path
 from .docker import resolve_shell_image, run_in_container, run_renode_test
 from .reporters import StepResult
 
@@ -170,7 +170,7 @@ def generate_robot_file(test_name, steps, resc_host_path, job_index, test_index,
 def _run_robot_test(test, steps, ctx, test_index):
     """Run a robot test. Returns a single StepResult for the whole test."""
     test_name = test.get("name", f"test_{test_index}")
-    effective_snapshot = ctx.snapshot or test.get("snapshot", "")
+    effective_snapshot = ctx.snapshot or from_config(test.get("snapshot", ""))
     if effective_snapshot and not os.path.isfile(effective_snapshot):
         raise FileNotFoundError(f"Snapshot not found: {effective_snapshot}")
 
@@ -190,7 +190,7 @@ def _run_robot_test(test, steps, ctx, test_index):
     if len(steps) == 1 and steps[0].get("file"):
         if effective_snapshot:
             print("  [WARN] snapshot ignored for file-based robot tests.")
-        robot_file = steps[0]["file"]
+        robot_file = from_config(steps[0]["file"])
     else:
         if any(s.get("file") for s in steps):
             raise ValueError(f"Test '{test_name}': mixing file: and script: steps is not supported.")

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector/validator.py

@@ -28,7 +28,7 @@ _TRIGGER_TOP_KEYS = {"when", "cron", "reporters", "jobs", "fail_fast", "timeout"
 
 # Top-level keys defined by this schema version; anything else is flagged.
 _KNOWN_TOP_KEYS = {
-    "version", "renode_version", "renode_image", "arguments", "matrix",
+    "version", "renode_version", "renode_image", "docker_args", "arguments", "matrix",
     "modules", "hubs", "machines", "connections", "mappings", "build", "tests", "quantum",
     "artifacts",
 } | _TRIGGER_TOP_KEYS
@@ -91,6 +91,13 @@ def validate_config(config) -> Tuple[List[Issue], List[Issue]]:
     if ri and not isinstance(ri, str):
         err("renode_image", f"Must be a string like 'my-renode:dev', got {type(ri).__name__}.")
 
+    # ---- docker_args ----
+    da = config.get("docker_args")
+    if da is not None and not (isinstance(da, str) or
+                               (isinstance(da, list) and all(isinstance(x, str) for x in da))):
+        err("docker_args", "Must be a string or a list of strings "
+            "(e.g. ['-v /opt/tools:/opt/tools', '-e FOO=1']).")
+
     # ---- unknown / renamed top-level keys ----
     for k in config:
         if k in _RENAMED_TOP_KEYS:

{hector_cli-0.5.0 → hector_cli-0.7.0}/hector_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hector-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: YAML-driven Renode + Verilator simulation orchestrator for embedded hardware CI
 Home-page: https://hector-ci.com
 Author: Nemesis
@@ -206,10 +206,11 @@ the CLI natively with `pip` and let hector launch real per-step containers.
 | `hector run --gather-execution-metrics boardA --gather-execution-metrics boardB` | Enable profiler for selected machines |
 | `hector run --renode-version 1.16.1` | Override the Renode version from `.hector.yaml` |
 | `hector run --renode-image my-renode:dev` | Use a specific (e.g. self-built) Renode Docker image |
+| `hector run --docker-args '-v /opt/tools:/opt/tools'` | Add extra flags (mounts, env, …) to every `docker run` |
 | `hector run --renode-dir /cache/renode` | Use/cache the Renode source checkout at this path (only fetched when needed) |
 | `hector run --renode-integration-dir /cache/integration` | Likewise for the verilator-integration checkout |
 | `hector run --no-docker` | Use locally installed `renode` / `renode-test` instead of Docker |
-| `hector run --workspace-mount /mnt` | Override the container path the project root is mounted at |
+| `hector run --workspace-mount /mnt` | Mount the hectorfile's folder at this container path and execute there |
 | `hector run --snapshot path/to/snapshot.save` | Load a snapshot instead of booting from the resc |
 | `hector run --snapshot snap.save --renode-version 1.16.1` | Load a snapshot without a `.hector.yaml` |
 | `hector test` | Run the `tests:` section; exit 1 on any failure |
@@ -482,6 +483,32 @@ hector run --renode-args '--console'
 hector run --renode-args '--hide-log --config my.conf'
 ```
 
+#### Paths and working directory
+
+Everything a hectorfile executes — `build:` steps, `shell` tests, Renode and `renode-test` — runs **in the hectorfile's folder**, and paths written in the file (`firmware:`, `platform:`, module `source:`, test `file:` / `snapshot:`, `file:` mappings, `artifacts:`, paths inside scripts and `commands:`) are **relative to that folder**. So `hector test -f boards/nucleo/.hector.yaml` behaves the same as running `hector test` inside `boards/nucleo/`.
+
+The directory you run hector from is mounted into the container (at the same path), and the container's working directory (`-w`) is the hectorfile's folder. If the hectorfile lives **outside** the directory you run from (`hector test -f ../other/.hector.yaml`), its folder is mounted as well, at its own path. (With [`--workspace-mount`](#overriding-the-workspace-mount-path---workspace-mount) the hectorfile's folder is mounted at the given path instead.) A path like `../shared/board.repl` works as long as it lands inside one of those mounts — for anything else, add a mount with [`docker_args`](#extra-docker-flags---docker-args). Under `--no-docker` the processes simply run with the hectorfile's folder as their cwd.
+
+Paths given on the **command line** (`--output`, `--snapshot`, `--test-file`, `--artifacts`, `--renode-dir`, …) stay relative to where you run hector, and `.hector/` is still created there.
+
+#### Extra Docker flags (`--docker-args`)
+
+Add your own flags to every `docker run` hector starts — Renode, robot tests, `shell` tests, `build:` steps and module builds — e.g. to mount more directories or set environment variables. Declare them in `.hector.yaml` as a string or a list:
+
+```yaml
+docker_args:
+  - -v /opt/toolchains:/opt/toolchains:ro
+  - -e LICENSE_SERVER=10.0.0.5
+```
+
+or pass them on the command line, where they are **appended** to the config's:
+
+```bash
+hector test --docker-args '-v /data/firmware:/data/firmware'
+```
+
+Use absolute host paths for `-v` (Docker treats a bare name as a named volume). Ignored under `--no-docker`.
+
 #### Container networking
 
 Every container hector starts — the Renode emulation (`run`), robot tests, `shell` tests, `build:` steps and module builds — runs with `--net=host`. GDB servers (`--debug`), `tcp:` mappings and anything a step listens on are reachable from the host on the same port, and steps can reach host services on `localhost`. No port publishing is involved.
@@ -545,12 +572,15 @@ An existing directory is reused as-is; a missing one is cloned into. The locatio
 
 #### Overriding the workspace mount path (`--workspace-mount`)
 
-By default the project root is bind-mounted into the container at the **same absolute path** as on the host (e.g. `/home/user/projects/myboard`), so paths look identical inside and outside the container. Override this only if the host path is unavailable at that location inside the image:
+By default everything is bind-mounted into the container at the **same absolute path** as on the host (e.g. `/home/user/projects/myboard`), so paths look identical inside and outside the container. `--workspace-mount PATH` instead mounts the **hectorfile's folder** at `PATH`, and that's where every step, Renode and `renode-test` execute:
 
 ```bash
-hector run --workspace-mount /workspace
+hector run --workspace-mount /workspace                              # . → /workspace
+hector test -f boards/nucleo/.hector.yaml --workspace-mount /workspace  # boards/nucleo → /workspace
 ```
 
+When you run from a different folder than the hectorfile's (the second line), that folder — where `.hector/` and `--output` live — is additionally mounted at its own path, unless it's already inside the hectorfile's folder.
+
 **Cannot be combined with `--no-docker`** — if you are running locally there is no container mount to configure.
 
 ### Selecting a matrix combination (`--job`)
@@ -625,6 +655,7 @@ The configuration lives in `.hector.yaml`.
 | `version` | No | Schema version (currently `"0.1"`). Warns if unrecognised. |
 | `renode_version` | Yes¹ | Renode version, no leading `v` (e.g. `1.16.1`). Selects both the git tag for cloning and the Docker image tag. |
 | `renode_image` | Yes¹ | Full Renode Docker image to use instead of `antmicro/renode:<renode_version>` (e.g. a self-built `my-renode:dev`). See [custom Renode image](#using-a-custom-renode-image---renode-image). |
+| `docker_args` | No | Extra `docker run` flags (string or list) for every container, e.g. more `-v` mounts. See [extra Docker flags](#extra-docker-flags---docker-args). |
 | `arguments` | No | Scalar defaults, overridable by env var or `--set`. |
 | `build` | No | Pre-sim shell steps run once per job in containers (compile firmware, fetch/generate files, …). Interpolated with the job's arguments/matrix variables. |
 | `matrix` | No | Cross-product job expansion. |

{hector_cli-0.5.0 → hector_cli-0.7.0}/tests/test_core_paths.py

@@ -84,6 +84,33 @@ def test_container_path_for_prefers_extra_mount(project, tmp_path_factory):
     assert core.container_path_for(str(inner)) == str((cache / "renode" / "x.so").resolve())
 
 
+def test_from_config_resolves_against_config_dir(project, monkeypatch):
+    monkeypatch.setattr(core, "CONFIG_DIR", str(project / "board"))
+    assert core.from_config("fw/app.elf") == str(project / "board" / "fw" / "app.elf")
+    assert core.from_config("../shared/x.repl") == str(project / "shared" / "x.repl")
+
+
+def test_from_config_leaves_absolute_and_urls(project, monkeypatch):
+    monkeypatch.setattr(core, "CONFIG_DIR", str(project / "board"))
+    for p in ("/opt/renode/x.repl", "https://example.com/fw.elf", "", None):
+        assert core.from_config(p) == p
+
+
+def test_from_config_defaults_to_cwd(project, monkeypatch):
+    monkeypatch.setattr(core, "CONFIG_DIR", None)
+    assert core.from_config("fw.elf") == str(project / "fw.elf")
+
+
+def test_execution_dir_is_container_path_of_config_dir(project, monkeypatch):
+    (project / "board").mkdir()
+    monkeypatch.setattr(core, "NO_DOCKER", False)
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", "/workspace")
+    monkeypatch.setattr(core, "CONFIG_DIR", str(project / "board"))
+    assert core.execution_dir() == "/workspace/board"
+    monkeypatch.setattr(core, "NO_DOCKER", True)
+    assert core.execution_dir() == str(project / "board")
+
+
 def test_host_uid_gid_on_posix():
     ids = core.host_uid_gid()
     if hasattr(os, "getuid"):

{hector_cli-0.5.0 → hector_cli-0.7.0}/tests/test_docker_argv.py

@@ -14,6 +14,8 @@ def clean_env(monkeypatch, tmp_path):
     monkeypatch.setattr(core, "WORKSPACE_MOUNT", str(tmp_path))
     monkeypatch.setattr(core, "EXTRA_MOUNTS", [])
     monkeypatch.setattr(core, "NO_DOCKER", False)
+    monkeypatch.setattr(core, "CONFIG_DIR", None)
+    monkeypatch.setattr(core, "DOCKER_ARGS", [])
     # Neutralise X11 forwarding so argv is deterministic across hosts.
     monkeypatch.delenv("XAUTHORITY", raising=False)
     monkeypatch.delenv("HOME", raising=False)
@@ -21,20 +23,71 @@ def clean_env(monkeypatch, tmp_path):
 
 # ---- build_renode_argv ----
 
-def test_no_docker_is_bare_renode(monkeypatch):
+def test_no_docker_is_bare_renode(monkeypatch, tmp_path):
     monkeypatch.setattr(core, "NO_DOCKER", True)
+    # Absolute: renode runs in the config's directory, not the cwd.
     assert docker.build_renode_argv("job.resc", "img", extra_args=["--console"]) == [
-        "renode", "job.resc", "--console"]
+        "renode", str(tmp_path / "job.resc"), "--console"]
 
 
-def test_docker_argv_core_tokens():
+def test_docker_argv_core_tokens(tmp_path):
     argv = docker.build_renode_argv("job.resc", "antmicro/renode:1.16.1")
     assert argv[:3] == ["docker", "run", "-it"]
     assert "--net=host" in argv
     assert "antmicro/renode:1.16.1" in argv
     # The image must be immediately followed by the renode invocation.
     i = argv.index("antmicro/renode:1.16.1")
-    assert argv[i + 1:i + 3] == ["renode", "job.resc"]
+    assert argv[i + 1:i + 3] == ["renode", str(tmp_path / "job.resc")]
+
+
+def test_workdir_is_cwd_without_config(tmp_path):
+    argv = docker.build_renode_argv("j.resc", "img")
+    assert argv[argv.index("-w") + 1] == str(tmp_path)
+
+
+def test_workdir_is_config_dir_mount_unchanged(monkeypatch, tmp_path):
+    (tmp_path / "sub").mkdir()
+    monkeypatch.setattr(core, "CONFIG_DIR", str(tmp_path / "sub"))
+    argv = docker.build_renode_argv("j.resc", "img")
+    assert argv[argv.index("-v") + 1] == f"{tmp_path}:{tmp_path}"
+    assert argv[argv.index("-w") + 1] == str(tmp_path / "sub")
+
+
+def test_user_docker_args_reach_every_container(monkeypatch):
+    monkeypatch.setattr(core, "DOCKER_ARGS", ["-v", "/opt/tools:/opt/tools", "-e", "FOO=1"])
+    calls = []
+
+    class _Proc:
+        returncode, stdout = 0, ""
+
+    monkeypatch.setattr(docker.subprocess, "run",
+                        lambda cmd, **kw: calls.append(cmd) or _Proc())
+    monkeypatch.setattr(docker.os, "makedirs", lambda *a, **kw: None)
+    docker.run_build("true", "img")
+    docker.run_in_container("true", "img")
+    docker.run_renode_test("t.robot", "img", "res")
+    docker.run_renode("j.resc", "img")
+    for cmd in calls:
+        i = cmd.index("/opt/tools:/opt/tools")
+        assert cmd[i - 1] == "-v" and cmd[i + 1:i + 3] == ["-e", "FOO=1"]
+        assert i < cmd.index("img")             # flags must precede the image
+
+
+def test_no_docker_steps_run_in_config_dir(monkeypatch, tmp_path):
+    monkeypatch.setattr(core, "NO_DOCKER", True)
+    monkeypatch.setattr(core, "CONFIG_DIR", str(tmp_path / "sub"))
+    cwds = []
+
+    class _Proc:
+        returncode, stdout = 0, ""
+
+    monkeypatch.setattr(docker.subprocess, "run",
+                        lambda cmd, **kw: cwds.append(kw.get("cwd")) or _Proc())
+    docker.run_build("true", "img")
+    docker.run_in_container("true", "img")
+    docker.run_renode_test("t.robot", "img", "res")
+    docker.run_renode("j.resc", "img")
+    assert cwds == [str(tmp_path / "sub")] * 4
 
 
 def test_docker_argv_does_not_publish_ports():
@@ -60,9 +113,9 @@ def test_every_container_uses_host_network(monkeypatch):
     assert all("--net=host" in cmd for cmd in calls)
 
 
-def test_docker_argv_appends_extra_args_after_resc():
+def test_docker_argv_appends_extra_args_after_resc(tmp_path):
     argv = docker.build_renode_argv("j.resc", "img", extra_args=["--console", "--hide-log"])
-    assert argv[-3:] == ["j.resc", "--console", "--hide-log"]
+    assert argv[-3:] == [str(tmp_path / "j.resc"), "--console", "--hide-log"]
 
 
 # ---- _runtime_flags ----

{hector_cli-0.5.0 → hector_cli-0.7.0}/tests/test_generator.py

@@ -6,7 +6,7 @@ import os
 import pytest
 
 from hector.generator import (NodeDescriptor, PeripheralDef, build_repl_fragment,
-                              finalize_commands, generate_emulation_resc,
+                              collect_artifacts, finalize_commands, generate_emulation_resc,
                               generate_node_repl, repl_value, snapshot_resc,
                               write_inline_repl)
 
@@ -194,3 +194,19 @@ def test_snapshot_resc_reopens_gdb_after_load():
     # A GDB server is never part of saved state, so it must be (re)started post-Load.
     assert text.index("Load @") < text.index("StartGdbServer 4444")
     assert 'mach set "mcu"' in text
+
+
+# ---- collect_artifacts ----
+
+def test_collect_artifacts_resolves_against_base_dir(tmp_path, monkeypatch):
+    # Config in board/: its 'artifacts:' globs resolve there, not against the cwd.
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "board" / "build").mkdir(parents=True)
+    (tmp_path / "board" / "build" / "fw.bin").write_text("x")
+    (tmp_path / "board" / "uart.log").write_text("x")
+    (tmp_path / "other.log").write_text("x")
+    collected = collect_artifacts(["build/*.bin", "*.log"], "results", 1,
+                                  base_dir=str(tmp_path / "board"))
+    assert sorted(collected) == [
+        os.path.join("results", "artifacts", "job_1", "board", "build", "fw.bin"),
+        os.path.join("results", "artifacts", "job_1", "board", "uart.log")]

{hector_cli-0.5.0 → hector_cli-0.7.0}/tests/test_pipeline_helpers.py

@@ -36,6 +36,90 @@ def test_config_path_returns_requested_when_neither_exists(tmp_path, monkeypatch
     assert resolve_config_path("missing.yaml") == "missing.yaml"
 
 
+# ---- load_config_or_exit: the config's directory ----
+
+@pytest.fixture
+def config_in_subdir(tmp_path, monkeypatch):
+    from hector import core, pipeline
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", str(tmp_path))
+    monkeypatch.setattr(core, "NO_DOCKER", False)
+    monkeypatch.setattr(core, "CONFIG_DIR", None)
+    monkeypatch.setattr(core, "EXTRA_MOUNTS", [])
+    monkeypatch.setattr(core, "WORKSPACE_ROOT", None)
+    monkeypatch.setattr(pipeline, "MOUNT_CONFIG_DIR", False)
+    (tmp_path / "board").mkdir()
+    (tmp_path / "board" / ".hector.yaml").write_text("renode_version: '1.16.1'\n")
+    return pipeline, core, tmp_path
+
+
+def test_load_config_sets_config_dir(config_in_subdir, monkeypatch):
+    pipeline, core, root = config_in_subdir
+    monkeypatch.setattr(pipeline, "CONFIG_PATH", "board/.hector.yaml")
+    pipeline.load_config_or_exit()
+    assert core.CONFIG_DIR == str(root / "board")
+    assert core.execution_dir() == str(root / "board")
+    assert core.EXTRA_MOUNTS == []            # inside the cwd mount already
+
+
+def test_load_config_outside_cwd_is_mounted_too(config_in_subdir, monkeypatch):
+    # Run from a sibling dir: the cwd stays the workspace mount, and ../board is
+    # bind-mounted 1:1 so the config's paths and working dir are reachable.
+    pipeline, core, root = config_in_subdir
+    (root / "elsewhere").mkdir()
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", str(root / "elsewhere"))
+    monkeypatch.chdir(root / "elsewhere")
+    monkeypatch.setattr(pipeline, "CONFIG_PATH", "../board/.hector.yaml")
+    pipeline.load_config_or_exit()
+    board = str((root / "board").resolve())
+    assert core.EXTRA_MOUNTS == [board]
+    assert core.execution_dir() == board
+    assert core.to_container_path(core.from_config("fw.elf")) == f"{board}/fw.elf"
+
+
+def test_workspace_mount_mounts_config_dir_there(config_in_subdir, monkeypatch):
+    # Run from the parent with --workspace-mount /workspace: the config's dir is what's
+    # mounted there and where execution happens; the cwd (.hector/, --output) is 1:1.
+    pipeline, core, root = config_in_subdir
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", "/workspace")
+    monkeypatch.setattr(pipeline, "MOUNT_CONFIG_DIR", True)
+    monkeypatch.setattr(pipeline, "CONFIG_PATH", "board/.hector.yaml")
+    pipeline.load_config_or_exit()
+    board, cwd = str((root / "board").resolve()), str(root.resolve())
+    assert core.workspace_root() == board
+    assert core.execution_dir() == "/workspace"
+    assert core.to_container_path(core.from_config("fw/app.elf")) == "/workspace/fw/app.elf"
+    assert core.EXTRA_MOUNTS == [cwd]
+    assert core.to_container_path(".hector/resc/job_1.resc") == f"{cwd}/.hector/resc/job_1.resc"
+
+
+def test_workspace_mount_from_config_dir_needs_no_extra_mount(config_in_subdir, monkeypatch):
+    pipeline, core, root = config_in_subdir
+    monkeypatch.chdir(root / "board")
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", "/workspace")
+    monkeypatch.setattr(pipeline, "MOUNT_CONFIG_DIR", True)
+    monkeypatch.setattr(pipeline, "CONFIG_PATH", ".hector.yaml")
+    pipeline.load_config_or_exit()
+    assert core.execution_dir() == "/workspace"
+    assert core.EXTRA_MOUNTS == []
+
+
+# ---- apply_docker_args ----
+
+@pytest.mark.parametrize("cfg,flag,expected", [
+    ({}, "", []),
+    ({"docker_args": "-v /a:/a -e X=1"}, "", ["-v", "/a:/a", "-e", "X=1"]),
+    ({"docker_args": ["-v /a:/a", "--env 'Y=two words'"]}, "",
+     ["-v", "/a:/a", "--env", "Y=two words"]),
+    ({"docker_args": "-v /a:/a"}, "-v /b:/b", ["-v", "/a:/a", "-v", "/b:/b"]),  # flag appends
+])
+def test_apply_docker_args(monkeypatch, cfg, flag, expected):
+    from hector import core, pipeline
+    monkeypatch.setattr(core, "DOCKER_ARGS", [])
+    pipeline.apply_docker_args(cfg, SimpleNamespace(docker_args=flag))
+    assert core.DOCKER_ARGS == expected
+
+
 # ---- resolve_renode_image ----
 
 def test_image_from_config():

{hector_cli-0.5.0 → hector_cli-0.7.0}/tests/test_validator.py

@@ -39,6 +39,22 @@ def test_missing_renode_version_is_error():
     assert any(i.path == "renode_version" for i in errors)
 
 
+def test_renode_image_alone_satisfies_requirement():
+    errors, _ = validate_config({"renode_image": "my-renode:dev"})
+    assert errors == []
+
+
+@pytest.mark.parametrize("value", ["-v /a:/a", ["-v /a:/a", "-e X=1"]])
+def test_docker_args_accepts_string_or_list(value):
+    errors, warnings = validate_config({"renode_version": "1.16.1", "docker_args": value})
+    assert errors == [] and not any(w.path == "docker_args" for w in warnings)
+
+
+def test_docker_args_wrong_type_is_error():
+    errors, _ = validate_config({"renode_version": "1.16.1", "docker_args": {"v": "/a"}})
+    assert any(i.path == "docker_args" for i in errors)
+
+
 def test_unknown_module_kind_is_error():
     cfg = {"renode_version": "1.16.1",
            "modules": {"u": {"kind": "bogus", "type": "X", "source": "s"}}}