The 60-requests-an-hour wall: caching Mac build apps on a Jamf distribution point
In a campus Jamf Pro environment, every enrolling Mac shared one public IP address, and that address ran out of GitHub API calls. New Macs failed part-way through their build. I fixed it by downloading each app once, on a local server, instead of on every Mac. The tool is called jamf-dp-sync, and this is what it does and where it stops.
The setup, and what went wrong #
Macs enrol with Jamf Pro. A tool called Jamf Setup Manager runs on first boot and walks through a list of actions. In that environment, seven of those actions installed apps with Installomator, the popular open-source script that downloads the latest version of an app straight from the vendor at install time: Nudge, swiftDialog, Adobe Acrobat Pro, Microsoft 365, Google Chrome, Zoom and Google Drive.
Two things went wrong.
The GitHub limit. Some Installomator labels, Nudge Suite and swiftDialog among them, ask the GitHub API which release is the latest. GitHub allows anonymous callers 60 requests per hour per public IP address. Behind a campus NAT, every enrolling Mac sits behind the same address, so all of them share those 60 requests. When several Macs were built at once, the GitHub-backed labels started failing part-way through.
The repeat downloads. Every Mac downloaded every installer from the internet, on every build. Microsoft 365 is nearly 3 GB and Acrobat about 1.7 GB, per Mac.
Installomator did nothing wrong here. Downloading the latest version at install time is the right design for most fleets, and the rate limit is GitHub’s. It bites when many Macs share one address and build at once. jamf-dp-sync is meant to complement Installomator, not replace it. The README tells the same story under Why it exists (opens in a new tab).
The idea #
The environment already had a Jamf file share distribution point (DP) on a server: a file share that Macs on the local network download packages from. If something on that server kept the build apps current, the Macs could install them over the LAN, with no GitHub call and no internet download during the build.
So that is what jamf-dp-sync does. It is a small unattended agent that runs from cron on the DP server, written in Python 3.6 or later with only the standard library, so there are no third-party Python packages to install or keep patched. It runs as an ordinary service user; only the one-off setup needs an administrator.
What it does each night #
For each app you list, the agent does this:
- Finds the target version. It reads the app’s Jamf Patch Management title. Apps with no title use the latest GitHub release. A
pinin the config overrides both, which is how you roll back. - Checks the Jamf policy. It reads the version the install policy already holds, from the package’s file name. If every policy already holds the target, it stops: no download, no writes.
- Looks for a copy it already made. If a package it made for that version is still on the DP (a pinned rollback, or a crash halfway), it skips straight to the Jamf steps.
- Finds the download. One of four small resolvers does this: a GitHub release asset, a URL template with the version in it, a “latest” link that redirects, or Adobe’s own update manifest. If the vendor isn’t serving the new version yet, it skips the app and only alerts after three days.
- Downloads into a private staging folder on the same disk as the DP. A pkg inside a DMG is pulled out with 7-Zip, without mounting anything.
- Verifies it (more on that below).
- Publishes the file into the DP’s
Packages/folder in one atomic step that never overwrites anything. - Records it in Jamf: a package record with the file’s SHA-512 and a marker in its notes saying the agent made it.
- Swaps the new package into each policy, changing only that one entry, then attaches it to its version in the patch title.
- Prunes older copies the agent made, keeping the current one plus one for rollback, and posts one summary to a chat webhook.
The order of the writes is fixed: file on disk, then package record, then policy, then patch title. A record is never created for a file that isn’t there. Any failed verification check stops that app before the DP or Jamf is touched, and the other apps carry on.
Most nights nothing has changed, and the run ends in about a second with no message. On Mondays it posts a “still alive” heartbeat, which tells a quiet night from a stopped agent.
What it checks before it publishes #
Nothing reaches Packages/ unless every check passes, in this order:
- The size equals what the vendor published, when the vendor publishes one.
- The SHA-256 equals the vendor’s digest, when the vendor publishes one (GitHub release assets and Adobe’s manifest do).
- The file is a real flat pkg: the xar header and table of contents parse, and the table-of-contents checksum matches.
- The signing certificate in the pkg is a “Developer ID Installer” certificate for the expected Apple Team ID, read with
openssl. - The version inside the pkg matches the target. For “latest” downloads, a newer pkg is accepted and named by its own version; an older one means the vendor’s CDN is stale, so the app is skipped.
Chrome showed why the last rule matters. On 9 November, Jamf’s catalogue listed 158.0.8127.18 while Google’s stable enterprise pkg was still 157. The agent skipped Chrome, correctly; overnight the catalogue moved back to 157.0.8103.51.
Its limits, as plainly as the README puts them #
- The signature check is not cryptographic. Check 4 reads the certificate’s fields. It does not verify the signature or the chain to Apple’s root the way
pkgutil --check-signaturedoes on a Mac, so a forged self-signed certificate with the same fields would pass. Authenticity comes from HTTPS to the vendor’s own host, plus the vendor’s SHA-256 and size where the source publishes them. For sources that publish no hash, it rests on HTTPS alone. macOS still checks the real signature when a Mac installs the pkg. - Policy edits are last-writer-wins. Jamf’s Classic API has no conditional update, and it replaces a policy’s whole package list on every write. The agent re-reads the policy just before writing and reads it back just after, and warns in the summary if the list changed. An admin edit made in the instant between that re-read and the write can still be lost, so schedule runs for a quiet hour.
- Signed vendor pkgs only. It publishes a pkg the vendor built and signed, directly or inside a DMG. It never repackages an
.appbundle. - Some disk images can’t be opened on Linux. 7-Zip can’t read every APFS image. Google Drive’s DMG is one of them: 7-Zip reports “Unsupported feature”. A dry run that reaches the download will show you.
- Local DP only. The packages exist only on the local file share distribution point. A Mac whose network segment points at the cloud distribution point won’t find them. It is a cache for on-site builds.
- Monitor mode is not finished. Entries for hand-uploaded apps are validated, but the agent doesn’t alert on them yet.
Jamf Cloud is expected to work, since the agent only talks HTTPS to Jamf’s APIs, but I haven’t tested it. Reports are welcome.
Does it work? #
For the apps it handles, the GitHub rate-limit failures are gone, and each installer crosses the internet once per version instead of once per Mac.
How much faster are builds? I haven’t measured. After watching the first installs, my verdict was that downloads were “soooooo much faster”, but there are no timed before-and-after builds, and I won’t put a number on it that I don’t have. Timing one build each way would give a real figure; I haven’t done it yet.
In a test VM, real vendor downloads took 6 seconds for Nudge, 8 for swiftDialog, 37 for Zoom, 221 for Acrobat (1.71 GB) and 398 for Office (2.93 GB). I did not time the full four-app run on the real DP server.
How to try it #
The code is at github.com/kamaltaynaz/jamf-dp-sync (opens in a new tab), release 1.0.0. It is MIT licensed. You need:
- a Linux server that hosts a Jamf file share distribution point, with Python 3.6 or later and
openssl; I tested on a Linux VM, and any current distribution should do; - a service user with write access to the
Packages/folder, and a staging folder on the same filesystem; - a Jamf Pro API client with a small role, and a Jamf policy for each app, which your enrolment workflow calls;
- optionally the official 7-Zip for Linux, only if an app ships its pkg inside a DMG.
Then describe your apps in a packages.json. If you already use Installomator, label-import drafts the entries from its labels; it reads the label’s text and never runs it. It is deliberately strict: it drafts a label only if it is made entirely of plain name=value lines and comments. Against the 1,161 labels in a current Installomator at the time of writing, November 2026, that gives 175 drafts; 770 are app bundles, which the agent never repackages.
Check and try it as the service user:
python3 /opt/jamf-dp-sync/jamf_dp_sync.py check-config
python3 /opt/jamf-dp-sync/jamf_dp_sync.py notify-test
python3 /opt/jamf-dp-sync/jamf_dp_sync.py run --dry-run
python3 /opt/jamf-dp-sync/jamf_dp_sync.py runAdd a daily cron line, then point your enrolment workflow at the policies. The install guide in the repository walks through each step.
If you need broad app coverage, repackaging or ongoing patching, AutoPkg or Munki do far more. This does one narrow job.
Credits #
I designed it. Claude Code, from Anthropic, built it. Codex, from OpenAI, reviewed it, and the other post in this pair tells that story. The tool leans on Installomator (opens in a new tab), whose labels record the vendor download sources and Team IDs, and on Jamf Setup Manager (opens in a new tab). Thank you to both. The test VM ran under Lima, the Linux VM tool for macOS, which deserves a write-up of its own for Mac admins.