autopkg-wrapper 2025.11.1__py3-none-any.whl

autopkg_wrapper/autopkg_wrapper.py

@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+import json
+import logging
+import plistlib
+import subprocess
+import sys
+from datetime import datetime
+from itertools import chain
+from pathlib import Path
+
+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
+
+
+class Recipe(object):
+    def __init__(self, name: str, post_processors: list = None):
+        self.filename = name
+        self.error = False
+        self.results = {}
+        self.updated = False
+        self.verified = None
+        self.pr_url = None
+        self.post_processors = post_processors
+
+        self._keys = None
+        self._has_run = False
+
+    @property
+    def name(self):
+        name = self.filename.split(".")[0]
+
+        return name
+
+    def verify_trust_info(self, args):
+        verbose_output = ["-vvvv"] if args.debug else None
+        prefs_file = (
+            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else None
+        )
+        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
+        )
+        (output, err) = p.communicate()
+        p_status = p.wait()
+        if p_status == 0:
+            self.verified = True
+        else:
+            err = err.decode()
+            self.results["message"] = err
+            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
+        )
+        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)}")
+
+        # Fail loudly if this exits 0
+        try:
+            subprocess.check_call(cmd, shell=True)
+        except subprocess.CalledProcessError as e:
+            logging.error(e.stderr)
+            raise e
+
+    def _parse_report(self, report):
+        with open(report, "rb") as f:
+            report_data = plistlib.load(f)
+
+        failed_items = report_data.get("failures", [])
+        imported_items = []
+        if report_data["summary_results"]:
+            # This means something happened
+            munki_results = report_data["summary_results"].get(
+                "munki_importer_summary_result", {}
+            )
+            imported_items.extend(munki_results.get("data_rows", []))
+
+        return {"imported": imported_items, "failed": failed_items}
+
+    def run(self, args):
+        if self.verified is False:
+            self.error = True
+            self.results["failed"] = True
+            self.results["imported"] = ""
+        else:
+            report_dir = Path("/tmp/autopkg")
+            report_time = datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
+            report_name = Path(f"{self.name}-{report_time}.plist")
+
+            report_dir.mkdir(parents=True, exist_ok=True)
+            report = report_dir / report_name
+            report.touch(exist_ok=True)
+
+            try:
+                prefs_file = (
+                    ["--prefs", args.autopkg_prefs.as_posix()]
+                    if args.autopkg_prefs
+                    else None
+                )
+                verbose_output = ["-vvvv"] if args.debug else None
+                post_processor_cmd = (
+                    list(
+                        chain.from_iterable(
+                            [
+                                ("--post", processor)
+                                for processor in self.post_processors
+                            ]
+                        )
+                    )
+                    if self.post_processors
+                    else None
+                )
+                cmd = [
+                    "/usr/local/bin/autopkg",
+                    "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)
+
+                logging.debug(f"cmd: {str(cmd)}")
+
+                subprocess.check_call(cmd, shell=True)
+
+            except subprocess.CalledProcessError:
+                self.error = True
+
+            self._has_run = True
+            self.results = self._parse_report(report)
+            if not self.results["failed"] and not self.error:
+                self.updated = True
+
+        return self.results
+
+
+def get_override_repo_info(args):
+    if args.overrides_repo_path:
+        recipe_override_dirs = args.overrides_repo_path
+
+    else:
+        logging.debug("Trying to determine overrides dir from default paths")
+
+        if args.autopkg_prefs:
+            autopkg_prefs_path = Path(args.autopkg_prefs).resolve()
+
+            if autopkg_prefs_path.suffix == ".json":
+                with open(autopkg_prefs_path, "r") as f:
+                    autopkg_prefs = json.load(f)
+            elif autopkg_prefs_path.suffix == ".plist":
+                autopkg_prefs = plistlib.loads(autopkg_prefs_path.read_bytes())
+        else:
+            user_home = Path.home()
+            autopkg_prefs_path = (
+                user_home / "Library/Preferences/com.github.autopkg.plist"
+            )
+
+            if autopkg_prefs_path.is_file():
+                autopkg_prefs = plistlib.loads(
+                    autopkg_prefs_path.resolve().read_bytes()
+                )
+
+        logging.debug(f"autopkg prefs path: {autopkg_prefs_path}")
+        logging.debug(f"autopkg prefs: {autopkg_prefs}")
+        recipe_override_dirs = Path(autopkg_prefs["RECIPE_OVERRIDE_DIRS"]).resolve()
+
+    if Path(recipe_override_dirs / ".git").is_dir():
+        override_repo_path = recipe_override_dirs
+    elif Path(recipe_override_dirs.parent / ".git").is_dir():
+        override_repo_path = recipe_override_dirs.parent
+
+    logging.debug(f"Override Repo Path: {override_repo_path}")
+
+    override_repo_git_work_tree = f"--work-tree={override_repo_path}"
+    override_repo_git_git_dir = f"--git-dir={override_repo_path / '.git'}"
+    override_repo_url, override_repo_remote_ref = git.get_repo_info(
+        override_repo_git_git_dir
+    )
+
+    git_info = {
+        "override_repo_path": override_repo_path,
+        "override_repo_url": override_repo_url,
+        "override_repo_remote_ref": override_repo_remote_ref,
+        "__work_tree": override_repo_git_work_tree,
+        "__git_dir": override_repo_git_git_dir,
+        "override_trust_branch": args.branch_name,
+        "github_token": args.github_token,
+        "create_pr": args.create_pr,
+    }
+
+    logging.debug(git_info)
+    return git_info
+
+
+def update_recipe_repo(recipe, git_info, disable_recipe_trust_check, args):
+    logging.debug(f"recipe.verified: {recipe.verified}")
+    logging.debug(f"disable_recipe_trust_check: {disable_recipe_trust_check}")
+
+    match recipe.verified:
+        case True:
+            logging.debug("Not updating repo as recipe has been verified")
+            return
+        case False | None if disable_recipe_trust_check:
+            logging.debug("Not updating repo as recipe verification has been disabled")
+            return
+        case False:
+            logging.debug("Updating repo as recipe verification failed")
+            current_branch = git.get_current_branch(git_info)
+
+            if args.disable_git_commands:
+                logging.info(
+                    "Not runing git commands as --disable-git-commands has been set"
+                )
+                return
+
+            if current_branch != git_info["override_trust_branch"]:
+                logging.debug(
+                    f"override_trust_branch: {git_info['override_trust_branch']}"
+                )
+                git.create_branch(git_info)
+
+            git.stage_recipe(git_info)
+            git.commit_recipe(
+                git_info, message=f"Updating Trust Info for {recipe.name}"
+            )
+            git.pull_branch(git_info)
+            git.push_branch(git_info)
+
+            return
+
+
+def parse_recipe_list(recipes, recipe_file, post_processors, args):
+    """Parsing list of recipes into a common format"""
+    recipe_list = None
+
+    logging.info(f"Recipes: {recipes}") if recipes else None
+    logging.info(f"Recipe List: {recipe_file}") if recipe_file else None
+
+    if recipe_file:
+        if recipe_file.suffix == ".json":
+            with open(recipe_file, "r") as f:
+                recipe_list = json.load(f)
+        elif recipe_file.suffix == ".txt":
+            with open(recipe_file, "r") as f:
+                recipe_list = f.read().splitlines()
+    if recipes:
+        if isinstance(recipes, list):
+            recipe_list = recipes
+        elif isinstance(recipes, str):
+            if recipes.find(",") != -1:
+                # Assuming recipes separated by commas
+                recipe_list = [
+                    recipe.strip() for recipe in recipes.split(",") if recipe
+                ]
+            else:
+                # Assuming recipes separated by space
+                recipe_list = [
+                    recipe.strip() for recipe in recipes.split(" ") if recipe
+                ]
+
+    if recipe_list is None:
+        logging.error(
+            """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"""
+        )
+        sys.exit(1)
+
+    logging.info(f"Processing the following recipes: {recipe_list}")
+    recipe_map = [Recipe(name, post_processors=post_processors) for name in recipe_list]
+
+    return recipe_map
+
+
+def parse_post_processors(post_processors):
+    """Parsing list of post_processors"""
+    logging.debug("Parsing post processors")
+
+    post_processors_list = None
+
+    match post_processors:
+        case None:
+            logging.debug("No post processors defined")
+        case []:
+            logging.debug("Found an empty list for post processors")
+        case list():
+            post_processors_list = post_processors
+        case str() if post_processors.find(",") != -1:
+            post_processors_list = [
+                post_processor.strip()
+                for post_processor in post_processors.split(",")
+                if post_processor.strip()
+            ]
+        case str():
+            post_processors_list = [
+                post_processor.strip()
+                for post_processor in post_processors.split(" ")
+                if post_processor.strip()
+            ]
+
+    logging.info(
+        f"Post Processors List: {post_processors_list}"
+    ) if post_processors_list else None
+
+    return post_processors_list
+
+
+def process_recipe(recipe, disable_recipe_trust_check, args):
+    if disable_recipe_trust_check:
+        logging.debug("Setting Recipe verification to None")
+        recipe.verified = None
+    else:
+        logging.debug("Checking Recipe verification")
+        recipe.verify_trust_info(args)
+
+    match recipe.verified:
+        case False | None if disable_recipe_trust_check:
+            logging.debug("Running Recipe without verification")
+            recipe.run(args)
+        case True:
+            logging.debug("Running Recipe after successful verification")
+            recipe.run(args)
+        case False:
+            recipe.update_trust_info(args)
+
+    return recipe
+
+
+def main():
+    args = setup_args()
+    setup_logger(args.debug if args.debug else False)
+    logging.info("Running autopkg_wrapper")
+
+    override_repo_info = get_override_repo_info(args)
+
+    post_processors_list = parse_post_processors(post_processors=args.post_processors)
+    recipe_list = parse_recipe_list(
+        recipes=args.recipes,
+        recipe_file=args.recipe_file,
+        post_processors=post_processors_list,
+        args=args,
+    )
+
+    failed_recipes = []
+
+    for recipe in recipe_list:
+        logging.info(f"Processing Recipe: {recipe.name}")
+        process_recipe(
+            recipe=recipe,
+            disable_recipe_trust_check=args.disable_recipe_trust_check,
+            args=args,
+        )
+        update_recipe_repo(
+            git_info=override_repo_info,
+            recipe=recipe,
+            disable_recipe_trust_check=args.disable_recipe_trust_check,
+            args=args,
+        )
+        slack.send_notification(
+            recipe=recipe, token=args.slack_token
+        ) if args.slack_token else None
+
+        if recipe.error or recipe.results.get("failed"):
+            failed_recipes.append(recipe)
+
+    recipe.pr_url = (
+        git.create_pull_request(git_info=override_repo_info, recipe=recipe)
+        if args.create_pr
+        else None
+    )
+
+    # Create GitHub issue for failed recipes
+    if args.create_issues and failed_recipes and args.github_token:
+        issue_url = git.create_issue_for_failed_recipes(
+            git_info=override_repo_info, failed_recipes=failed_recipes
+        )
+        logging.info(f"Created GitHub issue for failed recipes: {issue_url}")

autopkg_wrapper/notifier/slack.py

@@ -0,0 +1,61 @@
+import json
+import logging
+
+import requests
+
+
+def send_notification(recipe, token):
+    logging.debug("Skipping Slack notification as DEBUG is enabled!")
+
+    if token is None:
+        logging.error("Skipping Slack Notification as no SLACK_WEBHOOK_TOKEN defined!")
+        return
+
+    if recipe.verified is False:
+        task_title = f"{recipe.name} failed trust verification"
+        task_description = recipe.results["message"]
+    elif recipe.error:
+        task_title = f"Failed to import {recipe.name}"
+        if not recipe.results["failed"]:
+            task_description = "Unknown error"
+        else:
+            task_description = ("Error: {} \nTraceback: {} \n").format(
+                recipe.results["failed"][0]["message"],
+                recipe.results["failed"][0]["traceback"],
+            )
+
+            if "No releases found for repo" in task_description:
+                return
+    elif recipe.updated:
+        task_title = f"{recipe.name} has been uploaded to Jamf"
+        task_description = f"It's time to test {recipe.name}!"
+    else:
+        return
+
+    response = requests.post(
+        token,
+        data=json.dumps(
+            {
+                "attachments": [
+                    {
+                        "username": "Autopkg",
+                        "as_user": True,
+                        "title": task_title,
+                        "color": "warning"
+                        if not recipe.verified
+                        else "good"
+                        if not recipe.error
+                        else "danger",
+                        "text": task_description,
+                        "mrkdwn_in": ["text"],
+                    }
+                ]
+            }
+        ),
+        headers={"Content-Type": "application/json"},
+    )
+    if response.status_code != 200:
+        raise ValueError(
+            "Request to slack returned an error %s, the response is:\n%s"
+            % (response.status_code, response.text)
+        )

autopkg_wrapper/utils/args.py

@@ -0,0 +1,147 @@
+import argparse
+import os
+from datetime import datetime
+from pathlib import Path
+
+
+def validate_file(arg):
+    file_path = Path(arg).resolve()
+    file_exists = file_path.exists()
+
+    if file_exists:
+        return file_path
+    else:
+        message = f"Error! This is not valid file: {arg}"
+        raise argparse.ArgumentTypeError(message)
+
+
+def validate_directory(arg):
+    dir_path = Path(arg).resolve()
+    dir_exists = dir_path.is_dir()
+
+    if dir_exists:
+        return dir_path
+    else:
+        message = f"Error! This is not valid directory: {arg}"
+        raise argparse.ArgumentTypeError(message)
+
+
+def validate_bool(arg):
+    if isinstance(arg, bool):
+        return arg
+    elif isinstance(arg, str) and arg.lower() in ["0", "false", "no", "f"]:
+        return False
+    elif isinstance(arg, str) and arg.lower() in ["1", "true", "yes", "t"]:
+        return True
+
+
+def find_github_token():
+    if os.getenv("GITHUB_TOKEN", None):
+        return os.getenv("GITHUB_TOKEN")
+    elif os.getenv("GH_TOKEN", None):
+        return os.getenv("GH_TOKEN")
+    else:
+        return None
+
+
+def setup_args():
+    parser = argparse.ArgumentParser(description="Run autopkg recipes")
+    recipe_arguments = parser.add_mutually_exclusive_group()
+    recipe_arguments.add_argument(
+        "--recipe-file",
+        type=validate_file,
+        default=os.getenv("AW_RECIPE_FILE", None),
+        help="Provide the list of recipes to run via a JSON file for easier management.",
+    )
+    recipe_arguments.add_argument(
+        "--recipes",
+        nargs="*",
+        default=os.getenv("AW_RECIPES", None),
+        help="""
+            Recipes to run via CLI flag or environment variable. If the '--recipes' flag is used, simply
+            provide a space-separated list on the command line:
+                `autopkg-wrapper --recipes recipe_one.download recipe_two.download`
+            Alternatively, you can provide a space/comma-separated list in the 'AW_RECIPES' environment
+            variable:
+                `export AW_RECIPES="recipe_one.download recipe_two.download"`
+                `export AW_RECIPES="recipe_one.pkg,recipe_two.pkg"`
+                `autopkg-wrapper`
+            """,
+    )
+    parser.add_argument(
+        "--debug",
+        default=validate_bool(os.getenv("AW_DEBUG", False)),
+        action="store_true",
+        help="Enable debug logging when running script",
+    )
+    parser.add_argument(
+        "--disable-recipe-trust-check",
+        action="store_true",
+        help="""
+            If this option is used, recipe trust verification will not be run prior to a recipe run.
+            This does not set FAIL_RECIPES_WITHOUT_TRUST_INFO to No. You will need to set that outside
+            of this application.
+            """,
+    )
+    parser.add_argument(
+        "--disable-git-commands",
+        action="store_true",
+        help="""
+            If this option is used, git commands won't be run
+            """,
+    )
+    parser.add_argument(
+        "--slack-token",
+        default=os.getenv("SLACK_WEBHOOK_TOKEN", None),
+        help=argparse.SUPPRESS,
+    )
+    parser.add_argument("--github-token", default=find_github_token())
+    parser.add_argument(
+        "--branch-name",
+        default=os.getenv(
+            "AW_TRUST_BRANCH",
+            f"fix/update_trust_information/{datetime.now().strftime('%Y-%m-%dT%H-%M-%S')}",
+        ),
+        help="""
+            Branch name to be used recipe overrides have failed their trust verification and need to be updated.
+            By default, this will be in the format of \"fix/update_trust_information/YYYY-MM-DDTHH-MM-SS\"
+            """,
+    )
+    parser.add_argument(
+        "--create-pr",
+        default=os.getenv("AW_CREATE_PR", False),
+        action="store_true",
+        help="If enabled, autopkg_wrapper will open a PR for updated trust information",
+    )
+    parser.add_argument(
+        "--create-issues",
+        action="store_true",
+        help="Create a GitHub issue for recipes that fail during processing",
+    )
+    parser.add_argument(
+        "--overrides-repo-path",
+        default=os.getenv("AW_OVERRIDES_REPO_PATH", None),
+        type=validate_directory,
+        help="""
+        The path on disk to the git repository containing the autopkg overrides directory.
+        If none is provided, we will try to determine it for you.
+        """,
+    )
+    parser.add_argument(
+        "--post-processors",
+        default=os.getenv("AW_POST_PROCESSORS", None),
+        nargs="*",
+        help="""
+        One or more autopkg post processors to run after each recipe execution
+        """,
+    )
+    parser.add_argument(
+        "--autopkg-prefs",
+        default=os.getenv("AW_AUTOPKG_PREFS_FILE", None),
+        type=validate_file,
+        help="""
+        Path to the autopkg preferences you'd like to use
+        """,
+    )
+
+    return parser.parse_args()

autopkg_wrapper/utils/git_functions.py

@@ -0,0 +1,160 @@
+import logging
+import subprocess
+from datetime import datetime
+
+from github import Github
+
+# git_info = {
+#         "override_repo_path": override_repo_path,
+#         "override_repo_url": override_repo_url,
+#         "override_repo_remote_ref": override_repo_remote_ref,
+#         "__work_tree": override_repo_git_work_tree,
+#         "__git_dir": override_repo_git_git_dir,
+#         "override_trust_branch": args.branch_name,
+#         "github_token": args.github_token,
+#         "create_pr": args.create_pr,
+#     }
+
+
+def git_run(*args):
+    return subprocess.run(["git"] + list(args), text=True, capture_output=True)
+
+
+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_repo_ref = repo_url.split("https://github.com/")[1]
+
+    logging.debug(f"Repo URL: {repo_url}")
+    logging.debug(f"Remote Repo Ref: {remote_repo_ref}")
+    return repo_url, remote_repo_ref
+
+
+def get_current_branch(git_info):
+    current_branch = git_run(git_info["__git_dir"], "rev-parse", "--abbrev-ref", "HEAD")
+    current_branch = current_branch.stdout.strip()
+
+    logging.debug(f"Current Branch: {current_branch}")
+    return current_branch
+
+
+def create_branch(git_info):
+    new_branch = git_run(
+        git_info["__git_dir"], "checkout", "-b", git_info["override_trust_branch"]
+    )
+
+    logging.debug(f"Git Branch: {new_branch}")
+    return new_branch
+
+
+def stage_recipe(git_info):
+    add = git_run(git_info["__git_dir"], git_info["__work_tree"], "add", "-u")
+
+    logging.debug(f"Git Add: {add}")
+    return add
+
+
+def commit_recipe(git_info, message):
+    commit = git_run(
+        git_info["__git_dir"], git_info["__work_tree"], "commit", "-m", message
+    )
+
+    logging.debug(f"Git Commit: {commit}")
+    return commit
+
+
+def pull_branch(git_info):
+    pull = git_run(
+        git_info["__git_dir"],
+        git_info["__work_tree"],
+        "pull",
+        "--rebase",
+        "origin",
+        git_info["override_trust_branch"],
+    )
+
+    logging.debug(f"Git Branch: {pull}")
+    return pull
+
+
+def push_branch(git_info):
+    push = git_run(
+        git_info["__git_dir"],
+        git_info["__work_tree"],
+        "push",
+        "-u",
+        "origin",
+        git_info["override_trust_branch"],
+    )
+
+    logging.debug(f"Git Push: {push}")
+    return push
+
+
+def create_pull_request(git_info, recipe):
+    title = f"Update Trust Information: {recipe.name}"
+    body = f"""
+Recipe Verification information is out-of-date for {recipe.name}.
+Please review and merge the updated trust information for this override.
+    """
+
+    g = Github(git_info["github_token"])
+    repo = g.get_repo(git_info["override_repo_remote_ref"])
+    pr = repo.create_pull(
+        title=title, body=body, head=git_info["override_trust_branch"], base="main"
+    )
+    pr_url = f"{git_info['override_repo_url']}/pull/{pr.number}"
+
+    logging.debug(f"PR URL: {pr_url}")
+    return pr_url
+
+
+def create_issue_for_failed_recipes(git_info, failed_recipes):
+    """
+    Creates a GitHub issue listing all recipes that failed during the run.
+
+    Args:
+        git_info (dict): Dictionary containing Git repository information
+        failed_recipes (list): List of Recipe objects that failed during processing
+
+    Returns:
+        str: URL of the created GitHub issue, or None if no issue was created
+    """
+
+    if not failed_recipes:
+        logging.debug("No failed recipes to report")
+        return None
+
+    g = Github(git_info["github_token"])
+    repo = g.get_repo(git_info["override_repo_remote_ref"])
+
+    # Create issue title and body
+    current_date = datetime.now().strftime("%Y-%m-%d")
+    title = f"AutoPkg Recipe Failures - {current_date}"
+
+    body = "## Recipe Failure Details:\n\n"
+    for recipe in failed_recipes:
+        body += f"#### {recipe.name}\n"
+
+        if recipe.results.get("failed"):
+            for failure in recipe.results.get("failed", []):
+                body += f"- {failure.get('message', 'Unknown error')}\n"
+
+        body += "\n"
+
+    body += "\nThis issue was automatically generated by autopkg-wrapper."
+
+    # Create the issue
+    issue = repo.create_issue(
+        title=title,
+        body=body,
+        labels=["autopkg-failure"],
+    )
+
+    issue_url = f"{git_info['override_repo_url']}/issues/{issue.number}"
+    logging.debug(f"Issue URL: {issue_url}")
+
+    return issue_url

autopkg_wrapper/utils/logging.py

@@ -0,0 +1,12 @@
+import logging
+
+
+def setup_logger(debug=False):
+    log_level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=log_level,
+        format="%(filename)s - %(funcName)s - %(levelname)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    logging.debug("Debug logging is now enabled")

autopkg_wrapper-2025.11.1.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: autopkg-wrapper
+Version: 2025.11.1
+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>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: ~=3.12.0
+Requires-Dist: chardet
+Requires-Dist: idna
+Requires-Dist: pygithub
+Requires-Dist: requests
+Requires-Dist: ruamel-yaml
+Requires-Dist: toml
+Requires-Dist: urllib3
+Description-Content-Type: text/markdown
+
+# autopkg-wrapper
+
+`autopkg_wrapper` is a small package that can be used to run [`autopkg`](https://github.com/autopkg/autopkg) within CI/CD environments such as GitHub Actions.
+
+The easiest way to run it is by installing with pip.
+
+```shell
+pip install autopkg-wrapper
+```
+
+## Command Line Parameters
+
+```shell
+-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)
+--debug                         Enable debug logging when running script
+--override-trust                If set recipe override trust verification will be disabled. (Default: True)
+--github-token GITHUB_TOKEN     A token used to publish a PR to your GitHub repo if overrides require their trust to be updated
+--branch-name BRANCH_NAME       Branch name to be used where recipe overrides have failed their trust verification and need to be updated.
+                                By default, this will be in the format of "fix/update_trust_information/YYYY-MM-DDTHH-MM-SS"
+--create-pr                     If enabled, autopkg_wrapper will open a PR for updated trust information
+--autopkg-prefs AW_AUTOPKG_PREFS_FILE
+                                Path to the autopkg preferences you'd like to use
+--autopkg-overrides-repo-path AUTOPKG_OVERRIDES_REPO_PATH
+                                The path on disk to the git repository containing the autopkg overrides directory. If none is provided, we will try to determine it for you.
+```
+
+## Example
+
+An example folder structure and GitHub Actions Workflow is available within the [`actions-demo`](actions-demo)
+
+## Credits
+
+- [`autopkg_tools` from Facebook](https://github.com/facebook/IT-CPE/tree/main/legacy/autopkg_tools)
+- [`autopkg_tools` from Facebook, modified by Gusto](https://github.com/Gusto/it-cpe-opensource/tree/main/autopkg)

autopkg_wrapper-2025.11.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+autopkg_wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autopkg_wrapper/autopkg_wrapper.py,sha256=dF8BGhk1IpP4w6lRtJqgpY-VK9vkoOiD0jidIUaSn9M,13457
+autopkg_wrapper/notifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autopkg_wrapper/notifier/slack.py,sha256=aPxQDGd5zPxSsu3mEqalNOF0ly0QnYog0ieHokd5-OY,1979
+autopkg_wrapper/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autopkg_wrapper/utils/args.py,sha256=6sghB9DWZmv7VLUR9uJA5WkhxsZ08Ri1qoUY5rxydjY,4883
+autopkg_wrapper/utils/git_functions.py,sha256=Ojsq-wQsw7Gezq9pYDTtXF9SxrK9b9Cfap3mbJyVgdw,4456
+autopkg_wrapper/utils/logging.py,sha256=3knpMViO_zAU8WM5bSImQaz5M01vMFk_raB4lt1cbvo,324
+autopkg_wrapper-2025.11.1.dist-info/METADATA,sha256=qWyqCoaK3d4ttaNwIEFRrYeqQE1BKznnOP8twLpUJYc,2528
+autopkg_wrapper-2025.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+autopkg_wrapper-2025.11.1.dist-info/entry_points.txt,sha256=TVIcOt7OozzX1c00pwMGbBysaHg_v_N3mO3juoFqPpo,73
+autopkg_wrapper-2025.11.1.dist-info/licenses/LICENSE,sha256=PpNOQjZGcsKFuA0wU16YU7PueVxqPX4OnyZ7TlLQlq4,1602
+autopkg_wrapper-2025.11.1.dist-info/RECORD,,

autopkg_wrapper-2025.11.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

autopkg_wrapper-2025.11.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+autopkg_wrapper = autopkg_wrapper.autopkg_wrapper:main

autopkg_wrapper-2025.11.1.dist-info/licenses/LICENSE

@@ -0,0 +1,31 @@
+BSD-3-Clause
+
+Copyright (c) Facebook, Inc. and its affiliates.
+Copyright (c) tig <https://6fx.eu/>.
+Copyright (c) Gusto, Inc.
+Copyright (c) 2024, James Smith
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.