WonderPhi Host -- Batch Recipes for Website Hosting Operations
24 recipes for hosting at scale. Backup 12 sites in parallel; renew Lets Encrypt across a fleet; scan for broken links; audit DNS TXT records. nginx, Apache, TLS, backups, deploys, logs, DNS, SEO. Requires WonderPhi Compute.
© CRI-ONE. All rights reserved. Patents issued and pending. Unauthorized reproduction of the underlying designs is prohibited.
Extended catalog & full narrative — WonderPhi Host -- Batch Recipes for Website Hosting Operations
The extended dossier appended from the 2026-08-05 catalog snapshot. Prices in the body copy have been stripped; the live-store price on this page is the authoritative figure. Images have been omitted.
Easy Setup — No Package Manager, No Account, No Cloud
Single Python file. Python 3.8+ standard library only — nothing to pip install. Run with:
python wph-recipe.py
Sample plan files ship with the download and run out of the box. Pair with WonderPhi Compute to execute the generated plans in parallel.
WonderPhi Host — 24 batch recipes for website hosting operations
Twenty-four recipes for the daily ops of running websites: nginx test/reload, TLS certificate lifecycle, backup + rsync, log operations, deploys, HTTP audits, DNS checks, SEO pings. Point at a domain list, get a parallel plan.
Why this exists
If you run more than one website, you do the same operations over and over: renew certs, check TLS expiry, sanity-test nginx config after every change, back up the docroot, tail today's 404s, verify DNS. Every one of these is a shell one-liner. Running them all serially, per domain, is where a Sunday disappears.
These recipes wrap each operation so you can point at a domain list and fan out. Parallel curl checks on 500 domains in 17 seconds. TLS expiry audit across the whole fleet in one plan file.
What it is, in plain English
Give a recipe a list of domains (one per line). It emits a plan — one shell command per domain, using the tool for the job (certbot, openssl, curl, nslookup, rsync). Compute runs everything in parallel. You get per-domain results in a log file, filed by hostname.
How you use it — three steps
- Run the recipe file.
python wph-recipe.pyin the folder that contains your input files, or wherever you want the plan written. - Point at the target. The recipe asks (or reads from a text file) what the input is — a folder, a list of hostnames, a CSV, whatever the recipe expects. It writes a plan file: one shell command per line.
- Hand the plan to Compute. Drop the generated
plan.wpc.txtinto the WonderPhi Compute inbox, and every command runs in parallel across your cores. Read the honest log when it's done.
Worked examples — three of the 24 recipes in this library
http-status-all — every domain, HEAD check + status code
In under a minute you know which of your 300 sites are up, redirecting, throwing 500s, or timing out.
python wph-recipe.py http-status --domains sites.txt --output status.tsv
# emitted plan:
# curl -sI -o /dev/null -w '%{http_code}\t%{time_total}\n' https://alpha.example.com >> status.tsv
# curl -sI -o /dev/null -w '%{http_code}\t%{time_total}\n' https://beta.example.com >> status.tsv
tls-days-until-expiry — audit certs across your fleet
Recipe hits each domain's :443, parses the cert, prints days-until-expiry. Sort output and see everything expiring in the next 30 days.
python wph-recipe.py tls-days --domains domains.txt --output tls-audit.tsv
nginx-reload-fleet — safely reload nginx across every web node
Each plan-line does test-config first, then reload. If test-config fails, the reload is skipped for that host.
python wph-recipe.py nginx-reload --hosts web-nodes.txt
Verified capabilities
Recipes run against your live domains from a single operator workstation:
- 24 operations covered: nginx (test/reload/graceful), Apache (graceful-reload), TLS (certbot-renew, days-until-expiry, SHA-256 fingerprint), backup (docroot-tar, mysqldump, rsync-pull), logs (force-logrotate, top-URLs, today's 404s), deploy (rsync-deploy, CDN cachebust, php-fpm reload), HTTP audit (HEAD check, status code, timing, broken-links scan), DNS (A / MX / TXT records for SPF/DKIM/DMARC), SEO (sitemap ping, feed fetch).
- 500 domain health checks in 17.1 seconds (would take >30 minutes serially).
- Every operation has read-only variants where it makes sense. You can audit without touching production.
Every claim is testable on your own machine using the sample plans in the download.
Under the hood — the honest technical picture
Every recipe emits shell commands that call the standard operator tools: curl, openssl, nslookup, rsync, certbot, tar, mysqldump, nginx, apachectl. The recipe never re-implements these; it delegates. That means every command it emits is one you already trust.
- Uses standard operator tools. Nothing to install on the workstation beyond what a sysadmin already has.
- Read-only where possible. Audit recipes never change server state. Destructive recipes (reload, deploy) name themselves.
- Per-domain isolation. A DNS lookup failure for one domain doesn't stop the other 499.
- Recipes emit deterministic output — TSV / CSV files that pipe cleanly into whatever monitoring or reporting you already use.
- No agent on your web servers. Everything runs over SSH or is a local
curlfrom your workstation.
How it compares to the manual way
| Aspect | The typical alternative | This product |
|---|---|---|
| Cert expiry audit | Log into each web server, run openssl by hand | One recipe, all domains, TSV output in seconds |
| Bulk 404 report | SSH + grep, one host at a time | Fan-out log grep, aggregated output |
| Fleet nginx reload | Ansible playbook, or hand-scripted for-loop | One recipe, includes test-first-then-reload safety |
| Cost | Your Sunday | One plan-file, ~30 seconds |
What you need
- Windows / macOS / Linux as the operator's workstation.
- The tools each recipe wraps:
openssh,curl,openssl,rsync,nslookup. All standard on Linux/macOS; on Windows they ship with recent 10/11. - Python 3.8+ to generate the plan. Standard library only.
- WonderPhi Compute to run the plan in parallel.
What's in the download
wph-recipe.py— the recipe generator (Python 3.8+, standard library only)README.md— per-recipe reference for humansINDEX.md— alphabetical list of every recipe with a one-line descriptionsamples/— ready-to-run demo input files for every recipeLICENSE.txt— perpetual single-user license, personalized with your name and order number at delivery
Common questions
Q. Does it need agents on my web servers?
No. Recipes use SSH or straight-up curl from your workstation. Your servers don't know WonderPhi exists.
Q. Does it work with any web server, or only nginx?
The nginx-specific recipes only work on nginx (they call nginx -t and nginx -s reload). Apache has its own recipe (apache-graceful). The audit recipes (TLS, HTTP status, DNS) work against any web server.
Q. Can it renew Let's Encrypt certificates?
Yes — the certbot-renew recipe fans out certbot renew --quiet across the hosts you list. You still need certbot installed on each host; the recipe just orchestrates.
Q. Does it modify DNS records?
No. The DNS recipes are read-only — they check A, MX, TXT records so you can audit SPF/DKIM/DMARC across your domains. Modifying DNS is a separate concern (usually a registrar UI or Terraform).
Glossary — every term used above, in plain English
- Recipe
- One of the ready-made plan-file templates in this library. Each recipe knows how to do one job across many inputs.
- Plan file (
*.wpc.txt) - A plain text file with one shell command per line that WonderPhi Compute reads and executes across every CPU core in parallel.
- WonderPhi Compute
- The parallel runtime this recipe library is designed for. Sold separately, or bundled in the Complete Bundle.
- Shell command
- Any line you'd normally type into a terminal / Command Prompt / PowerShell prompt.
- Standard library only
- The recipe uses only what ships with Python 3.8+ — no
pip install, no external packages. - Perpetual license
- Buy once, use forever. No renewals, no expiration, no update check.
- nginx
- The most popular open-source web server. Runs the majority of the top million sites.
- TLS certificate
- The cryptographic certificate that lets a browser show the padlock icon. Expires every 90 days for Let's Encrypt.
- SPF / DKIM / DMARC
- Three DNS
TXT-record standards that prove your outbound email is legitimate. Missing any = your mail lands in spam. - Docroot
- The directory on the server where the website's files live.
- Fan-out
- Running the same operation against a list of targets in parallel.
License & support
Retail single-user license, perpetual, non-transferable. Every download's LICENSE.txt is personalized at checkout with your name, email, and order number. Full terms live inside your download — short version: install on any machine you personally own and operate, don't redistribute, don't run it as a paid service for third parties (that needs the Industrial variant), and everything else is fine.
Support: email chris@cri-one.com. Because WonderPhi Host — 24 batch recipes for website hosting operations never changes, there's nothing to "support" in the update sense — but if something isn't behaving the way you expect, write and I'll help.
USA-only sales for retail.
a0819454e71e0d11851e0aa9d0eca3cd866d332d431e906da9b4b5bebe7f5212
WonderPhi Host -- Batch Recipes for Website Hosting Operations
Publicly online since 2010 · U.S. patent applications since 2012 · inventions offered since 2014. The work of Christopher Gabriel Brown, independently documented.


