autopkg-wrapper 2026.2.2__tar.gz → 2026.2.5__tar.gz

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/.github/workflows/build-publish.yml

@@ -105,22 +105,20 @@ jobs:
     steps:
       - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
-      - name: Setup UV
-        uses: astral-sh/setup-uv@803947b9bd8e9f986429fa0c5a41c367cd732b41 # v7.2.1
+      - name: Setup mise
+        uses: jdx/mise-action@6d1e696aa24c1aa1bcc1adea0212707c71ab78a8 # v3.6.1
         with:
-          activate-environment: true
-          enable-cache: true
-          cache-dependency-glob: uv.lock
+          install: true
+          cache: true
 
-      - name: Setup Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-        with:
-          python-version-file: pyproject.toml
+      - name: Run tests
+        run: mise run test
+
+      - name: Build package
+        env:
+          RELEASE_VERSION: ${{ needs.release.outputs.version }}
+        run: mise run build
 
-      - name: Build Package with UV
-        run: |
-          uv version ${{ needs.release.outputs.version }}
-          uv build
       - name: Upload Package Artifacts
         uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autopkg-wrapper
-Version: 2026.2.2
+Version: 2026.2.5
 Summary: A package used to execute some autopkg functions, primarily within the context of a GitHub Actions runner.
 Project-URL: Repository, https://github.com/smithjw/autopkg-wrapper
 Author-email: James Smith <james@smithjw.me>
@@ -33,6 +33,8 @@ pip install autopkg-wrapper
 -h, --help                      Show this help message and exit
 --recipe-file RECIPE_FILE       Path to a list of recipes to run (cannot be run with --recipes)
 --recipes [RECIPES ...]         Recipes to run with autopkg (cannot be run with --recipe-file)
+--recipe-processing-order [RECIPE_PROCESSING_ORDER ...]
+                                Optional processing order for recipe "types" (suffix segments after the first '.'); supports partial tokens like upload/auto_update; env var AW_RECIPE_PROCESSING_ORDER expects comma-separated values
 --debug                         Enable debug logging when running script
  --disable-recipe-trust-check    If this option is used, recipe trust verification will not be run prior to a recipe run.
  --github-token GITHUB_TOKEN     A token used to publish a PR to your GitHub repo if overrides require their trust to be updated

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/README.md

@@ -14,6 +14,8 @@ pip install autopkg-wrapper
 -h, --help                      Show this help message and exit
 --recipe-file RECIPE_FILE       Path to a list of recipes to run (cannot be run with --recipes)
 --recipes [RECIPES ...]         Recipes to run with autopkg (cannot be run with --recipe-file)
+--recipe-processing-order [RECIPE_PROCESSING_ORDER ...]
+                                Optional processing order for recipe "types" (suffix segments after the first '.'); supports partial tokens like upload/auto_update; env var AW_RECIPE_PROCESSING_ORDER expects comma-separated values
 --debug                         Enable debug logging when running script
  --disable-recipe-trust-check    If this option is used, recipe trust verification will not be run prior to a recipe run.
  --github-token GITHUB_TOKEN     A token used to publish a PR to your GitHub repo if overrides require their trust to be updated

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/autopkg_wrapper/autopkg_wrapper.py

@@ -13,6 +13,7 @@ import autopkg_wrapper.utils.git_functions as git
 from autopkg_wrapper.notifier import slack
 from autopkg_wrapper.utils.args import setup_args
 from autopkg_wrapper.utils.logging import setup_logger
+from autopkg_wrapper.utils.recipe_ordering import order_recipe_list
 from autopkg_wrapper.utils.report_processor import process_reports
 
 
@@ -36,43 +37,39 @@ class Recipe(object):
         return name
 
     def verify_trust_info(self, args):
-        verbose_output = ["-vvvv"] if args.debug else None
+        verbose_output = ["-vvvv"] if args.debug else []
         prefs_file = (
-            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else None
+            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else []
         )
