Make Targets

Every target of the repository’s Makefile that carries a documentation comment, with the description and parameters declared beside it. Generated by the documentation build; edit the Makefile rather than this page.

make act-debug

Undocumented.

param:

node=<container_name> cmd=’<shell pipeline>’

make act-runner-image

Build local/act-runner-fixed: the stock act runner image with /var/run removed so a recent Docker engine accepts act’s job-setup content copy.

usage:

ACT_PLATFORM_IMAGE=local/act-runner-fixed:latest make swarm-zombie app=<app>

note:

see docs/agents/action/iteration/workflow.md.

make act-workflow

Run the act-based workflow deploy check.

make alias

Print the portable agent shortcuts and the operator’s terminal aliases.

make autoformat

Auto-format all source files (skips tools that are not installed).

make autoformat-restage

Autoformat, then re-stage files it rewrote that were already staged – only when no unstaged changes were present beforehand.

make binfmt

Make an architecture executable here through emulation.

param arch:

amd64 | arm64 (default: the platform in INFINITO_DOCKER_PLATFORM)

make bond

Serve the role bond matrix, where editing a cell rewrites the role’s bond.

make bootstrap

Install dependencies and prepare the project.

make build

Build the local image.

make build-cleanup

Clean up image artifacts.

make build-dependency

Pull the build dependency image.

make build-missing

Build the local image if it is missing.

make build-no-cache

Build the local image without cache.

make build-no-cache-all

Build the no-cache image for every distro.

make cache-apply

Install this checkout’s cache declarations into the running cache stack.

note:

creates the Nexus proxy repos, issues the frontend certs, installs the upstream map the frontend mounts and reloads it.

note:

`make compose-up` runs it for a checkout that shares another one’s cache stack; call it directly after changing a `cache:` declaration.

make cheat

Print the operator prompt cheatsheet from docs/contributing/tools/agents/cheatsheet.md.

make clean

Remove ignored files from the working tree.

note:

