Automate SVG Optimisation in Your CI/CD Pipeline

GitHub Actions: SVGO CLI on changed files

Pure-OSS path. Minify only the SVGs changed in the PR, then fail if anything wasn't already optimised.

name: svg-optimize
on: pull_request
jobs:
  svgo:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with: { fetch-depth: 0 }
      - uses: actions/setup-node@v4
        with: { node-version: 20 }
      - run: npm i -D svgo
      - name: Minify changed SVGs
        run: |
          git diff --name-only origin/${{ github.base_ref }}... -- '*.svg' \
            | xargs -r npx svgo --multipass
      - name: Fail if assets were not pre-optimized
        run: git diff --exit-code -- '*.svg'

JAD runner: submit one SVG via curl

Runner path. Probe health, then POST the file to the /v1/tools run endpoint. No options field is sent because the minifier has none.

# 1) confirm the local runner is up
curl -fsS http://127.0.0.1:9789/v1/health

# 2) minify a file (files stay on this machine)
curl -fsS -X POST \
  http://127.0.0.1:9789/v1/tools/svg-pro-minifier/run \
  -F 'file=@assets/logo.svg'

# response includes outputPath, sizeBytes, and metrics
# (Size reduction / Original / Minified)

Read the schema before running

Confirm the tool is runner-backed and has no options, so your payload builder stays correct even if the tool evolves.

$ curl -fsS https://jadapps.com/api/v1/tools/svg-pro-minifier | jq '{slug, options, execution}'
{
  "slug": "svg-pro-minifier",
  "options": [],            # nothing to configure
  "execution": {
    "runnerBacked": true,
    "runnerMode": "engine" # runs in-process locally
  }
}

Pre-commit hook (husky) to keep diffs clean

Run the minifier locally before each commit so optimised, byte-stable assets land in history. Idempotence means a clean file re-stages with no change.

# .husky/pre-commit
staged=$(git diff --cached --name-only -- '*.svg')
[ -z "$staged" ] && exit 0
for f in $staged; do
  curl -fsS -X POST http://127.0.0.1:9789/v1/tools/svg-pro-minifier/run \
    -F "file=@$f" -o "$f.min"
  mv "$f.min" "$f"
  git add "$f"
done

Two-stage pipeline: minify then size-budget gate

Combine the safe minify pass with a gzip budget check. Estimator output gives the real wire size to assert against.

# stage 1: safe minify (no options)
curl -fsS -X POST $RUNNER/v1/tools/svg-pro-minifier/run \
  -F 'file=@icons/cart.svg' -o cart.min.svg

# stage 2: gzip budget gate
gzip=$(curl -fsS -X POST $RUNNER/v1/tools/svg-compression-estimator/run \
  -F 'file=@cart.min.svg' | grep -oE 'Gzip:[^—]+')
echo "$gzip"
# parse bytes and: [ bytes -lt 1024 ] || { echo 'over budget'; exit 1; }

If the @jadapps/runner isn't started/paired on the agent, GET /v1/health returns connection refused. Add a step to launch and health-check the runner before submitting jobs, or fall back to the SVGO CLI path. The default port is 9789 (legacy 49217); set NEXT_PUBLIC_RUNNER_URL if you bound a custom port.

The minifier validates options against an empty schema. Sending unexpected option keys is invalid — keep the payload to just the file. If you need rounding or simplification, that's a separate tool/step, not an option on this one.

Per-run limits apply (free 5 MB, Pro 50 MB, higher 2 GB). A huge SVG almost always means an embedded base64 raster — minify can't shrink raster bytes. Re-export as true vector, or handle that asset outside the SVG pipeline.

The clean-diff pattern fails the build when an asset wasn't pre-optimised. That's the goal. If it fails unexpectedly on an already-minified file, your local tool version differs from CI — pin the same engine/SVGO version so output is identical.

You can run JAD's safe minify and SVGO's aggressive plugins, but pick one as the canonical formatter to avoid back-and-forth churn. A common split: JAD/SVGO for the committed safe form, plus a separate review step for any geometry-altering SVGO plugins.

An auto-commit-back step can retrigger the workflow. Guard it (skip when the actor is the bot, or use [skip ci] in the commit message) so you don't loop. Idempotence helps: once assets are minified, the bot's commit is empty and the loop stops.

If a committed file isn't well-formed SVG, the runner/CLI errors on it. Add a parse/validate step (or rely on the tool's Invalid SVG rejection) and surface the filename so the author can fix the malformed source.

Unlike an aggressive SVGO config with removeViewBox enabled, the JAD minifier never strips the viewBox — so responsive icons keep scaling. If you also run SVGO in the pipeline, ensure removeViewBox stays off in your config.