-        cmd = ["/usr/local/bin/autopkg", "verify-trust-info", self.filename]
-        cmd = cmd + verbose_output if verbose_output else cmd
-        cmd = cmd + prefs_file if prefs_file else cmd
-        cmd = " ".join(cmd)
-        logging.debug(f"cmd: {str(cmd)}")
-
-        p = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
+        autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
+        cmd = (
+            [autopkg_bin, "verify-trust-info", self.filename]
+            + verbose_output
+            + prefs_file
         )
-        (output, err) = p.communicate()
-        p_status = p.wait()
-        if p_status == 0:
+        logging.debug(f"cmd: {cmd}")
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode == 0:
             self.verified = True
         else:
-            err = err.decode()
-            self.results["message"] = err
+            self.results["message"] = (result.stderr or "").strip()
             self.verified = False
         return self.verified
 
     def update_trust_info(self, args):
         prefs_file = (
-            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else None
+            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else []
         )
-        cmd = ["/usr/local/bin/autopkg", "update-trust-info", self.filename]
-        cmd = cmd + prefs_file if prefs_file else cmd
-        cmd = " ".join(cmd)
-        logging.debug(f"cmd: {str(cmd)}")
+        autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
+        cmd = [autopkg_bin, "update-trust-info", self.filename] + prefs_file
+        logging.debug(f"cmd: {cmd}")
 
         # Fail loudly if this exits 0
         try:
-            subprocess.check_call(cmd, shell=True)
+            subprocess.check_call(cmd)
         except subprocess.CalledProcessError as e:
-            logging.error(e.stderr)
+            logging.error(str(e))
             raise e
 
     def _parse_report(self, report):
@@ -108,9 +105,9 @@ class Recipe(object):
                 prefs_file = (
                     ["--prefs", args.autopkg_prefs.as_posix()]
                     if args.autopkg_prefs
-                    else None
+                    else []
                 )
-                verbose_output = ["-vvvv"] if args.debug else None
+                verbose_output = ["-vvvv"] if args.debug else []
                 post_processor_cmd = (
                     list(
                         chain.from_iterable(
@@ -121,25 +118,25 @@ class Recipe(object):
                         )
                     )
                     if self.post_processors
-                    else None
+                    else []
                 )
+                autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
                 cmd = [
-                    "/usr/local/bin/autopkg",
+                    autopkg_bin,
                     "run",
                     self.filename,
                     "--report-plist",
                     str(report),
                 ]
-                cmd = cmd + post_processor_cmd if post_processor_cmd else cmd
-                cmd = cmd + verbose_output if verbose_output else cmd
-                cmd = cmd + prefs_file if prefs_file else cmd
-                cmd = " ".join(cmd)
+                cmd = cmd + post_processor_cmd + verbose_output + prefs_file
 
-                logging.debug(f"cmd: {str(cmd)}")
+                logging.debug(f"cmd: {cmd}")
 
-                subprocess.check_call(cmd, shell=True)
+                result = subprocess.run(cmd, capture_output=True, text=True)
+                if result.returncode != 0:
+                    self.error = True
 
-            except subprocess.CalledProcessError:
+            except Exception:
                 self.error = True
 
             self._has_run = True
@@ -246,7 +243,12 @@ def update_recipe_repo(recipe, git_info, disable_recipe_trust_check, args):
 
 
 def parse_recipe_list(recipes, recipe_file, post_processors, args):
-    """Parsing list of recipes into a common format"""
+    """Parse recipe inputs into a common list of recipe names.
+
+    The arguments assume that `recipes` and `recipe_file` are mutually exclusive.
+    If `args.recipe_processing_order` is provided, the list is re-ordered before
+    creating `Recipe` objects.
+    """
     recipe_list = None
 
     logging.info(f"Recipes: {recipes}") if recipes else None
@@ -256,6 +258,12 @@ def parse_recipe_list(recipes, recipe_file, post_processors, args):
         if recipe_file.suffix == ".json":
             with open(recipe_file, "r") as f:
                 recipe_list = json.load(f)