falls back to sudo for container-owned __pycache__/*.pyc; warns and continues if both fail.

make clean-cache

Wipe on-disk caches under /var/cache/infinito/core/cache/.

note:

stops cache containers first; re-run `make compose-up` to recreate them.

make clean-container-owned

Remove container-owned generated artefacts (build/).

note:

these files are created inside the compose container with the in-container UID (typically `nobody`); the host cannot rm them directly.

note:

the helper auto-starts a stopped infinito container before deleting; safe no-op when the targets do not exist.

make clean-pycache-dirs

Remove tracked directories whose only child is a __pycache__ folder.

note:

catches orphans left after moving or deleting source files.

make clean-stale-nfs

Recover stale in-namespace NFS mounts from wedged act-swarm nfs-server containers.

usage:

make clean-stale-nfs [cid=<container-id-or-name>] [mount=/mnt/gtest]

make clean-sudo

Remove ignored files from the working tree with sudo.

make compose-app-exec

Run a one-off command inside a deployed app container of the local compose stack.

usage:

make compose-app-exec app=<container> cmd=”…”

example:

make compose-app-exec app=flowise cmd=”wget -qO- http://localhost:3000/api/v1/ping”

param app:

container name of the deployed app.

param cmd:

shell command to run inside it.

make compose-app-logs

Dump the logs of a deployed app container of the local compose stack.

usage:

make compose-app-logs app=<container> [tail=<lines>]

example:

make compose-app-logs app=litellm tail=80

param app:

container name of the deployed app.

param tail:

number of trailing lines (default: 200).

make compose-app-restart

Restart a single deployed app container of the local compose stack.

usage:

make compose-app-restart app=<container>

example:

make compose-app-restart app=nextcloud

param app:

container name of the deployed app.

make compose-deploy

Run the local deploy router.

usage:

make compose-deploy [mode=…] [apps=…] [purge=…] [type=…] [bundles=…] [disable=…] [full_cycle=…] [variant=…] [debug=…]

example:

make compose-deploy mode=reinstall apps=web-app-matomo full_cycle=true

note:

see scripts/tests/deploy/local/deploy/main.sh for the full routing table.

param mode:

initialize | reinstall | update (default: initialize)

param apps:

comma-separated app ids (e.g. web-app-matomo,web-app-keycloak)

param purge:

true | false (default: false) — purge entities before deploy

param bundles:

comma-separated bundle names; overrides apps when set

param disable:

comma-separated service names to render as disabled

param full_cycle:

true | false — when true, also run the async update pass

param variant:

matrix round index to pin the redeploy to a specific variant

param debug:

true | false (default: from default.env)

param skip_compile:

true | false — skip the in-container entry.sh recompile (use when the venv is prebuilt)

make compose-down

Stop the development stack.

make compose-entity-purge

Purge one or more app entities from the container and drop them from the round inventories.

usage:

make compose-entity-purge apps=<application_id>[,<application_id>…]

param apps:

application ids to purge

make compose-exec

Run a shell or one-off command in the running development container.

usage:

make compose-exec [cmd=”…”]

example:

make compose-exec cmd=”ls /opt/src/infinito”

param cmd:

shell command to run; when unset, opens an interactive shell.

make compose-inner-run

Run a one-off `docker run` inside the running container (nested Docker-in-Docker).

usage:

IMAGE=<ref> [cmd=”…”] [INFINITO_RUN_FLAGS=”…”] make compose-inner-run

example:

IMAGE=alpine cmd=’env’ make compose-inner-run

param IMAGE:

image reference passed to `docker run` (required, e.g. alpine).

param cmd:

command to execute inside the sidecar; defaults to the image entrypoint.

param INFINITO_RUN_FLAGS:

extra flags forwarded verbatim to `docker run`.

make compose-inventory-refresh

Refresh the container inventory without deploying apps.

make compose-network-recreate

Recreate the stack’s default network after an IPAM change, keeping volumes and reattaching foreign stacks.

make compose-playwright

Rerun a role-local Playwright spec against the live running stack (no redeploy).

usage:

make compose-playwright role=<role> [pw=”–grep <pattern>”] [keep=true]

example:

make compose-playwright role=web-app-dashboard pw=”–grep icons” keep=true

make compose-restart

Restart the development stack.

make compose-role-sync

Re-run only the role of a deployed app against the running stack (no system stages; the spec runs only with pw=).

usage:

make compose-role-sync role=<application_id> [variant=<idx>] [task=<task file>] [pw=”<playwright args>”] [keep=true] [base=’<hex>’]

example:

make compose-role-sync role=web-app-gitea variant=0 pw=”–grep design: –grep-invert gallery”

example:

make compose-role-sync role=web-app-xwiki variant=0 task=06_design.yml

param role:

deployed application id

param variant:

matrix round index the app was deployed with

param task:

task file of the role that runs alone instead of the whole role; it gets the role variables and nothing an earlier task of the role set

param pw:

Playwright arguments without quotes; when set, the spec of the role is staged again, its .env rendered again and run with them

param keep:

true lets that spec run capture the design gallery

param base:

hex base color that replaces the one of the inventory for this run, e.g. base=’#001f3f’

make compose-stop

Stop the development stack without removing volumes.

make compose-system-purge

Purge the broader container-level deploy artifacts.

make compose-up

Start the development stack.

make console

Interactive REPL for the infinito.nexus CLI, running on the host.

note:

each line is forwarded to `python -m cli`; Ctrl+C only cancels the current input.

note:

exit with `exit`, `quit`, or Ctrl+D.

make design-gallery

Rerun the design spec of a deployed app and copy its screenshots to /tmp/design-gallery/<app>/ (no redeploy).

usage:

make design-gallery app=<application_id> [views=<view>[,<view>…]] [before=true] [pw=”–grep <pattern>”]

example:

make design-gallery app=web-app-gitea views=dashboard,settings

param app:

deployed application id

param views:

comma-separated view names; only these are captured, by the gallery test alone, and added to the existing screenshots

param before:

true also captures every view with the injected snippets stripped from the document

param pw:

Playwright arguments without quotes that replace the default `–grep design:`; such a run adds its screenshots to the existing ones

make design-logos

Render every app’s branding assets (slots and favicon, day and night) from one logo and base color into an HTML preview, without a deploy.

usage:

make design-logos domain=<primary domain> out=<dir> [logo=<path>] [base=’<hex>’] [roles=<role>[,<role>…]]

example:

make design-logos domain=veen.world out=/tmp/design-logos logo=../computer-inventory/files/galaxyserver/web-svc-design/logo.png base=’#8DB33A’

param domain:

primary domain the role domains are rendered with

param out:

directory the assets and index.html are written to

param logo:

logo file; web-svc-design’s logo when empty

param base:

hex base color; web-svc-design’s base when empty

param roles:

comma-separated application ids; every role with a design entry when empty

make design-palette

Run the design assertions of a deployed app with another base color and restore the base of the inventory afterwards, also on failure.

usage:

make design-palette app=<application_id> base=’<hex>’ sync=<design|role> [variant=<idx>]

example:

make design-palette app=web-app-gitea variant=0 base=’#001f3f’ sync=role

param app:

deployed application id

param base:

hex base color for the check

param sync:

design re-renders the static design files, role re-runs the app role for values it bakes at deploy time

param variant:

matrix round index the app was deployed with

make design-queue

Print the roles that are due for a design pass in working order (new roles first, then by version gap).

usage:

make design-queue [args=”–next|–all|–format json”]

param args:

extra flags for the queue CLI

make design-sync

Re-render shared CSS, role style.css and the branding assets of a deployed app (no redeploy; injected scripts stay as deployed).

usage:

make design-sync app=<application_id> [variant=<idx>] [base=’<hex>’]

param app:

deployed application id

param variant:

matrix round index the app was deployed with

param base:

hex base color that replaces the one of the inventory for this run, e.g. base=’#001f3f’

make diagnose-disk-usage

Show disk and Docker resource usage to identify what to clean up.

make diagnose-network

Run the network-diagnose script inside the infinito container.

note:

covers DNS, TCP, TLS, and PMTU on both IPv4 and IPv6.

make dotenv

Regenerate .env (SPOT) from default.env + runtime context.

note:

runtime context covers distro, cache sizes, secrets, and the like.

make dotenv-force

Force a clean .env regeneration in a stripped environment.

note:

avoids stale BASH_ENV INFINITO_* values pinning via setdefault.

make environment-bootstrap

Bootstrap the local development environment.

make environment-teardown

Tear down the local development environment.

make fix-chmod

Mark all shell scripts under scripts/ as executable.

make fix-dockerignore

Regenerate .dockerignore from .gitignore.

note:

.gitignore carries the `.git` entry Docker needs.

note:

race-safe under parallel `make setup` invocations.

make help

Print every Make target with the description from its preceding comment line.

usage:

make help [target=<name>]

example:

make help target=compose-playwright

make i18n-extract

Merge the translatable strings of core and the documentation into the gettext catalogs under locale/.

param domain:

core | docs (empty: both)

make i18n-prune

Empty the translations that altered a protected span so the next i18n-translate redoes them.

param domain:

core | docs (empty: both)

param languages:

comma-separated ISO 639-1 codes (empty: every language)

make i18n-retry

Offer the entries a previous run recorded as refused again, after the masking or the damage predicate changed.

param domain:

core | docs (empty: both)

param languages:

comma-separated ISO 639-1 codes (empty: every language)

make i18n-translate

Machine-translate the empty and fuzzy entries of the gettext catalogs through the translation gateway, deploying its bundle when it does not answer.

param domain:

core | docs (empty: both)

param languages:

comma-separated ISO 639-1 codes (empty: every language the gateway serves)

param redeploy:

true — deploy the bundle even when a gateway already answers (after changing its code or its backends)

make i18n-tune

Measure the fastest LibreTranslate client settings on this host and record them for `make dotenv`.

param language:

ISO 639-1 code the sweep translates into (default: de)

make install

Install all runtime dependencies.

note:

incremental via a stamp file (see scripts/install/all.sh).

make install-act

Install act (nektos/act) if missing; provisions the act-based make targets.

make install-act-update

Force act (nektos/act) to its latest release.

make install-agent

Install OS-level sandbox dependencies required by the Claude Code sandbox.

note:

pulls in bubblewrap and socat.

make install-alias

Install the terminal aliases from INFINITO_ALIAS_REPOSITORY into the user’s shell config.

make install-ansible

Install Ansible dependencies.

make install-force

Force a full reinstall.

note:

drops the install stamp and rebuilds it.

make install-lint

Install lint dependencies.

note:

host or docker selected via INFINITO_LINT_RUNNER; incremental via a per-env stamp.

make install-lint-force

Force a full lint reinstall.

note:

drops the per-env stamp and rebuilds it.

make install-node

Install the Node.js runtime the JavaScript unit suite runs on.

make install-php

Install PHP, Composer and the vendor tree the PHP unit suite runs on.

make install-python

Install Python tooling.

make install-python-dev

Install Python tooling including lint and dev dependencies.

make install-ruby

Install the Ruby interpreter the Ruby unit suite runs on.

make install-skills

Install the agent skills from INFINITO_SKILLS_REPOSITORY into this project.

make install-system-python

Install the system Python prerequisites.

make install-venv

Install the virtual environment.

make kernel-loop-load

Load the kernel loop driver the swarm backup DR drill needs.

note:

run this on the host; container environments have no modprobe.

make lint

Run all lint checks in parallel.

note:

each check runs on host or in docker per INFINITO_LINT_RUNNER.

make lint-action

Run the GitHub Actions lint checks.

make lint-ansible

Run Ansible lint checks.

note:

runs ansible’s syntax-check plus ansible-lint.

make lint-css

Check that every CSS file parses, via stylelint with an empty rule set.

make lint-dockerfile

Run hadolint over the root Dockerfile.

make lint-javascript

Run ESLint over the project’s JavaScript files.

note:

covers Playwright specs and persona helpers.

make lint-makefile

Run checkmake against the Makefile.

make lint-markdown

Run Markdown lint checks via markdownlint-cli2.

make lint-mermaid

Render every Markdown mermaid diagram via mmdc; fails on any diagram GitHub cannot render.

make lint-packages

Validate distro packaging metadata (debian changelog, fedora spec, arch PKGBUILD).

note:

provisions the native parsers explicitly, then validates; absent tools are skipped.

make lint-php

Check that every PHP file parses, via `php -l`.

make lint-playwright

Verify every role’s Playwright spec parses + resolves its helpers.

note:

stages the spec like test-e2e-playwright does and runs `npx playwright test –list`.

make lint-python

Run Python lint checks.

make lint-ruby

Check that every Ruby file parses, via `ruby -c`.

make lint-shellcheck

Run shellcheck lint checks.

make lint-sql

Check that every SQL file parses, via `sqlfluff parse`.

note:

dialect comes from the nearest .sqlfluff; absent tooling is skipped.

make meta-list

Print the repository role list.

make meta-mig

Build the meta graph inputs.

make meta-tree

Print the repository tree.

make network-dns-remove

Remove the DNS configuration.

make network-dns-setup

Configure DNS on Linux.

make network-ipv6-disable

Disable IPv6 for local development.

make network-ipv6-restore

Restore IPv6 settings.

make network-refresh

Refresh the running development stack only when it already exists.

make network-trust-ca

Trust the local CA on Linux and WSL2.

make onboard

Set up a developer workstation end to end: dependencies, project setup, agent skills, terminal aliases, host network/security prep, and the dev extras inside the running dev container.

make quality

Autoformat, then run the full test suite (pre-commit gate).

make quality-high

Full gate: quality (autoformat + test) followed by every lint check.

make roles-clean

Remove every custom role (roles/web-app-cst-*) a pull placed in this checkout and nothing else.

make roles-pull

Pull the custom roles (web-app-cst-*) an inventory declares into roles/ without deploying, removing the ones it no longer declares.

usage:

make roles-pull inventory=<path>

example:

make roles-pull inventory=inventories/production/devices.yml

param inventory:

inventory file whose group_vars/host_vars declare applications.<group>.custom and .source (required).

make roundtrip

Validate one or more roles through every deploy mode in order (compose, then swarm), stopping at the first failure.

param apps:

space-separated role ids; default = one role per base cluster, most-complex first (complexity –unique).

param modes:

optional mode sequence (default “compose swarm”; append k8s once it exists).

param keep:

true keeps each validated swarm cluster instead of releasing it.

param disable:

optional comma-separated provider keys removed from the test inventory (e.g. matomo,dashboard,prometheus,email,css).

make runner-ci-deploy

Provision self-hosted CI runner instances on a remote host.

usage:

make runner-ci-deploy HOST=runner.example.com DISTRO=debian [COUNT=15] [PORT=22] [OWNER=myuser] [REPO=infinito-nexus]

make runner-ci-disable

Disable self-hosted CI runners — routes all deploy jobs back to GitHub-hosted runners.

usage:

make runner-ci-disable [OWNER=myuser] [REPO=infinito-nexus]

make runner-ci-enable

Enable self-hosted CI runners by setting CI_SELF_HOSTED_RUNNER_COUNT and INFINITO_TIMEOUT_MULTIPLIER.

note:

MULTIPLIER default 30 gives ~1 h max wait (60 retries × 30 × 2 s delay) for slow hardware.

usage:

make runner-ci-enable COUNT=15 [MULTIPLIER=30] [OWNER=myuser] [REPO=infinito-nexus]

make security-apparmor-restore

Restore AppArmor profiles.

make security-apparmor-teardown

Tear down AppArmor for local development.

make security-runtimes

List the PHP runtime of every pinned role image from registry metadata, without pulling, and fail on one below its security floor.

make setup

Run the setup step after generating .dockerignore.

make setup-clean

Run setup after cleaning ignored files.

make swarm-app-exec

Run a one-off command inside a swarm SERVICE container (one replica) on a DinD node.

param service:

swarm service name (e.g. moodle_moodle | openldap_openldap).

param name:

cluster id (the app id) used to default the node.

param node:

full DinD node container (default <name>-swarm-mgr-01).

param cmd:

shell pipeline executed inside the resolved service container.

make swarm-clean

Reclaim ALL leftover act-swarm state (DinD nodes, NFS sidecars, lab networks, act outer containers) from aborted/wedged roundtrip runs, across every cluster id.

note:

removes what the docker CLI can; D-state remnants (wedged kernel NFS) need a host docker restart under sudo, or are reported in a no-priv sandbox.

note:

run BETWEEN swarm runs; it would kill an in-flight one.

make swarm-clean-stale-nfs

Recover stale in-namespace NFS mounts from wedged act-swarm nfs-server containers.

usage:

make swarm-clean-stale-nfs [cid=<container-id-or-name>] [mount=/mnt/gtest]

note:

needs sudo; may restart containerd/docker only if docker rm still cannot reap the container.

make swarm-diagnostic

Backup/NFS diagnostics for a live swarm-test cluster: backup unit state + journal, NFS mounts, D-state (wedged NFS) processes, rsync/dump processes, disk. Read-only.

param name:

REQUIRED cluster id (the app id when no name= was passed to swarm-zombie).

param node:

optional single node container name; default probes mgr-01, nfs-server, bkp-01.

param unit:

optional systemd unit glob for the journal dump; default svc-bkp-*.

make swarm-down

Release a named swarm-test cluster (DinD nodes, lab network, act outer container).

param name:

REQUIRED cluster id matching the one swarm-zombie used (the app id when no name= was passed).

note:

Safe to run multiple times.

make swarm-exec

Run a one-off command inside one of the swarm-test DinD nodes.

param node:

full container name (e.g. <cluster>-swarm-mgr-01 | <cluster>-nfs-server; cluster = name= or the app id).

param cmd:

shell pipeline executed inside that container.

make swarm-playwright

Rerun a role-local Playwright spec against the live swarm-test cluster (no redeploy).

note:

nodes hold a frozen bootstrap copy (not a compose-style mount), so the working-tree’s modified+untracked files are copied into the node before rerunning via the same rerun-spec.sh engine as compose-playwright; solve ALL of a role’s tests (no pw= narrowing) before any redeploy.

usage:

make swarm-playwright role=<role> name=<cluster-id> [pw=”–grep <pattern>”] [keep=true] [node=<container>]

example:

make swarm-playwright role=web-svc-logout name=web-app-baserow pw=”–grep baserow” keep=true

make swarm-shell

Drop into an interactive shell on one of the swarm-test DinD nodes.

param name:

REQUIRED cluster id (the app id when no name= was passed); node defaults to <name>-swarm-mgr-01.

param node:

full container name to target (overrides the default).

make swarm-zombie

Run a swarm matrix-app test, copy the act job’s rescue bundle to the host, then release the cluster unless keep=true.

param app:

matrix application id (e.g. web-app-baserow).

param keep:

true keeps the cluster and its act outer container up for post-mortem inspection; otherwise both are released on success and on failure.

param distros:

optional single distro the cluster runs on (default: INFINITO_DISTRO from .env).

param variant:

optional matrix variant index to deploy (default 0); a multi-variant app runs one cluster per swarm-zombie, so pick the round to validate.

param disable:

optional comma-separated provider keys removed from the test inventory (e.g. matomo,dashboard,prometheus,email,css).

param vpn:

optional WireGuard axis (auto|enforced|disabled); default disabled.

param meshes:

optional WireGuard layout a meshed round deploys (default INFINITO_SWARM_MESHES).

param name:

optional cluster-id prefix for the container + network names; release with the same name=.

param arch:

architecture the cluster deploys on, amd64 | arm64 (default: the host’s own).

param network:

optional node network mode pinned on the row (clearnet | tor | multi); empty keeps the run’s rotation.

param step_timeout:

optional minute budget for the matrix-deploy step (default 690).

param INFINITO_INVENTORY_EXTRA_VARS:

optional environment JSON object laid over every round’s inventory vars, `applications` merged per app; must not contain ‘;’.

note:

With keep=true use `make swarm-exec` / `make swarm-shell` to inspect, `make swarm-down` to release.

make system-purge

Run the broad low-hardware cleanup routine.

make test

Run the full test pipeline.

make test-external

Run the external test suite.

make test-integration

Run the integration test suite.

make test-lint

Run the lint test suite.

make test-main-merged

Verify upstream main is fully merged into HEAD (pre-push gate); fetches and fails if the branch lags main.

make test-merge-signed

Verify every commit an in-progress merge brings in (HEAD..MERGE_HEAD) is signed (commit-msg gate).

make test-oracle

Run the suite whose verdict comes from a model (not part of the `test` fan-out).

note:

brings the tools lane up first, because the checks run inside the stack’s container and cannot deploy the model they ask.

make test-performance

Run the runtime-performance suite (not part of the `test` fan-out).

make test-signed

Verify HEAD is signed.

note:

`git log %G?` returns N for unsigned; gates the pre-push hook against unsigned tips.

make test-unit

Run the unit test suite (every language).

make test-unit-javascript

Run the JavaScript unit test suite (node:test, no npm dependency).

make test-unit-php

Run the PHP unit test suite (PHPUnit).

make test-unit-python

Run the Python unit test suite.

make test-unit-ruby

Run the Ruby unit test suite (minitest).

make worktree-down

Stop a branch worktree’s stack, release the checkout and free its slot.

usage:

make worktree-down branch=<name> [base=<dir>] [force=true]

param branch:

branch the worktree was created for (required).

param base:

parent directory the worktree lives in (default ~/.local/share/worktrees/<domain>/<account>/<repo>).

param force:

true discards uncommitted changes in the worktree.

make worktree-prune

Drop registrations of worktrees whose directory is gone, freeing the branches they claim.

usage:

make worktree-prune

make worktree-up

Check a branch out into an isolated worktree with its own subnet, ports and container names.

usage:

make worktree-up branch=<name> [base=<dir>]

note:

the worktree shares the primary checkout’s cache stack instead of starting its own; `make cache-apply` serves its own cache declarations from it.

param branch:

branch to check out (required).

param base:

parent directory for the worktree (default ~/.local/share/worktrees/<domain>/<account>/<repo>).

make wsl2-dns-setup

Set up DNS on WSL2.

make wsl2-systemd-check

Enable systemd on WSL2.

make wsl2-trust-windows

Trust Windows certificates in WSL2.