+        elif recipe_file.suffix in {".yaml", ".yml"}:
+            from ruamel.yaml import YAML
+
+            yaml = YAML(typ="safe")
+            with open(recipe_file, "r", encoding="utf-8") as f:
+                recipe_list = yaml.load(f)
         elif recipe_file.suffix == ".txt":
             with open(recipe_file, "r") as f:
                 recipe_list = f.read().splitlines()
@@ -279,11 +287,16 @@ def parse_recipe_list(recipes, recipe_file, post_processors, args):
             """Please provide recipes to run via the following methods:
     --recipes recipe_one.download recipe_two.download
     --recipe-file path/to/recipe_list.json
-    Comma separated list in the AUTOPKG_RECIPES env variable"""
+    Comma separated list in the AW_RECIPES env variable"""
         )
         sys.exit(1)
 
-    logging.info(f"Processing the following recipes: {recipe_list}")
+    if args.recipe_processing_order:
+        recipe_list = order_recipe_list(
+            recipe_list=recipe_list, order=args.recipe_processing_order
+        )
+
+    logging.info(f"Processing {len(recipe_list)} recipes.")
     recipe_map = [Recipe(name, post_processors=post_processors) for name in recipe_list]
 
     return recipe_map

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/autopkg_wrapper/notifier/slack.py

@@ -5,7 +5,7 @@ import requests
 
 
 def send_notification(recipe, token):
-    logging.debug("Skipping Slack notification as DEBUG is enabled!")
+    logging.debug("Preparing Slack notification")
 
     if token is None:
         logging.error("Skipping Slack Notification as no SLACK_WEBHOOK_TOKEN defined!")

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/autopkg_wrapper/utils/args.py

@@ -68,6 +68,33 @@ def setup_args():
                 `autopkg-wrapper`
             """,
     )
+    parser.add_argument(
+        "--recipe-processing-order",
+        nargs="*",
+        default=os.getenv("AW_RECIPE_PROCESSING_ORDER", None),
+        help="""
+            This option comes in handy if you include additional recipe type names in your overrides and wish them to be processed in a specific order.
+            We'll specifically look for these recipe types after the first period (.) in the recipe name.
+            Order items can be either a full type suffix (e.g. "upload.jamf") or a partial token (e.g. "upload", "auto_update").
+            Partial tokens are matched against the dot-separated segments after the first '.' so recipes like "Foo.epz.auto_update.jamf" will match "auto_update".
+            This can also be provided via the 'AW_RECIPE_PROCESSING_ORDER' environment variable as a comma-separated list (e.g. "upload,self_service,auto_update").
+            For example, if you have the following recipes to be processed:
+                ExampleApp.auto_install.jamf
+                ExampleApp.upload.jamf
+                ExampleApp.self_service.jamf
+            And you want to ensure that the .upload recipes are always processed first, followed by .auto_install, and finally .self_service, you would provide the following processing order:
+                `--recipe-processing-order upload.jamf auto_install.jamf self_service.jamf`
+            This would ensure that all .upload recipes are processed before any other recipe types.
+            Within each recipe type, the recipes will be ordered alphabetically.
+            We assume that no extensions are provided (but will strip them if needed - extensions that are stripped include .recipe or .recipe.yaml).
+            """,
+    )
+    parser.add_argument(
+        "--autopkg-bin",
+        default=os.getenv("AW_AUTOPKG_BIN", "/usr/local/bin/autopkg"),
+        help="Path to the autopkg binary (default: /usr/local/bin/autopkg). Can also be set via AW_AUTOPKG_BIN.",
+    )
+
     parser.add_argument(
         "--debug",
         default=validate_bool(os.getenv("AW_DEBUG", False)),

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/autopkg_wrapper/utils/git_functions.py

@@ -1,4 +1,5 @@
 import logging
+import re
 import subprocess
 from datetime import datetime
 
@@ -21,12 +22,26 @@ def git_run(*args):
 
 
 def get_repo_info(override_repo_git_git_dir):
-    repo_url = (
-        git_run(override_repo_git_git_dir, "config", "--get", "remote.origin.url")
-        .stdout.strip()
-        .split(".git")[0]
+    remote = git_run(
+        override_repo_git_git_dir, "config", "--get", "remote.origin.url"
+    ).stdout.strip()
+
+    # Supports:
+    # - https://github.com/<owner>/<repo>.git
+    # - git@github.com:<owner>/<repo>.git
+    # - ssh://git@github.com/<owner>/<repo>.git
+    m = re.search(
+        r"github\.com[:/](?P<owner>[^/]+)/(?P<repo>[^\s/]+?)(?:\.git)?$",
+        remote,
+        flags=re.IGNORECASE,
     )
-    remote_repo_ref = repo_url.split("https://github.com/")[1]
+    if not m:
+        raise ValueError(f"Unsupported Git remote URL: {remote}")
+
+    owner = m.group("owner")
+    repo = m.group("repo")
+    remote_repo_ref = f"{owner}/{repo}"
+    repo_url = f"https://github.com/{remote_repo_ref}"
 
     logging.debug(f"Repo URL: {repo_url}")
     logging.debug(f"Remote Repo Ref: {remote_repo_ref}")

autopkg_wrapper-2026.2.5/autopkg_wrapper/utils/recipe_ordering.py

@@ -0,0 +1,149 @@
+import logging
+
+
+def order_recipe_list(recipe_list, order):
+    # This option comes in handy if you include additional recipe type names in your overrides and wish them to be processed in a specific order.
+    # We'll specifically look for these recipe types after the first period (.) in the recipe name.
+    # For example, if you have the following recipes to be processed:
+    #     ExampleApp.auto_install.jamf
+    #     ExampleApp.upload.jamf
+    #     ExampleApp.self_service.jamf
+    # And you want to ensure that the .upload recipes are always processed first, followed by .auto_install, and finally .self_service, you would provide the following processing order:
+    #     `--recipe-processing-order upload.jamf auto_install.jamf self_service.jamf`
+    # This would ensure that all .upload recipes are processed before any other recipe types.
+    # Within each recipe type, the recipes will be ordered alphabetically.
+    # We assume that no extensions are provided (but will strip them if needed - extensions that are stripped include .recipe or .recipe.yaml).
+
+    def strip_known_extensions(value: str) -> str:
+        value = value.strip()
+        if value.endswith(".recipe.yaml"):
+            return value[: -len(".recipe.yaml")]
+        if value.endswith(".recipe"):
+            return value[: -len(".recipe")]
+        return value
+
+    def normalise_processing_order(value):
+        if not value:
+            return []
+
+        items: list[str] = []
+        if isinstance(value, str):
+            raw = value.strip()
+            if not raw:
+                return []
+            # String values generally come from env var defaults; treat as comma-separated.
+            items = [v.strip() for v in raw.split(",")]
+        else:
+            # argparse typically provides a list here, but env var defaults can leak through.
+            for v in value:
+                if v is None:
+                    continue
+                v = str(v).strip()
+                if not v:
+                    continue
+                if "," in v:
+                    items.extend([p.strip() for p in v.split(",")])
+                else:
+                    items.append(v)
+
+        normalised: list[str] = []
+        seen: set[str] = set()
+        for item in items:
+            if not item:
+                continue
+            item = item.lstrip(".")
+            item = strip_known_extensions(item)
+            if not item or item in seen:
+                continue
+            seen.add(item)
+            normalised.append(item)
+        return normalised
+
+    def recipe_type(recipe_name: str) -> str:
+        # Type is everything after the first '.' (e.g. Example.upload.jamf -> upload.jamf)
+        parts = recipe_name.split(".", 1)
+        return parts[1] if len(parts) == 2 else ""
+
+    def recipe_segments_after_first_dot(recipe_name: str) -> list[str]:
+        after_first = recipe_type(recipe_name)
+        return [p for p in after_first.split(".") if p] if after_first else []
+
+    def pattern_matches_segments(pattern: str, segments: list[str]) -> bool:
+        # Pattern can be a single token ("auto_update") or a dot-separated sequence
+        # ("upload.jamf", "auto_update.jamf", etc.).
+        if not pattern:
+            return False
+        pattern_parts = [p for p in pattern.split(".") if p]
+        if not pattern_parts:
+            return False
+
+        # Case-insensitive matching.
+        segments_norm = [s.casefold() for s in segments]
+        pattern_parts_norm = [p.casefold() for p in pattern_parts]
+
+        if len(pattern_parts_norm) == 1:
+            return pattern_parts_norm[0] in segments_norm
+
+        # Contiguous subsequence match.
+        for start in range(0, len(segments_norm) - len(pattern_parts_norm) + 1):
+            if (
+                segments_norm[start : start + len(pattern_parts_norm)]
+                == pattern_parts_norm
+            ):
+                return True
+        return False
+
+    if not recipe_list:
+        return recipe_list
+
+    normalised_order = normalise_processing_order(order)
+
+    # If the provided order contains no usable tokens, do not re-order.
+    # (We still strip known extensions, which is order-preserving.)
+    if not normalised_order:
+        return [
+            strip_known_extensions(str(r).strip()) for r in recipe_list if r is not None
+        ]
+
+    # First, normalise recipe names by stripping known extensions.
+    normalised_recipes: list[str] = []
+    for r in recipe_list:
+        if r is None:
+            continue
+        normalised_recipes.append(strip_known_extensions(str(r).strip()))
+
+    # If a processing order is supplied, match each recipe to the *first* pattern it satisfies.
+    # This supports both direct matches ("upload.jamf") and partial matches ("upload",
+    # "auto_update") against dot-separated segments after the first '.' in the recipe name.
+    pattern_groups: dict[str, list[str]] = {p: [] for p in normalised_order}
+    unmatched: list[str] = []
+
+    for r in normalised_recipes:
+        segments = recipe_segments_after_first_dot(r)
+        matched = False
+        for p in normalised_order:
+            if pattern_matches_segments(p, segments):
+                pattern_groups[p].append(r)
+                matched = True
+                break
+        if not matched:
+            unmatched.append(r)
+
+    ordered: list[str] = []
+    for p in normalised_order:
+        ordered.extend(sorted(pattern_groups[p], key=str.casefold))
+
+    # Remaining recipes: group by their full type string and order groups alphabetically,
+    # with empty-type last.
+    groups: dict[str, list[str]] = {}
+    for r in unmatched:
+        t = recipe_type(r)
+        groups.setdefault(t, []).append(r)
+
+    for t in sorted(groups.keys(), key=lambda x: (x == "", x.casefold())):
+        ordered.extend(sorted(groups[t], key=str.casefold))
+
+    logging.debug(f"Recipe processing order: {normalised_order}")
+    logging.debug(f"Ordered recipes: {ordered}")
+
+    return ordered

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/autopkg_wrapper/utils/report_processor.py

@@ -53,7 +53,7 @@ def parse_text_file(path: str) -> Dict[str, List]:
 
     re_error = re.compile(r"ERROR[:\s-]+(.+)", re.IGNORECASE)
     re_upload = re.compile(
-        r"(Uploaded|Upload|Uploading)[^\n]*?(?P<name>[A-Za-z0-9 ._+\-]+)(?:[^\n]*?version[^\d]*(?P<version>\d+(?:\.\d+)+))?",
+        r"(Uploaded|Upload|Uploading)[^\n]*?(?P<name>[A-Za-z0-9 ._+\-]+?)(?=(?:\s+\bversion\b)|$)(?:[^\n]*?\bversion\b[^\d]*(?P<version>\d+(?:\.\d+)+))?",
         re.IGNORECASE,
     )
     re_policy = re.compile(r"Policy (created|updated):\s*(?P<name>.+)", re.IGNORECASE)

autopkg_wrapper-2026.2.5/mise.toml

@@ -0,0 +1,25 @@
+[tools]
+prek = "latest"
+python = "3.14"
+uv = "latest"
+
+[tasks.install]
+description = "Install/sync Python dependencies (uv)"
+run = "uv sync"
+
+[tasks.upgrade]
+description = "Upgrade all Python dependencies (updates uv.lock)"
+run = ["uv lock --upgrade", "uv sync"]
+
+[tasks.test]
+description = "Run unit tests"
+run = "uv run python -m unittest -v"
+
+[tasks.build]
+description = "Build sdist + wheel"
+run = """
+if [ -n "${RELEASE_VERSION:-}" ]; then
+	uv version "$RELEASE_VERSION"
+fi
+uv build
+"""

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "autopkg-wrapper"
-version = "2026.2.2"
+version = "2026.2.5"
 description = "A package used to execute some autopkg functions, primarily within the context of a GitHub Actions runner."
 readme = "README.md"
 requires-python = "~=3.14.0"

autopkg_wrapper-2026.2.5/tests/test_args_utils.py

@@ -0,0 +1,79 @@
+import os
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from autopkg_wrapper.utils import args as args_utils
+
+
+class TestArgsUtils(unittest.TestCase):
+    def test_validate_bool(self):
+        self.assertTrue(args_utils.validate_bool(True))
+        self.assertFalse(args_utils.validate_bool(False))
+
+        self.assertFalse(args_utils.validate_bool("0"))
+        self.assertFalse(args_utils.validate_bool("false"))
+        self.assertFalse(args_utils.validate_bool("No"))
+        self.assertFalse(args_utils.validate_bool("F"))
+
+        self.assertTrue(args_utils.validate_bool("1"))
+        self.assertTrue(args_utils.validate_bool("true"))
+        self.assertTrue(args_utils.validate_bool("YES"))
+        self.assertTrue(args_utils.validate_bool("t"))
+
+    def test_validate_file_and_directory(self):
+        with tempfile.TemporaryDirectory() as td:
+            # directory
+            self.assertEqual(
+                args_utils.validate_directory(td).as_posix(),
+                os.path.realpath(td),
+            )
+
+            # file
+            fp = os.path.join(td, "example.txt")
+            with open(fp, "w", encoding="utf-8") as f:
+                f.write("hi")
+            self.assertEqual(
+                args_utils.validate_file(fp).as_posix(),
+                os.path.realpath(fp),
+            )
+
+    def test_find_github_token_prefers_github_token(self):
+        with patch.dict(
+            os.environ, {"GITHUB_TOKEN": "aaa", "GH_TOKEN": "bbb"}, clear=True
+        ):
+            self.assertEqual(args_utils.find_github_token(), "aaa")
+
+    def test_find_github_token_falls_back_to_gh_token(self):
+        with patch.dict(os.environ, {"GH_TOKEN": "bbb"}, clear=True):
+            self.assertEqual(args_utils.find_github_token(), "bbb")
+
+    def test_setup_args_reads_processing_order_env_var(self):
+        # Note: argparse default comes through as a string when provided via env var.
+        with patch.dict(
+            os.environ,
+            {"AW_RECIPE_PROCESSING_ORDER": "upload,self_service"},
+            clear=True,
+        ):
+            with patch("sys.argv", ["autopkg_wrapper"]):
+                parsed = args_utils.setup_args()
+        self.assertEqual(parsed.recipe_processing_order, "upload,self_service")
+
+    def test_setup_args_reads_autopkg_bin_env_var(self):
+        with patch.dict(os.environ, {"AW_AUTOPKG_BIN": "/opt/bin/autopkg"}, clear=True):
+            with patch("sys.argv", ["autopkg_wrapper"]):
+                parsed = args_utils.setup_args()
+        self.assertEqual(parsed.autopkg_bin, "/opt/bin/autopkg")
+
+    def test_setup_args_cli_autopkg_bin_overrides_env_var(self):
+        with patch.dict(os.environ, {"AW_AUTOPKG_BIN": "/opt/bin/autopkg"}, clear=True):
+            with patch(
+                "sys.argv",
+                ["autopkg_wrapper", "--autopkg-bin", "/custom/autopkg"],
+            ):
+                parsed = args_utils.setup_args()
+        self.assertEqual(parsed.autopkg_bin, "/custom/autopkg")
+
+
+if __name__ == "__main__":
+    unittest.main()