Repository navigation
Remote protocol: 1. This release is the baseline: from it on, mm and the
mmd on your hosts use the newest remote protocol both speak, so a newer mm
works with hosts on 0.1.1 or later, and a host upgraded first keeps serving
older clients as long as it speaks their protocol. The protocol number
changes only for a change an older release cannot read. Builds from before
0.1.1 do not work with it: install mm with the installer and set their
hosts up again with mm target setup plan --upgrade. See
compatibility between releases;
upgrade mm and your hosts says which installations
mm target setup upgrades in place and what it refuses.
Removed
- The separate release download site, the release certification step, and
the PowerShell installer: releases are published on GitHub, and Windows is
not a release target becausemmdoes not build for Windows. - The
docker-swarmruntime driver and theswarm-native-secretdelivery
driver. The runtime drivers aredocker-composeandpodman-compose, and a
configuration that still names a removed driver fails to load with a message
naming its replacement. A target that lists several hosts undernodes:
takes Docker Swarm's place: see
Coming from Docker Swarm.
Changed
-
A host's
mmdthat cannot read a request, such as one from a newermm,
answersMM_REMOTE_UPGRADE_REQUIREDwith both releases and acts on none of
it, instead of closing the connection. Whenmmand a host share no
protocol, the refusal names the release and the protocols of each side, and
the command for the side to upgrade. -
mm target setuporders releases by version first and remote protocol
second, so a host from before 0.1.1 (version 0.1.0, protocol 16 to 19) is
older than 0.1.1 and is replaced with--upgrade; before, setup took it
for a newer release and refused it. -
A configuration key this
mmormmddoes not read is ignored with a
warning that names the file, the key, and the key it most likely meant,
instead of failing to load:
Warning: unknown key `modules.web.build.sufix` in .config/mm.yaml; this mm ignores it (did you mean `suffix`?).
A project that uses a key a later release adds keeps planning with an older
mmand on hosts with an oldermmd, and adding a key never raises
schema-version. Plans list the keys underunknown_config_keys, a remote
plan with the nodes that ignore them;mm config validate --strictfails
on them, for CI. The published JSON Schema still flags them in editors. -
The installer is served at
https://modmon.dev/install.sh(the site build
copiespackaging/release/install.sh) and installs from the releases on
GitHub: the latest by default, or the one--versionnames, release
candidates (vX.Y.Z-rc.N) included. It checks the archive against the
release'sSHA256SUMSbefore it unpacks anything, and installsmm, on
Linuxmm-ingress-helperbeside it, andmmdwith--with-daemon. Under
WSL it installs the Linux archive. -
mm doctor --check-updatesreadsmanifest.jsonof the latest GitHub
release, which the release workflow attaches and attests; a release
candidate is never offered as an update. It reads the manifest of every
later release: fields, platforms, and binaries a release adds are skipped,
and a release that needs a newer reader says to run the installer. -
A client newer than its host now says to run
mm target setup plan --upgradeand to apply that plan with--upgrade; before, it named the
plan without the flag that a cluster's setup asks for. -
A build reads the ignore file next to its Dockerfile, such as
web/Dockerfile.dockerignoreforweb/Dockerfile, instead of the
context's.dockerignorewhen it exists, as Docker does, and matches
ignore patterns by Docker's rules: from the top of the context, so
node_modulesno longer excludesweb/node_modules(write
**/node_modules). An image's context hash covers only what its own
ignore file sends. -
mm buildbuilds only the build variant the environment selects (every
variant when it selects none of several), and a build receipt deploys to
another environment only when it holds the variant that environment
selects; the refusal names the variants on each side and the command that
builds the missing one. -
A registered project whose folder or
.config/mm.yamlwas deleted no longer
stops the dashboard ormm dev setup --services: it is skipped, and the
dashboard andmm doctor(MM_WORKSPACE_STALE) name the command that
forgets it. -
Commands that wait show what they do at once: on a terminal, the running
step with its time, a row per node and a bar where an amount is known,
each finished step left as one line; elsewhere one plain line per
finished step with its time (MM_PLAIN=1asks for that on a terminal).
mm target setup planshows the plan as a card with short IDs and the
changes first, reads every node, the secrets and the host binaries at
once, and asks the secret store once instead of once per secret.
target setup apply --yesplans once, not twice. -
mm deploy planandapplyshow the plan as a card and the rollout live,
node by node; scripts still read the same==> node: steplines. Status,
rollback, cancel, team sync,target nodes,target mesh status,
target storage status,doctor,build,service status,service restartand a followedjob runshow what they wait for. -
The terminal UI's Variables view lists the services on the left and shows
the variables of the one selected, instead of every variable in one table.
Search (/) and the problem filter (p) still look across every service,
with the selected service's matches first. -
The website and the documentation lead with clusters: what a list of
servers gets from mm, the smallest cluster target, and the terminal UI on a
cluster come first, agents second, and local development after them. New
guides: Run a cluster and
Coming from Docker Swarm. The old
address/docs/how-to/swarm-clusterleads to the cluster guide. -
A restart of
mmd(an upgrade, a crash, the watchdog) keeps its sockets:
mmdhands them to systemd (FileDescriptorStoreMax=inmmd.service),
so name lookups and requests that arrive meanwhile are answered by the
nextmmdinstead of refused. Upgrading withmm target setupreplaces
mmandmmdone node at a time without restarting a container, and puts
the new relay in place only asmmdrestarts (before, a node refused every
client for about half a minute of each upgrade). -
A mistake in
/etc/mm/host.yamlno longer stopsmmdat its next start:
it keeps answering its containers' names and refuses every request with the
file, the line, andmmd access validateuntil the file loads. -
The audit log is rotated at 16 MiB and keeps about 80 MiB in five files;
mmd access auditreads them all. Request records used against replay are
removed after two days. -
mm target setupwithdelivery: pushremoves the deploy key, the pinned
origin host key, and the clone that fetch mode left on a host, and the
setup plan says so, for one host as for a cluster. -
mm deploy applyrefused for a secret store outage says the apply planned
again and was refused, and that nothing was changed. -
mm deploy planandmm deploy applystop with
MM_SECRET_STORE_UNAVAILABLEwhen a secret store the deployment needs is
unreachable, sealed, or refuses the login, on a remote host, a cluster node,
and this machine alike. They used to plan without the secret's version, and
the apply failed when it read the value.mm devstill plans the
development environment while its store is stopped and reports the store in
its status. See
when a secret store does not answer. -
A remote host refuses a Compose service's
runtime:unless its host policy
offers that runtime underruntimes:; the refusal lists what the host
offers. Before,runtime:reached the engine unchecked. -
On a cluster node a container no longer reaches its own node's mesh
address, nor a port another node publishes on its mesh address. Reach such
a port from the hosts, or put both services on a network undernetworks:. -
mm_readwith kindjobsorscheduleson a remote environment returns
the declared jobs and their runs on the hosts (empty when none are
declared) instead of failing withMM_BUILD; reconciling or toggling a
remote environment's schedules is refused withMM_REMOTE_SCHEDULES. -
mm service statuslists each service once, with a row for each of its
containers, node by node on a cluster target. The columns areSTACK,
SERVICE,STATE(running 3/3),NODE(cluster targets only),
CONTAINER,HEALTH,STATUSin the engine's words, andIMAGE. In
--output jsona service hasnodes(one entry per node with its state
and counts) and each container hasnode.service.nodeis gone: a
script that read it readsservice.nodes[].nodeorcontainers[].node. -
mm service logsprefixes every line with the container that wrote it
(web-1 | ...), and on a cluster target with the node before it
(app-1 web-1 | ...). In--output jsoneach record hasnode,
container, andtimestamp. -
Status and logs take no deployment lock and wait for no deployment. A
remote host answers a status from the containers its engine runs, read
from the Docker Engine API on its socket, without rendering a Compose
file: it answers during a rollout and within tens of milliseconds. Remote
status no longer prints the Compose plugin's version. -
mm service statuson a cluster counts a service on a node that did not
answer: a service placed on three nodes, one of them silent, reads
degraded 2/3with ano answerrow for that node instead of
running 2/2, and a service placed only on a silent node is listed as
unknown 0/1. In--output jsonthat node's entry under the service's
nodeshas"state": "unknown". -
The count under
STATEis the containers that are ready: running, and
passing their health check when they have one. A service whose containers
all run while a health check has not passed yet readsstarting 2/3
instead ofdegraded 3/3; in--output jsonitsstatestays
degraded, the new booleanstartingistrue(on the service and on
each node's entry undernodes), andhealthy_countsays how many are
ready."state": "degraded"with"starting": trueis a rollout in
progress, not a failure. -
In
--output jsonof a status, every entry of the top-levelnodeslist
hasproblem,deployment,drift, andnetwork_drift:nullor[]
when there is nothing to report. They used to be left out when empty. -
An MCP tool that cannot reach a host answers
MM_UNREACHABLEwith the
host, what happened, and the next step, in mm's own words; it used to
answer with a sentence that named no cause. A host that refuses the agent
key, as aftermm key rotate --agent, saysrefused this device's agent keyand how to register the new key. -
mm doctorsays why a key's passphrase is in a file beside the key when
MM_KEY_VAULT=filechose that (MM_KEY_PASSPHRASE_IN_FILE); it used to
say the machine has no system keychain. -
On a cluster node,
mmdreads the containers on its networks and the
containers that wait for shared storage from the Docker Engine API. It
used to startdocker psanddocker container inspectevery ten
seconds. -
mmd's name resolver no longer startsip -j -4 route show table all
each time it looks at the node: it reads the mesh statemmdstored. A
node whose stored networks name one that no deployment there uses any
more (the engine has no bridge for it) tried that address every second
for as long asmmdran; it now tries every second for 30 seconds, as at
boot, and then with its ordinary look every ten seconds. -
mm team join --agentaftermm key rotate --agentputs the new agent
key in your entry in place of the one the rotation replaced and says so
(This replaces the previous agent key SHA256:…); it used to add the new
key beside the old one. Only a key this device's own rotation replaced is
taken out.mm key rotate --agentnames that step and the old key's
fingerprint, andmm key rotate --output jsonhasreplaced. -
mm doctorfor an environment on a remote target exits non-zero only for
findings about that environment and what this machine needs to reach it.
The local certificate authority and the shared development services are
listed as notes.mm doctor -e ENVIRONMENTon a machine where
mm dev setupnever ran returned2and now returns0when the
environment is ready. This machine's container engine does not decide
the exit code either: doctor returned3for every remote environment,
because the engine of a remote environment is not asked and that read as
unavailable. Theruntimeline now says
on the target's hosts; this machine's engine is not used. -
The remote protocol is version 19 (0.1.0 spoke version 1):
mmand the
hosts'mmdmust run the same version, and a host on another one answers
with the side to upgrade. Runmm target setup planand apply it after
upgradingmm. Version 18 adds the Compose overlay that keeps a
role: jobservice out of a deployment and itsjob_onlystatus,
environmentson secret and config files, and the release (name, inputs,
images) on plans, deployment records and each request. Version 19 adds a
route's headers and allowlist and the environment's Cloudflare Tunnel to
cluster plans, each node's tunnel connector to a status, each node's member
of the managed secret store to its facts and report, and the requests that
snapshot, restore and fill that store. -
The terminal UI lists each service of a cluster once, with a muted row for
each node beneath it;spacefolds the rows. The service details list its
nodes and what differs from the last deployment, the Overview shows the
deployed release, the log view starts each line with its node and
container in one colour per node and marks a node that does not answer,
and the start review lists service moves and cluster network changes. -
The terminal UI's deploy review is the plan
mm deploy planprints for the
same plan, line by line and scrollable, instead of three lines. While the
plan is applied, each node's row says which step it is on and which
stacks it has applied, as the apply reaches it;eschides the review
while the apply goes on andushows it again. On a remote environment
bplans a rollback, the planmm deploy rollbackmakes, and shows it
the same way. The MCP toolmm_deploy_plantakesrollback: truefor the
same plan, andmm_deploy_applyapplies it. -
In the terminal UI the rows beneath a service on a cluster are rows to act
on:lfollows that node's container, asmm service logs --nodedoes,
andxruns a command in it. -
The terminal UI shows errors as the command line does, with their code:
error[MM_UNREACHABLE]: .... -
mm deploy applyon a cluster prints a line when a node's turn with a
stack is over (==> app-1: app: healthy). -
mmd.serviceisType=notifywithWatchdogSec=30s.mmdreports
itself alive only while a request to its own socket is answered, so
systemd replaces a daemon that stopped answering within half a minute,
two seconds after it killed it (RestartSecwas five), and keeps trying
for as long as it takes. On a cluster nodemmdanswers names on a thread
of its own, so a busy or stuck request does not delay a container's
lookup. A daemon that starts while a deployment was in progress on its
host releases that deployment's lock at once and marks the rollout
interrupted;mm deploy statussays so, and the next deployment undoes
it. Runmm target setup planand apply it to install the new unit. -
The terminal UI draws at once and fills in. Bare
mmused to read
everything before its first frame: 0.6 seconds for an environment on this
machine and over 2 seconds for a remote one. It now draws from the project
configuration in under 50 ms and reads the environment afterwards, each part
by itself: a view whose part has not arrived says what it is waiting for,
and on a cluster each node is listed as it answers, so one slow or silent
node no longer holds back the others. While the environment is being read,
keys that look around work and any other key says it works as soon as the
environment is here. -
mmkeeps the SSH connection to a remote host open for five minutes and
uses it for the next request, from the same command or the next one, instead
of connecting again each time. Only a connection made with this device's
key file is kept: never one made with a security key, the agent key, or
MM_SSH_KEY. Kept connections are closed whenmmcreates a key, applies a
team sync, a deployment, or a target setup, or accepts a target's new keys,
and when the key file they were made with is removed or replaced;
MM_SSH_REUSE=offturns them off. The host checks every request as before,
whichever connection carries it. See
remote access. -
Reads on a host are quicker for the host too: a status asks the engine for
its version, its state, and each stack at the same time and renders each
stack once less; a node checks its engine's firewall once for all cluster
networks instead of once per network; andmm deploy planreads the nodes'
stored network addresses while they plan. -
In the terminal UI, a cluster node that does not answer counts as an issue
in the header, the Overview, and Diagnostics, and the Services view names
it. It used to be visible only in the details of the Environments view,
under a header that saidno issues. -
A deployment waits up to ten minutes for a stack to become healthy (it was
two), and no longer waits at all when waiting cannot help: a container that
exited, a container the engine keeps restarting, or a failing health check
fails the deployment at once, with the service's name and the container's
last log lines in the error. This applies to local and remote deployments. -
On a host, a deployment that was interrupted is undone before the next one
starts even when the next one deploys another commit. It used to be left as
it was, because the host looked for interrupted deployments per checkout. -
A request to a cluster node names the node it is for, and a node refuses a
request meant for another (MM_NODE_MISMATCH). A client and a host on
different protocol versions refuse to work together, and the error says
which side to upgrade. -
An error from a remote host is reported with the code and message it had on
the host, and on a cluster target with the node's name. It used to be
wrapped asMM_SECURITY"security policy rejected the operation: remote
error ...", whatever it was. Only a refusal the host made as policy is still
MM_SECURITY. A host error under a code thismmdoes not know is
MM_REMOTE. -
A host that cannot be reached fails with
MM_UNREACHABLEand a message that
names the host and address, says what happened (no answer,mmdnot
running, a changed host key, a refused key), and what to run next. It used
to report a protocol error. -
mm target trustlists the keys of a cluster target's nodes by node name. -
mmdowns the WireGuard mesh between cluster nodes. The interface ismm0
(it waswg0, written as awg-quickconfiguration by the setup scripts).
Each node'smmdmakes the node's key and stores the applied state under
/var/lib/mm/mesh, andmm-mesh.servicerestores the interface at boot
beforemmd, the container engine, and the storage server. A host set up by
an earlier development version moves tomm0on the next
mm target setupapply and keeps its key; no manual step is needed. -
mm target setupon a cluster runs a new step,connect-nodes, after
provision-nodes: the mesh is brought up by themmdthat provisioning
installs.mm target setup plannow logs in to nodes whose SSH host key the
repo records, to read their public WireGuard key and peers; it changes
nothing there. -
mmd.servicemay open netlink sockets, which it needs to read the mesh
interface formm target mesh status. -
The MCP
mm_logsandmm_exectools and theservicesread go through the
same path asmm service, so they work on cluster targets too. -
Bare
mmopens the terminal UI whatever state the environment is in. It
used to print the fullmm doctorreport and a menu, and would not open
until every local check passed, so a broken local environment also blocked
switching to staging or production. What a local environment still needs is
now a short numbered list on the Overview;enterruns the selected step
with the same handler as its command. An environment that cannot be read at
all opens with the reason and empty views, and reloads when it answers. -
Bare
mmregisters this machine as thelocaltarget when it is missing,
asmm initandmm dev setupdo. Existing targets are not changed. -
Leaving the terminal UI exits with status 0. It used to exit with the status
of the environment it opened on. -
An environment marked
not set upin the Environments view opens on its
setup steps instead of refusing to open. -
mm doctorprints passed checks as one count and ends with the steps to
take, each once, with its command. JSON output is unchanged. -
mm service logs --tail Nwithout--follow, and themm_logsMCP tool,
return the last N lines of the service in time order. A runtime applies the
limit to each container or Swarm task, stopped ones included, so a service
with several returned more lines than asked for, grouped by task. -
Log and job output redaction no longer replaces a short secret value inside
unrelated text: a secretnullturned/dev/nullinto/dev/[REDACTED].
Values of eight characters or more are replaced everywhere as before.
Shorter values are replaced where they stand alone, and values under four
characters or ordinary words (null,true, ...) are not replaced. -
The terminal UI's Environment view is now called Variables, and the views
are renumbered: Environments is2, Services3, Ingress4, Variables
5, Mounts6, Diagnostics7, TLS8, Access9, and Gates0. -
In the terminal UI's Jobs view,
spaceenables or disables a schedule;
enow edits it. -
On a remote environment the terminal UI refreshes every 10 seconds instead
of every 3, shows the target and your access in place of the local control
plane, and labelsuas deploy. -
The website is a new Nuxt app in
site/with a home page and the
documentation under/docs. The documentation itself is now plain Markdown
indocs/, and generated schemas live insite/public/schema(still served
at/schema). Old documentation addresses redirect to their place under
/docs. -
The local dashboard has a new design that follows the terminal interface:
a health summary, a services table with replicas and routes, and the control
plane and project details on every view. It shares its components with the
website throughpackages/ui. -
Install instructions lead with the one-line release installer;
./install.shremains for building from a checkout. -
mmrefuses to run directly for an AI agent. When a coding tool's
environment variable is set (such asCLAUDECODE,OPENCODE,CODEX_CI,
CURSOR_AGENT,GEMINI_CLI,AI_AGENT,AGENT, orMM_AGENT), every
command exceptmm mcp serveexits with code 3. Runmmfrom your own
terminal. -
The MCP server takes its limits from the project's
agents:block. The
privatemcp.jsonis now optional, usesschema_version1, and can only
narrow the block withceiling. Tool and resource contracts are
mm-mcp-tools-v1andmm-mcp-resources-v1: a
scopeneeds onlyenvironment, and plans reportapplied_by. -
The MCP server reaches remote environments only with the agent key. It no
longer usesMM_SSH_KEY, a target's key file, or the device key. -
Agents can no longer apply a change above their level by confirming it
themselves, and the users file cannot be edited through MCP. -
Remote access no longer uses per-developer Unix accounts or
/etc/mm/access.yaml.mmdreads/etc/mm/host.yaml(enrolled projects,
ceilings, break-glass keys) andmmd.jsonschema 2, and refuses the old
files with a pointer to the migration steps. -
mm secret generate --missingcreates only the generated secrets the
selected environment uses: those its bindings name, its services mount, and
its registries, TLS, tunnel and deploy key read.--alltakes every secret
with agenerate:block, as--missingdid before. A secret whose provider
has no connection from this machine is listed as skipped with the reason,
in the JSON output too, and the others are still created. -
mm buildbuilds only the modules the selected environment runs, and the
first-party images they build FROM;mm build --allbuilds every module,
as before. A build receipt promotes to an environment that runs fewer
modules than the one it was built for. -
A deployment plan needs only the
release-inputs:that a template of the
planned environment reads, and names every missing one with the template
line that reads it, so a development environment plans without the values
CI supplies for staging, from the command line and through MCP alike. -
A failed MCP call returns the message the command line prints for its
error, redacted as the command log is, with the command line's help in
next_action; what another program printed stays out, and a failed
program is named with its exit code.mm_readhealthreturns the
findings ofmm config validatewhen the environment's status cannot be
read, andMM_CONFIG_INVALIDnames its first three findings.
Added
-
mm updateupdatesmmfrom the latest stable release, or the one
--versionnames, andmmdandmm-ingress-helperwhen they sit beside
it. It checks the archive against the release'smanifest.jsonbefore it
unpacks anything, runs the newmm, and replaces every binary or none.
mm update --checkonly reports, and the update check now says to run
mm update. See update mm. -
mm target setupreads each host's CPU while it plans and installsmm
andmmdbuilt for it: from the directory of themmyou run when it
holds them, otherwise from thismm's release, downloaded, checked against
its manifest, and kept under the mm home. Setup works from macOS and for
clusters whose nodes have different CPUs, and no longer needs the
installer's--with-daemon. The plan names each host's source and the
digests;--host-binariesstill overrides, and binaries built for macOS,
for two CPUs, or for another CPU than the host are refused before anything
is installed. See
where setup takes mm and mmd from. -
mm workspace listshows the project folders mm has run in on this machine,
their project ID, when each was last used, and which are gone.
mm workspace forget --stale(orROOT|ID) forgets them through a reviewed
plan: their operation history andmm env setvalues go, their files stay. -
A service may run on its host's network (
network_mode: host), as a VPN
or DNS server needs. On a remote host or a cluster node the host policy
decides:allowwithfeatures: [network-host]for thatstack/service.
On your own machine the service says why withhost-network: <why>under
modules.<module>.services.<service>, and the plan shows the reason.
Such a service has no routes, joins no network, and keeps the host's user
namespace. See
run a service on the host's network. -
mm_setup_planandmm_setup_applylet an agent set up this machine within
its grant, through the services the command line uses: the shared local
services (mm dev setup --services), a managed secret provider's install,
the local age store (mm secret init age), and missing generated secrets
(mm secret generate). The secret steps needsecrets: truewith level
deployon an environment that runs here; trusting the local certificate
authority andmm agent truststay the user's. -
Releases are published by the release workflow when a
vX.Y.Ztag is
pushed tomaster: the Linux x86-64 and ARM64 archives are built from the
tag in pinned containers byscripts/release/build-linux.sh(which also
reproduces them on any machine with Docker), the macOS archives on GitHub's
macOS runners, and the GitHub release carries them with the source archive,
SHA256SUMS, and a build provenance attestation for each file
(gh attestation verify). AvX.Y.Z-rc.Ntag publishes the same as a
prerelease. The notes must start with the remote protocol the release
speaks. The maintainer may add an SSH signature overSHA256SUMS
(scripts/release/sign.sh). See publish a release. -
Linux release archives carry
mm-ingress-helperbesidemmandmmd, and
the installer puts it besidemm, so local HTTPS ingress (mm ingress start) works from a release install, not only from a checkout. When the
helper is missing, the error says how to get it from a release. -
development: on | optional | offon a module, service or job keeps it
off in local development until a developer runsmm dev enable UNIT
(kept in the gitignored local overrides) ormm dev up --with UNIT(one
run). What it needs through Composedepends_oncomes on with it; its
routes, jobs and schedules follow it;mm dev disablestops it and keeps
its volumes. The plan lists it asoff locally (optional), the terminal
UI turns it on and off witho, the dashboard greys it out, and agents
withdeployon the development environment usemm_dev_unit. -
An environment on a cluster target can take its routes through a
Cloudflare Tunnel with no port open on any node:ingress.type: cloudflaredandingress.cloudflared.token(a secret). Every ingress
node runs a cloudflared connector next to its proxy, configured from the
routes, with the token in a file only the connector reads; connectors
change one node at a time, each once it is connected.mm deploy plan
names the tunnel and each node's hosts, andmm service statusand
mm doctorshow each connector's connections (MM_TUNNEL_NOT_CONNECTED,
MM_TUNNEL_TOKEN_MISSING). See
Serve a cluster through Cloudflare Tunnel. -
Routes on a cluster target set response headers (
headers:on a route,
ingress.headerson an environment), let only the requests anallow:
list names through (methods and a path pattern; the proxy answers 404 to
the rest), and take apriority:among the routes of their host (by
default the longer path goes first). The plan lists a host's routes in the
order the proxy tries them, with what each lets through. -
A cluster environment can keep its deploy secrets in an OpenBao store mm
runs on its nodes:mode: managedwithscope: environmentunder
providers:.mm target setupinstalls the pinned, checksum-verified
release as a systemd unit on 3 or 5 members, joins them over the mesh with
TLS from a per-environment authority whose key stays on your machine,
initialises the store, and revokes the root token; each node'smmd
unseals its member on boot.mm secret set|generate|rotate|statusstage
values as with the age store, and each becomes a new version once its
deployment succeeded.mm secret provider recovery export|importhand the
recovery copy over,mm secret provider snapshotandrestoretake the
store to a file and back onto fresh nodes, andmm secret provider status,
mm target nodes,mm doctorand MCP's readsecret_storeshow each
member's seal, Raft role and release
(MM_SECRET_STORE_SEALED,MM_SECRET_STORE_DEGRADED,
MM_SECRET_STORE_VERSION_SKEW).mm secret migrate --from age --to NAME
moves the age store's values in, keeping their revisions, and setup
upgrades the store (OpenBao 2.4 or 2.5) one member at a time, the leader
last. A reinstalled node's member rejoins through setup: the plan shows it
asrejoins, and the apply removes its old Raft entry through a serving
member before it joins again; a member that is only down is never removed.
The remote protocol is now 19. See
Keep deploy secrets in a managed store. -
mm -e ENV secret set KEYandmm -e ENV env set KEYon a remote
environment stage the value on every host throughmmd, as your own
principal: sealed with age to each host's store, all hosts or none, and
only for a secret the deployed commit declares or a variable its
templates use without a value in.config/mm.yaml. Running services keep
their values until a deployment makes the change live;unsetstages a
removal anddiscarddrops a staged change.--localwrites this
machine's store, which setup pushes, as these commands did before. The users file'ssecrets: truegrants it per environment (admin includes it; an agent only when
theagents:block sayssecrets: truetoo).secret statusshows each
host's live and staged revision and who changed it, never a value, as do
the terminal UI's Variables view and MCPmm_readkindsecrets.
mm deploy planlists the staged changes it makes live and refuses a
host that would deploy without a required value;mm deploy redeploy
(MCP:mm_deploy_planwithredeploy) plans the running commit again.
Every stage is in each host's audit log. See
Change an environment's variable. -
MCP
mm_stage_valuestages a secret or variable for an agent whose
grant hassecrets: true; the value is sealed to the hosts and never
returned. -
mm target setuprefuses to replace themmandmmda node runs with
another build of the same release or an older release unless
--upgradeis given ordeploy.mm-versionpins the release; the plan
names the build each node runs and the one it would get. -
A build target under
modules.<m>.build.targetscan be a mapping with
target(the Dockerfile stage),suffixandargs; its arguments merge
over the module's, so two environments build two images from one stage
with different public values.mm build planand receipts list each
variant's arguments. The string form still works. -
On a cluster, each node restarts its containers whose health check has
failed for 3 minutes, one at a time asmm service restartdoes, never
during a deployment, at most 5 times an hour; past that it keeps the
container out of the names and routes while another can serve, and
mm service statusandmm doctorreportMM_SERVICE_RESTART_LIMIT.
health:on a service changes the times or turns it off; each restart is
in the audit log, the status, andmm service logs. -
ingress.balance: spreadon an environment, orbalance:on one route,
sends a cluster's ingress requests to the service's containers on every
node instead of the ingress node's own first; a route to an autoscaled
service spreads by default. Every cluster route now sends each request to
the less busy of two containers, so a slow container gets fewer. -
A service with
role: job, which changed nothing before, is now only the
container its jobs run in: a deployment starts none of it, so a job can
hold secrets no running container holds. Plans andmm service status
list it asjob only. See
Give jobs a service of their own. -
environments:on asecret-filesorconfig-filesentry mounts the file
only in those environments; elsewhere its secret is not required. -
Release facts: templates and bindings read
MM.COMMIT,
MM.COMMIT_SHORT,MM.RELEASE,MM.IMAGE.<module>and
MM.IMAGE_DIGEST.<module>, and values declared underrelease-inputs:
asRELEASE.<NAME>, given withmm deploy plan --release NAME --release-input NAME=VALUE(andmm_deploy_plan). They are part of the
plan, recorded per node, shown bymm deploy status, restored by
mm deploy rollbackand kept bymm deploy redeploy; a missing or
malformed input fails the plan with
MM_RELEASE_INPUT. -
mm historylists the commands run in a project on this machine and
mm history show IDprints what one printed, as plain text; agents read
the same records withmm_readkindcommands, and each change an agent
makes through MCP is listed with its audit entry. Records stay under the
mm home, with secret-bearing arguments and private keys redacted
(MM_NO_HISTORY=1leaves a command out). -
deploy.mm-versionon an environment pins the release of mm that may plan
its deployments and ofmmdon its hosts ("0.9","=0.9.3"). Plans from
another mm, and for hosts that run anothermmd, are refused, and
mm doctorreportsMM_VERSION_PIN. Without a pin,mm doctorwarns when
hosts run an older or newer release than mm (MM_HOST_RELEASE_OLDER,
MM_HOST_RELEASE_NEWER). -
mmd state exportandmmd state importback up and restore a host's own
records: the host policy, the node's name, access, blocks, deployment
history, cluster network addresses, and the audit log. An export never
holds a key, a secret value, or a passphrase. -
A production checklist in the docs, with the test or release file behind
each item. -
delivery: pushon a target: mm sends each commit's tracked files to the
hosts over its own connection, and the hosts never contact the git server
and need no origin or deploy key. A host keeps a bundle only when its
files hash to the commit's tree, the plan and the host's audit log name the
bundle's hash, and on a cluster every node of a plan is sent it.
mm target setup --delivery push(one host) and anodes:target with
delivery: pushset a host up for it. The default staysfetch. With
pusha host cannot check which branch of the origin a commit is on:
deploy-fromis held against the branches the client states. -
hardening: strictat the top ofmm.yamlgives every deployed service a
read-only root filesystem, no Linux capabilities, no new privileges, the
engine's default seccomp profile, and a tmpfs at/tmp. The plan lists
what each service runs with. A service leaves one default out under
hardening: {except: {read-only: "<reason>"}}, the plan prints the reason,
and an exception without one fails validation (MM_HARDENING_REASON).
mm devis not hardened. See harden services. -
A remote host says which OCI runtimes it offers (
runtimes: [runsc]in
/etc/mm/host.yaml) and can run every service that publishes a port or
takes ingress traffic under one of them (exposed-runtime: runsc), which
the plan shows.mm doctorruns a container under each runtime a host
offers and reports one that does not work asMM_RUNTIME_NOT_WORKING. See
choose an OCI runtime. -
Remote hosts and cluster nodes can run rootful Podman: an environment with
runtime: {driver: podman-compose}on a remote target is set up with
Podman 5, Docker Compose as its Compose provider, and Podman's API socket,
and everything a cluster does works there: networks across nodes, names,
rolling deploys, shared volumes, status, logs, and exec. Every service
gets 65536 user ids of its own, the same on every node and in every
deployment, from a range setup reserves (mm-servicesin/etc/subuid
and/etc/subgid): its volumes keep working across recreates and nodes,
and its config files andsecret-filesbelong to the container's user.
A service keeps the host's ids withhost-user-namespace: <why>, which
every service that mounts a volume another one mounts needs
(MM_USER_NAMESPACE).update.order: start-firstworks on Podman too:
the new container has the service's ids and keeps its volumes.mm doctorreports a host
whose Podman is older than 5.0 (MM_PODMAN_VERSION), whosepodman composedoes not run Docker Compose (MM_PODMAN_COMPOSE), or whose
engine does not answer (MM_NODE_ENGINE), andmm target nodes --output jsonlists each node'sengine, as the terminal UI's Environments view
does. The firewall chains that keep the mesh between the hosts andmm doctor's check of a host's OCI runtimes work on Podman nodes too.
Projects made before need the new.config/ansible/bootstrap.ymlfrom
mm init. -
jobs.<name>.runmakes a deployment run a job by itself:before-deploy
(after what its service depends on is healthy, before the service is
started or replaced; a failure stops the deployment with the old version
running),after-deploy(once the deployment converged), oronce(the
first time the environment is deployed with it, undermmd, recorded on
every node).jobs.<name>.environmentslists the environments a job
belongs to (environment:still reads).mm deploy planlists the jobs a
deployment runs and whether aoncejob is due; a rollback plan lists the
jobs that ran since the release it returns to.mmdruns the schedules a
deployment reconciled on its host, and moves on the runs nobody waits for. -
Jobs on cluster targets: a job runs on one node, the first node that
runs its service or the node (or group)jobs.<name>.placementnames,
and joins the service's networks there; its schedule runs on that node
only.jobs.<name>.userruns the command as another user. A job a
deployment runs before it replaces a service stops the deployment when it
fails, with the job's last output in the error;mm deploy logsprints
the output of the jobs the last deployment ran. A job container a cut-off
run left behind is removed by the next deployment. -
mm service restartandmm job runwork on remote targets, for a user
at theoperatelevel or higher. A restart waits until the service is
healthy again; on a cluster target it restarts one node at a time. A job
runs in a fresh container with what the last deployment gave its service.
mm job status,mm job history, andmm job retryread and repeat
runs on the hosts. Every restart and run is in the host's audit log. -
Ingress on cluster targets. A stack's
ingress:routes work as written:
the first node (or the nodes undercluster.ingress) runs Traefik on ports
80 and 443 and sends each request to a healthy container of the service on
its own node, else on any node. The node'smmdwrites what each route
sends to from its service map, so a container that starts, fails its
health check, or leaves changes the routes at once, without a proxy
restart; the proxy mounts no Docker socket. HTTPS uses Let's Encrypt, or a
certificate the environment provides withenvironments.<env>.tls
(two secrets). The deployment plan shows the routes and the nodes. -
Autoscale on cluster targets:
autoscale: {scale: {max: 4}}on a service
keeps it betweenscale.min(default: itsreplicas) andscale.max
containers, one added when its average CPU has been above 75% for 30 s and
one removed when it has been below 40% for 5 m (metric:overrides each,
type: memorytoo).mmdmeasures, decides on the first node of the
placement that answers, and starts or drains one container at a time; a
deployment keeps the count.mm service statusshows the count, the last
change, and its reason.replicas: Non a service runs N containers over
its placement's nodes. Docker Engine and Podman hosts alike. Validation
findingMM_SCALE. -
mm service restarton a cluster target drops no request: each node
restarts its containers one at a time, and one that another container can
stand in for leaves first (out of every node's answers and ingress, its
drain), restarts, and is answered again once healthy. -
A container that leaves a cluster node (an update replaces it while the
service runs on other nodes, its service moves to another node, autoscale
removes it, ormmd container leavetakes it out; with--restartit
restarts in place and is answered again once healthy) drops
out of every node's name answers and ingress first, waits until every node
confirms, serves what it has for its service'sdrain(default1m), and
then gets its stop signal andstop_grace_period. A leave survives an
mmdrestart, andmm service statusshows the container asleaving.
This replaces the eight seconds astart-firstupdate waited. -
mm deploy cancel [OPERATION]stops what runs on a remote environment, ends
its child processes on every host, returns the hosts a deployment changed to
what they ran before, then frees the environment. A job run, and the jobs of
a cancelled deployment, stop with it and are recorded as cancelled; a
restart and a push upload stop too, and a container the deployment had begun
to drain is routed to again. Anyone who may deploy there may cancel; the
audit log names who started it and who cancelled it.mm deploy apply
prints the operation's ID first and a line every 15 seconds while a step
runs, and stops withMM_TIMEOUTnaming the host, the step, and the
operation when a host shows no progress fordeploy.progress-timeout
(default2m); a long step whose host is at work, such as a migration or a
drain, is never stopped by it.mm deploy statusand the MCP read
deploymentslist what runs on each host, with who and since when, andmm doctorreports per host how itsmmdfares, operations in flight or stuck,
child processes past their deadline, and services that have not converged. -
mm key rotatekeeps the device's access: the new key is made beside the
current one, mm offers both,mm team joinputs the new key in the entry
in place of the current one, andmm key rotate --finishdrops the old key
once the hosts were synced. A sole admin can rotate. -
mm service logsreads a service's containers on every node of a cluster
target as one stream, in the order the engines recorded the lines. Without
a service name it reads every service of the environment, and
--node NODE(repeatable) reads only the named nodes.--followpicks up
containers that start later, so a deployment does not end the stream.
--timestampsshows the engine's timestamp of each line. A node that does
not answer is one line in the stream marked with!, and the command
fails only when no node answers. Lines are ordered by each node's own
clock, so keep the nodes' clocks synchronised. -
mm service statuson a remote environment prints the deployment the
containers were started from (deployed:with the commit, time, who
applied it, the plan, and the build receipt), one line for each node when
they run different releases. Below the table it says what differs on a
node from its last deployment: a service deployed there that has no
container, or a service running there that the deployed configuration
places on other nodes. JSON hasdeploymentanddrift, also for each
entry ofnodes. -
A node that says nothing is waited for until five seconds after the first
node answered a status or a log read, and is then listed as not answering
while the other nodes' answers are shown. -
mm target nodesprints the cluster's address table under the nodes: each
network's block and each node's slice of it, and the addresses and routes
every node already uses.--output jsonhas them underaddresses, and
the MCP readnodesreturns the same. -
MM_ENGINE_API=off, in the environment ofmmor ofmmdon a host,
makes mm read status and logs through thedockercommand instead of the
Docker Engine API. The API is used only when thedockercommand would
talk to the local socket: noDOCKER_HOSTother thanunix://...and no
Docker context other than the default. Podman is asked through its
command as before. -
A remote host or a cluster can read an environment's secrets from an
external OpenBao or Vault itself, so their values never pass through the
machine that deploys.mmd secrets connectgives the host its own AppRole
credential, stored encrypted for root only;targets.<name>.providers
declares where the target's hosts reach the store. A node asks the store
only for the secrets of its own services, and rotating a secret in the
store shows as a new version in the next plan. -
File secrets rotate on Docker Compose. Each version of a secret is one
file, kept for the user mm runs as and named by a keyed digest of the
store's version. A new version replaces only the services that mount the
secret, the previous one stays until the deployment has succeeded, and a
deployment that fails mounts it again. Before, a changed file secret was
refused when the plan was applied. The first deployment after upgrading
replaces the services that mount a file secret once. -
mmdkeeps the last four hours of CPU and memory of the containers on its
node in memory, sampled every five seconds from cgroup v2 files. No command
shows them yet. -
config-fileson a service ships a file of the project, or a template
rendered from the environment's bindings, to every host that runs the
service and mounts it read-only. A changed file or binding replaces only
the services that mount it, the plan says which, and superseded versions
are removed once the deployment has finished. -
Shared volumes on cluster targets. List a stack's Compose volumes under
shared-volumesand every node that runs a service on one sees the same
directory: the target's storage node (the first node, orcluster.storage)
keeps the files in/var/lib/mm/storageand the other nodes mount them
over the WireGuard mesh, with no package and nothing to configure. The plan
shows which node keeps each volume and which nodes mount it, and a
deployment creates the directory on the storage node before it replaces a
container. Shared volumes are for files that replicas share, such as
uploads: they are slower than local disk and do not give the locking
guarantees a database needs, and the storage node is a single point of failure that mm neither
replicates nor backs up. A service withrole: databaseorrole: queue
that mounts one fails validation (MM_SHARED_VOLUME) unless it sets
allow-shared-volumes: true. See
shared volumes across nodes. -
mm target storage statusshows the storage node, each shared volume with
its size and the nodes that have it mounted, and whether every node reaches
the storage node; the MCP readstorage,mm doctor, and the terminal UI's
node list report the same.mm target storage delete VOLUMEdeletes a
volume's files after showing what it removes, and is the only thing that
does: taking a volume out ofshared-volumes, a rollback, and a failed
deployment keep them. -
A node that starts while the storage node is away starts its other services
and brings up the ones that mount a shared volume once the storage node
answers. A deployment that needs a shared volume is refused with
MM_STORAGE_UNREACHABLEbefore it changes anything when a node cannot
reach the storage node. -
Containers cannot reach the storage node's NFS port, on their own node or
through the mesh, and the storage node takes storage traffic from the other
nodes' mesh addresses only (mmd storage up, chainsMM-STORAGEand
MM-STORAGE-IN).mm target setuploads the rules on every node and has
every node prove that it can mount. -
Changing
cluster.storagewhile the old storage node holds files is
refused bymm target setup planwith the steps to move them by hand. A
target withcluster.mesh.interfaceserves no shared volumes. -
mm key protect,mm key rotateandmm key remove, each a reviewed step
(--plan HASH --yes).protectencrypts a plain key made by an earlier
mmin place and keeps its public key, so no host access changes;rotate
replaces a key and its passphrase;removedeletes both.mm key show
says how a key is protected, andmm doctorreports a plain key
(MM_KEY_UNPROTECTED), a key whose passphrase the vault no longer has
(MM_KEY_PASSPHRASE_MISSING), and a passphrase kept in a file
(MM_KEY_PASSPHRASE_IN_FILE), each with the command that fixes it.
MM_KEY_VAULTchooses the vault. See
remote access. -
mm target connectionslists the SSH connections this device keeps open
to remote hosts, andmm target connections --closecloses them. -
MM_TIMING=1prints how long each phase of a command took (configuration,
each connection, each request, each engine command), for finding what is
slow.mmdprints the same per request when the variable is in its
environment. See CONTRIBUTING.md. -
Rolling deploys and rollback across cluster nodes, with no configuration:
stacks roll out in name order and each stack one node at a time, a node is
done when its containers are healthy and every other node resolves them, and
when a node fails, every node the deployment changed returns to what it ran
before while the nodes it had not reached are never touched. The error names
the node, the service, and the container's last log lines. Optional
overrides:update: {order, parallelism, failure}on a service
(start-firststarts the new container next to the old one and stops the
old one once the new one is healthy and resolved everywhere),after:on a
stack, andenvironments.<env>.deploy.convergence-timeout(default10m),
which the plan shows. -
mm deploy rollbackplans and applies a return to what the hosts ran before
the last deployment, or before a rollout that was left unfinished. The hosts
plan the earlier commit themselves, so the checkout does not need it. -
mm deploy statusshows, per host, the last finished deployment, the one
before, and a rollout that is running or was left unfinished. The MCP read
deploymentsreturns the same, andmm target nodes,mm doctor
(MM_ROLLOUT_UNFINISHED), and the terminal UI's node list say when a node
holds one. -
One deployment at a time per environment across a cluster: a second
mm deploy applywhile one runs is refused withMM_DEPLOY_RUNNING, who
started the running one, and when. -
A cluster node that reboots runs its services again without a deployment: a
service whose Compose files set norestart:policy gets
restart: unless-stoppedon cluster targets, and the plan lists those
services. The first deployment after an upgrade recreates their containers
once. -
Deploying to a cluster of Compose hosts. On a target that lists
nodes:,
mm deploy planasks every node'smmdto plan at the same time and prints
one plan: a section per node and one plan hash over all of them.
mm deploy apply --plan HASHapplies exactly that and reports what each
node did. A node refuses a plan the hash does not cover. -
Networks that span cluster nodes. On a target that lists nodes, every
network undernetworks:inmm.yamlreaches all nodes that run a service
on it, with nothing to turn on: two services on different nodes that name
the same network reach each other by address, and containers that share no
network cannot, on one node or across nodes. Traffic between nodes stays
inside the WireGuard mesh and keeps the containers' addresses; nothing
outside the mesh reaches these networks. Each network takes a /20 of
cluster.networksand each node a /24 of it: 16 nodes per network, room for
253 containers of a network on each node, and 256 networks in the default
10.64.0.0/12. An address never changes once given, and several projects on
the same hosts never collide.mm deploy planshows the addresses, the
routes, and the firewall rules it adds or removes; mm's rules live in the
iptables chainsMM-CLUSTERandMM-CLUSTER-NAT.mm-network.service
restores them after a reboot and when the engine restarts.mm service statusandmm doctorreport a node that drifted (MM_NETWORK_DRIFT), and
the next deployment repairs it. -
Service names across cluster nodes. On a network that spans the nodes, a
container looks up<service>and gets the service's healthy containers on
its own node, or, when its node has none, on every node: a request stays on
the node when the service runs there, and moves to another node with the
next lookup when the local container turns unhealthy.tasks.<service>is
every healthy container on every node, the same answer everywhere;
<service>.<node>is one node's container, and a network alias resolves
like its service's name. Healthy means running and passing the health check, or running
when there is none: a container that turns unhealthy, and a node that stops
answering, leave the answers and come back by themselves. Nothing is
configured. Each node'smmdanswers its own node's containers on the
node's address on each network (port 53), learns the other nodes'
containers over the mesh (TCP port 7953 on the mesh address, open to the
cluster's nodes only), and passes every other name to the resolvers in the
node's/etc/resolv.conf. The first deployment after upgrading restarts
the containers of services on these networks once, to give them the node's
resolver. -
mm service statuslists what each service name resolves to on each network
of a cluster target, which nodes answer the name with their own containers
when the answers differ between nodes, the containers left out of an answer
because they are not healthy, and what keeps a node from answering names.
The same is in--output jsonundernames(each node's answer under
lookups), in a service's details in the terminal UI, and inmm_readwith
kindnames. -
dns,dns_search, anddns_optin a Compose file fail the plan with
MM_COMPOSE_DNSfor a service on a network that spans cluster nodes, where
they would have no effect. -
A network that an earlier deployment created local to a host moves onto its
cluster addresses at the next deployment: the plan says the network is
created again and names the services whose containers restart. -
mm target setup planandmm deploy planrefuse acluster.mesh.subnet
orcluster.networksthat overlaps an address or a route a node already
has, such as a provider's private network. The error names the node, the
route, and the key to set, and offers a range that is free on every node.
Acluster.networkstoo small for one network failsmm config validate
with how many networks each size holds. -
internal: trueon a network inmm.yaml: its containers reach the members
of the network and nothing else. -
mmd network show|up|leaveon a host: the addresses it stored and what
differs from them, bringing the host to them, and removing mm's firewall
chains. -
Placing services on cluster nodes. A service's
placement(a node, a group
fromcluster.groups,all, or a list) names the nodes that each run one
container of it; withoutplacementa service runs on the first node. Every
node runs one Compose project per stack with only its own services, and a
network, volume, secret, or config of the Compose file exists only on the
nodes that use it. The plan lists the services of each node, and says when a
depends_onwas dropped because the dependency runs on another node. A node
that no service is placed on takes the access change, records the commit,
and runs nothing. -
Moving a service between nodes in one plan. Change its
placement: the plan
says "starts on app-2, then stops on app-1", apply starts the service on its
new node while it still runs on the old one, and stops it there as the last
step. Volumes stay on the node they are on.--nodescannot leave out a
node a service moves to. -
On a cluster target, Compose keys that only Docker Swarm reads
(deploy.mode,deploy.placement,deploy.endpoint_mode, and
deploy.replicasabove 1) fail the plan withMM_COMPOSE_DEPLOY_KEYand what
to write inmm.yamlinstead. A Compose service without an entry under
modulesfails withMM_PLACEMENT. An environment with one host reads the
same Compose file as before. -
A relative bind mount works on every node of a cluster: each node mounts the
path from its own checkout of the deployed commit. -
--nodes NODE,...onmm deploy,mm deploy plan, andmm team syncplans
for some nodes of a cluster while another cannot be reached. The plan lists
the nodes it leaves out; they keep what they run. -
--nodes NODE,...onmm target setup planandapplysets up some nodes
of a cluster, for example to roll out a newmmwhile one node is down or
presents an SSH host key that is not trusted yet. Setup does not contact the
others; the mesh keeps their existing peers, and the storage step is skipped
when the storage node is left out. -
mm target nodeslists every node of the selected environment's target:
whether it answers and why not, itsmmdversion, its mesh address, and
the commit and time of its last applied deployment. It exits with status 3
when a node is not ready and has a JSON form. The terminal UI shows the
nodes in the Environments view and the MCP server returns them from
mm_readwith kindnodes. -
The setup plan of a cluster shows the mesh: every node's address, endpoint,
and public key, and each peer entry it adds (+), changes (~), removes
(-), or leaves alone (=). The plan hash covers it. Adding or removing a
node changes one entry on every other node; a peer that does not change
keeps its session. A removed node is named with the command that takes the
mesh off it (mmd mesh leave). -
The WireGuard private key of a node is made on that node and never leaves
it. It is in no plan, log, or command line; mm reads public keys only. -
mm target mesh statusshows every node's mesh interface and, per peer, the
endpoint, the last handshake, and the bytes received and sent, and lists
what is wrong with what to do: for two nodes without a handshake, the UDP
port that must be open between their two addresses. It exits with status 3
when a node does not answer or the mesh has a problem, has a JSON form, and
needsviewaccess.mm doctorreports the same problems, the terminal UI
shows each node's connected peers, and the MCP server returns the report
frommm_readwith kindmesh. -
mm target mesh rotate NODEreplaces one node's WireGuard key pair as a
reviewed plan: the node makes the new key, and every other node replaces
its one entry for that node. The other nodes keep their keys and sessions. -
The mesh uses one port: UDP 51820 (
cluster.mesh.port) must be reachable
between every pair of nodes. Setup says which two hosts when it is not. -
cluster.mesh.mtu(default 1420) sets the MTU of the mesh interface and is
shown in the setup plan. Setup sends one packet of that size between every
pair of nodes and stops with the setting to lower when the path drops it,
which is the failure where small requests work and large responses stall.
Networks between nodes are routed over the mesh without another
encapsulation. -
endpointon a node of a cluster target: the address the other nodes send
WireGuard packets to when it is nothost. -
mm service statuson a cluster asks every node and labels each row with
its node; a node that does not answer is listed with the reason.
mm service logs,mm service exec, andmm forwardgo to the node that
runs the service.mm team syncplans and applies on every node under one
hash. -
mm doctorasks every node of a cluster environment and reports nodes that
do not answer, are not set up, or answer under another node's name, and
nodes that differ inmmdversion or deployed commit. -
An environment whose target lists
nodes:uses thedocker-composedriver
unless a driver is configured. -
An Environments view in the terminal UI: every configured environment with
where it runs, its services, and its deployed commit.enterswitches the
terminal UI to another environment without leaving it. -
Service actions in the terminal UI.
enteron a service or one of its
containers opens a menu: follow logs (with pause, filter, wrap, and
timestamps), run a command and see its output and exit code, restart, and
open its variables. Each action also has its own key. -
Editing in the terminal UI:
aadds,eedits, andDremoves
environments, jobs, schedules, and configuration values. Each change shows a
short form and then the exact diff before it writes the file, like
mm config. -
Teammate onboarding in the terminal UI's Access view:
aadds a teammate
with their public key and a level per remote environment,echanges a
level,Dremoves them, andjrequests access for this device. After
saving, it lists the commit, merge, and deploy steps that make it effective. -
mm service restart SERVICErestarts a service's containers on a local
target. It used to report that the runtime had no restart. -
A Terminal UI page in the documentation.
-
Per-environment limits for AI agents. A new
agents:block in the project
configuration sets what an agent may do throughmm mcp servein each
environment:view,operate, ordeploy, plusexecfor all or named
services. The default isview, andmm initgrantsdeployandexecin
the development environment only. An action outside the grant returns
MM_AGENT_HANDOFFwith the exact command for the user to run. -
mm_accessandmm_execMCP tools.mm_execruns an exact argv in a
service container, without a shell, TTY, or stdin. -
mm agent status,mm agent trust, andmm agent setup. The block applies
on a machine only aftermm agent trust; an edited block grantsview
until it is trusted again.mm agent setupconnects Claude Code, OpenCode,
Codex, and Cursor to the MCP server, for a project or with--user. -
Agent keys:
mm key create --agentandmm team join --agent. A remote
host gives a key markedagent: trueits user's access limited by the
deployed commit'sagents:block, and shows it asNAME (agent). -
./install.shregisters the MCP server with Claude Code and OpenCode when
they are installed. -
Local HTTPS, the dashboard, and Mailpit on macOS with Docker Desktop. The
HAProxy forwarder, Compose autostart, and dashboard run as launchd agents of
your user, somm ingress startandstopneed no sudo there. Workstation
setup adds scoped.testDNS through/etc/resolver/test. -
mm ingress statusandmm ingress restart. -
mm target ingress configureaccepts--acme-ca-serverand
--acme-ca-certificatefor Let's Encrypt staging or internal ACME servers. -
Remote environments with access declared in the repo. A
users:key lists
each user's public keys and a level per environment (view,operate,
deploy,admin, plusexec,forward, andsecretsadd-ons). Deploys
and the newmm team syncapply it per environment. Hosts run one locked
mmSSH account whose only command is the relay;mmdrenders its
authorized_keys.mm deploy plansends a commit ID, and the host fetches it
from the project's pinned origin, enforcingdeploy-frombranch rules. New
commands:mm key create|show,mm team join|add|remove|show|whoami|sync,
mm config user, andmmd access show|block|unblock|render-keys. -
Remote deploys of images mm builds.
mm build receipt FILEwrites the latest
published build of the checkout for the environment, andmm deploy plan --receipt FILEsends it with the commit. The host checks that the receipt is
a build of that commit for that environment and matches its build settings,
deploys its digests, and records it as the commit's build for status and
logs. CI can build once and deploy with a machine key fromMM_SSH_KEY. -
modules.<name>.build.credential-only-secretsmarks build secrets that only
authenticate fetching inputs, such as a Composer token. They are still
mounted but left out of the build fingerprint, so they no longer disable
reuse of unchanged images. -
Build receipts promote between environments: a receipt built for one
environment deploys to another, locally or throughmmd, when that
environment's configuration at the receipt's commit builds exactly the same
units, and the refusal names the first module that differs. Deployment plans
record the receipt and the environment it was built for inbuild_receipt,
andmmdaudits it. Local deploys accept--receiptondeploy planand
deploy apply. -
mm build import FILE [--cache-only], a reviewed plan applied with--plan HASH --yes, records a receipt as the checkout's published build for the
environment, or with--cache-onlyonly seeds reuse so a fresh CI runner
retags unchanged images instead of rebuilding them. -
deploy-fromandinitial-deploy-fromaccept branch patterns:*matches
within one/segment and?one character, so[main, "*.x"]allows
release branches such as26.6.xand their hotfixes. -
The TUI's Access tab shows whether the environment runs locally or on a
remote target, this device's key, what the host enforces for you (level,
add-ons, and the commits it enforces and runs), the team from the users file,
and saved forwards. -
mm forward SERVICE[:PORT]reaches a remote service's port on localhost
through the mm protocol; the host's SSH forwarding stays disabled.mm forward save|list|remove|upkeeps private shortcuts with pinned local
ports. Needs theforwardadd-on for the service. -
Remote targets in the repo. A
targets:key holds each host's public
connection facts (host, port, SSH host key, daemon identity), so a fresh
clone reaches every environment withoutmm target add. Clients pin the keys
on first use and refuse a changed key untilmm target trust NAME. A private
target with the same name still takes precedence. -
Remote hosts refuse Compose features that reach the host (privileged
containers, host namespaces, devices, extra capabilities, and similar) unless
host.yamlallows one feature for one service. A host checks only the
services the planned environment runs.mm config validate --for-remote
reports them before a push, for the environment-enames or else for each
environment whose target is notlocal;--host-policy FILEchecks against
a copy of a host'shost.yamland reports what it allows. -
Split configuration files. Any top-level key except
schema-versioncan live
in.config/mm/<key>.yaml, which holds just that key's value.mm config split KEYandmm config join KEYmove a key through a reviewed plan that
must leave the configuration's meaning unchanged,mm config sourcesshows
where each key lives, andmm config schema KEYprints one key's schema.
Errors and config edits name the file that declares the key, andmm config validatewarns when git ignores a split file. -
mm target setup plan|apply --origin URL --break-glass NAME=KEYalso
installs the remote access layer:mmandmmdfrom one release
(--host-binaries), themmrelay account and sshd drop-in, the project's
enrollment in/etc/mm/host.yamlwith its pinned origin host key
(--origin-host-key), a read-only deploy key, and themmdservice. It
checks each part and prints the host key, daemon identity, and deploy key.
The newmmd access enrolldoes the host policy and deploy key part. -
mmd secrets recipientandmmd secrets import: the host side of pushing an
environment's age secrets and its git deploy key from the operator's
machine. Imported secrets keep the operator's revisions, and an installed
deploy key replaces the generated one and survives later setup runs. -
mm buildfor an environment whose target is this machine builds into the
local engine, Docker or Podman, undermm.invalid/PROJECT/MODULE:TAG, with
no registry, no login and no push.mm deployandmm dev uprun these
images withpull_policy: never; remote environments still run published
builds only. -
mm dev upbuilds first, in the plan it shows, every local image that is
missing or whose build inputs changed since its last local build, and
keeps the others. -
A build that cannot run says why and what to run: Docker, Buildx or Podman
not installed, the engine not running, or a Buildx builder whosedocker
driver cannot build several platforms, attach attestations, or write an
archive (docker buildx create --use). -
The
filesecret provider reads a secret from a file on the machine that
runs mm, such as the credentials file a package manager keeps, each time a
build or deployment needs it:storage: {provider: file, location: ~/.config/tool/auth.json}. The content is used as written, newlines
included.mm secret statusshows the path, never the value;set,
rotateandgeneraterefuse it; a relative path, a non-regular file, a
file over 1 MiB and a path inside mm's home are refused; a host never reads
it. Each line of a multi-line secret is now redacted from build and
service output too. See
read a secret from a file.
Fixed
-
A container or a job that the engine cannot start fails with
MM_RUNTIME_LAUNCHand says why in mm's words when the cause is one mm
recognizes: a mount that puts a directory onto a file, an image that is
missing or cannot be pulled, a network that does not exist, a host port or a
container name that is taken. It names the service or job and what to
change, also over MCP. A job run that could not start endsfailedwith
that message as its output instead of stayinglaunching. -
A build whose Buildx builder no longer exists fails with
MM_BUILD, naming
the builder anddocker buildx use default. A local Docker build runs on the
current Docker context's own builder, so a builder thatdocker buildx use
selected, or that was removed since, no longer affects it. -
On Docker, a
secret-filesentry'smodereaches the container: the file
has mode0444by default, so a service whose image runs as another user
reads it withoutuser: "0:0"or extra capabilities, while its directory
stays closed to other users of the machine. On a remote host the file also
belongs to the entry'suidandgid. On your own machine it belongs to
you; the plan, andmm config validatewith the warning
MM_SECRET_FILE_OWNER, name each file whoseuid,gidormodethat
can affect. Entries other than uid 0, gid 0, mode 0444 no longer fail on
Docker. -
A development mount's
protectedorexcludesentry that names a file,
such asprotected: [.env], no longer stops every container of the module
from starting. The deployment plan looks at the source: an empty
read-only file covers a file, an empty volume still covers a directory,
and a path that is not in the source is left alone instead of becoming an
empty directory in the checkout. The plan lists each path and what covers
it. -
mm deploy planandmm dev upno longer stop withexisting route ownership has no successful deployment snapshot; recover the target before deployingwhen an environment's routes on its target are not the ones its
last finished deployment recorded, such as after an apply cut off after it
saved its routes. The plan takes those routes back and says so
(adopted_route_claimsin JSON); routes of other projects and environments
still stop it. Refusals about routes name the command to run next. See
troubleshooting. -
mm doctor'sMM_HOST_RELEASE_OLDERsaid to runmm target setup plan
without--upgrade, which setup refuses for hosts on an older release;
MM_HOST_RELEASE_NEWERnow saysmm update. -
State that another release wrote no longer stops an update. A newer
mm
ormmdreads what an older one stored and moves the state database
forward; an older one ignores fields a newer one added, and refuses a file
or database whose format changed with a message that names it and says to
runmm update(or, on a host,mm target setup plan --upgrade), without
changing it. Before, records refused any field they did not know, a newer
migration said to use a compatible mm, and anmmdwhose deployment
record it could not read did not start. See
compatibility. -
Every stored schema number starts at 1:
schema-versionin
/etc/mm/host.yaml,schema_versionin/etc/mm/mmd.jsonand
MM_HOME/mcp.json, and the access policy. Adding a key no longer raises
one:mmd.jsonandhost.yamltake keys they do not know with a warning
that names them (mcp.json, which only narrows what agents may do,
refuses them), and the messages about earlier formats
(access.yaml, version 1 ofmcp.json) are gone. A host set up by an
earlier build getsmmd.jsonagain frommm target setup --upgrade; set
schema-version: 1in itshost.yamlby hand. -
Job output,
mm service logsand MCPmm_logsare redacted against the
secrets the environment hands out (its services' variables and secret
files, registry logins, tunnel token and certificate) and the other
declared secrets in the stores it uses. Before, they read every declared
secret, so on a machine with no connection to another environment's secret
store a local before-deploy job, and with itmm dev up, failed. -
A symlink, special file, or
.envfile that the ignore file excludes no
longer stops a build. One that would be sent is refused with its path in
the context and the ignore file to exclude it in, in the terminal and over
MCP. -
mm config validatechecks every environment's Compose files the way
mm deployandmm dev upcompile them and reports what they would
refuse asMM_COMPOSE_SOURCE. Before, such a file passed validation and
CI and failed first at the deployment. -
A node of a cluster no longer refuses a deployment plan for want of a
secret that only a service placed on other nodes mounts, such as the
secret file of arole: jobservice pinned to one node. -
mm target setupfor a target withoutnodes:reads the release the
host'smmdreports when it installs the remote access layer, and holds it
to the rules of a cluster node: another build or an older release only with
--upgradeor adeploy.mm-versionpin, a newer one only with
--downgrade. Before, it installed whatever it was given and ignored both
flags. -
An environment's
build-variantno longer makes a module without
build.targetsmiss its image at deployment. -
On a Podman host, a service whose user is not root can listen on a port
below 1024, as on Docker Engine: mm sets
net.ipv4.ip_unprivileged_port_start=0on each service with a network
namespace of its own that does not set it, and the deployment plan lists
them underports:. -
A remote environment whose first deployment failed can be looked into:
mm status,mm job history,mm deploy logs, and the terminal UI read
the hosts' record of the attempt instead of being refused, and a host that
never began one refuses withMM_NOT_DEPLOYED, whose message reaches an
agent as it is. MCPmm_readhas the kinddeploy_logs, what
mm deploy logsprints. -
Requests to a remote environment carried the runtime the command settled
on:mm team syncon anodes:target said podman-compose while its
deployments said docker-compose. Every request now carries the
environment's runtime. -
Small findings of the fourth pass on real hosts: a key given twice in
host.yamlis reported at both its lines instead of the first line of the
file;mm doctorreports a node whosemmdanswered and refused (another
remote protocol, a host policy it cannot read) asMM_NODE_REFUSED, with
help that points at what it said rather than atsystemctl status mmd; a
deployment saysstarted the new web next to the oldonly on nodes where
it did; an engine that hangs on a cluster node is named after the node,
notlocal; and a push upload has one ID on every node, somm deploy cancelstops all of it, and the client hearsMM_CANCELLEDrather than a
broken pipe. -
mm deploy statusended "No rollout is in progress." when no node had
answered (a client of another remote protocol, say). It now names the
nodes that did not answer as unknown, and exits non-zero with
MM_UNREACHABLEwhen none answered. -
mm target setup planfrom an oldermmplanned to install its oldermm
andmmdon nodes that ran a newer release, without a word, cutting off
every up-to-date client once applied. The plan now names, per node, the
release it replaces with which, and refuses a node that runs a newer
release unless--downgrade. Nodes report their release from this release
on, so the refusal protects hosts upgraded past it; anmmfrom before
this change still sees nothing. -
A job run whose
mm job runhad answered (once its container started)
was in no host's list:mm deploy statusdid not show it andmm deploy cancelwith its ID said nothing ran. Every host now lists the
environment's running job runs inmm deploy status(text, JSON, the MCP
read, the terminal UI), and the run's ID stops it. -
An access sync (
mm team sync,mmd access sync) while a deployment
rolled out made its reviewed plan stale at every node it had not reached
yet, even when it changed nobody's access, and the rollout failed there.
A reviewed plan now stays valid unless a grant that lets its deployer in
changed. -
mm team joinduring a key rotation looked for your entry under--name
or$USERonly, and otherwise proposed a new user with the old key; a
mm key rotate --finishafter it locked the device out. The join now finds
the entry that lists this device's key (or asks for--name), never
proposes a new user with a key another entry lists, and--finishrefuses
while the users file here lists the current key and not the new one
(--unlistedfinishes anyway). The rotation's text names root's
authorized_keys, and setup that a host refuses names the key to add. -
Two projects whose ids start with the same 12 hex digits shared their
networks, name lookups and ingress routes on the hosts they shared: the
deployment of one could take the ingress proxy off the other's network.
Setup now refuses to enroll a project whose id starts like an enrolled
project's, naming both. The names projects already have on running hosts
stay as they are. -
The terminal UI's review of a deployment to a cluster said
0 routes
whateveringress:routes the plan served; it counts the routes of the
ingress nodes now. -
In the terminal UI, an action key pressed right after it opened, while the
environment was still being read, was dropped with a note in the footer,
even when the screen already showed every node's status:ubrought no
deploy review. Such a key now waits and goes ahead as soon as the
environment is read, unless another key is pressed first. -
A deployment that moved a service to another OCI runtime, such as off
gVisor afterexposed-runtimeleft the host's policy, said nothing about
it in its plan. The plan now names each such service and the runtime it
ran under. -
A rolling restart, or a deployment, waited its whole window for a container
that stays paused. It now fails within a few looks withMM_RUNTIME_PAUSED,
naming the container and the command that resumes it. -
Two environments of one project whose names start alike, such as
stagingandstaging-eu, saw each other's networks and service names
inmm service statusandmm target nodeswhen they share nodes. Each
now sees only its own. -
Networks a deployment stopped using stayed on the cluster's nodes with
their routes andMM-CLUSTERrules. The deployment that stops using a
network now takes it away on every node once the rollout finished there,
and its plan lists it; another environment's networks stay. -
A deployment whose commit lowers its own deployer's access, such as an
agent applying a commit that gives agents onlyview, stopped after its
first step on the first node and held the environment until its lease
ran out. The deployer now finishes or aborts that rollout; everything
else follows the new access at once. -
On a cluster, the record of a
oncejob names the deployment's cluster
plan, as its runs do, whichever node started it. -
The terminal UI said "Started app on local with 0 route(s)." after a
deployment to one remote host; it names the target now. -
A deployment plan that several nodes refuse, such as one for an engine the
nodes do not run, names every refusing node, not only the first. -
mm service exec --container IDon a cluster runs the command on the node
that has the container. It asked the service's first node, which did not
find a container of another node. -
An MCP call that mm refuses in its own words, such as
mm_deploy_planwith
rollbackfor an environment that runs on this machine, or a change to the
schedules of a remote environment, now gives the agent mm's message and
code. The agent used to get a fixed text, which for a valid project sent
it tomm init. Provider output is still never passed on. -
Interrupting
mm job runof a job on a remote host prints that the run
goes on there as a note, no longer as an error. -
mm agent trust --output jsonnames the review'splan_hashand the
nextcommand, as the text output does. -
A second environment could not be set up on a cluster target that fetches
from git:mm target setup deploy-keymade it a key of its own, and the
target names one. It now copies the target's key from another environment
of the target that holds it. A node that does not run an environment yet
names the setup command in its refusal.mm target setup deploy-keyand
mm target setup recordno longer need Ansible on this machine. -
After a host moved from Let's Encrypt to a certificate the environment
provides (tls:), the ingress proxy of a cluster served the old Let's
Encrypt certificate now and then, after each change of its backends. The
deployment that switches the host now takes the old certificate out of the
proxy's ACME state and restarts the proxy once. -
A rolling
mm service restartstopped bymm deploy cancelended with
"runtime response was invalid"; it now endsMM_CANCELLEDand names the
nodes it restarted and the ones it did not reach. -
A cluster deployment failed at its second node with "reviewed remote plan
has expired" when the steps before it took longer than the plan's ten
minutes (a longbefore-deploymigration, a longdrain), and rolled the
first node back. A node now judges the plan by when it took the hold,
which every node does when the rollout starts. -
A rollout step stopped by an emergency block (
mmd access block) kept the
environment held until the step's own deadline (about 20 minutes for a
stack step); the lock now lapses a minute later, as after any step. -
mm deploy applyprinted nothing for 30 seconds while a host'smmd
was frozen: each progress line waited for its look at the host. The line
now comes every 15 seconds whatever the host answers. -
A rollback on a cluster node stopped the containers the failed step had
started while the ingress proxy and the names still sent them requests.
Where another node runs the service, they now leave first (out of the
names and routes, then the drain of the deployment rolled back to), as on
astop-firstupdate. -
An agent's
mm_deploy_applyon a cluster stopped after the MCP request
bound (request_timeout_ms, 15 seconds by default) while the nodes rolled
the plan out, and left the rollout unfinished on them. Applying a
deployment through MCP now runs until the rollout ends; every other call
keeps the bound. -
A host enrolled for push refuses a commit whose stated branches
deploy-fromdoes not allow before the upload, not after it. -
A team sync or deployment that a busy node refused lists that node as not
changed, with the reason, instead of "changed and left as it is". -
mm service logs --followon a cluster exits with an error naming the node
and the reason when every node's stream has ended with an error; it used to
exit 0. -
On a cluster target, a service none of whose containers passes its health
check is still answered by name and through the ingress, with its running
containers: such a check is more often wrong than the service. It used to
get no answer and no backend at all, so one slow engine or strict check
stopped every request.mm service status,mm deploy status, MCP and
the terminal UI say the service is answered while unhealthy, andmm doctorreportsMM_SERVICE_ANSWERED_UNHEALTHYnaming it. Leaving and
stopped containers are never answered. -
On a Podman cluster node, the first container of a network there gets its
first name lookups answered and reaches other nodes from its first
connection:mmdlistens on the network's gateway before Podman creates
the bridge with that container, and gives the bridge its settings before
answering the container's first lookup. Its first requests by name used
to fail with "bad address", then "No route to host" for a few seconds. -
mm service restartno longer restarts the container of a job that runs
as the service. That container carries the service's labels, so a restart
began a running job again from the start, and ran once more a job whose
container a cut-off run had left behind. -
mm config validaterefuses a Compose file that setsenvironmentor
env_fileon a service (MM_COMPOSE_ENVIRONMENT). It used to pass, and
the host refused the commit when it planned the deployment. -
Two
mmprocesses that open a new state database at the same moment no
longer end with one of them reportingMM_STATE_LEGACY, as if the
database came from an earlier mm. The second process read the schema
while the first was creating it. -
The terminal UI on a remote environment: editing an environment, a
variable, or the team failed withno .config/mm.yaml was found from /srv/mm/projects/..., because it looked for the configuration in the
host's copy of the project; it edits this checkout. The Overview named
that path as the root. This machine's local HTTPS and shared development
services are no longer counted as issues of a remote environment or read
for it, and the Overview shows the nodes that answer (a cluster) or the
deployed release (one host) where it shows local HTTPS for an environment
on this machine. A refresh shows each node as it answers and keeps what
the others said last, instead of waiting for every node; a service whose
node has not answered yet reads2/3withnot answered yeton that
node's row, not2/2. The Environments view checks only the nodes of the
environment on screen, not its whole status again. -
xon a service of a cluster in the terminal UI picked the first running
container of the service, on whichever node, and asked the first node of
the service to run the command in it: it failed when that container was
on another node. It now runs wheremm service execruns it. -
A
start-firstupdate of a cluster service that also joins a network
failed after 15 s, waiting for the old container's address on a network
it was never on. -
Two containers of one cluster network on the same node could not reach
each other on a host whose kernel filters bridged traffic: mm's
MM-CLUSTERchain dropped it. The next deployment adds one rule per
network that leaves such traffic to the engine's own rules. -
A rollback puts back only what the deployment changed on a host: a stack
a step started or replaced, and the services started first for a
before-deployjob. Before, every stack was applied again with the
environment of the newer configuration, so a stack the deployment had not
reached yet could restart with new environment values. -
A job run that exits non-zero on its last attempt keeps its output, so
mm job status,mm deploy logs, and a failed deployment show why it
failed. Before, the output of a failed run was dropped. -
No stuck operation can lock an environment. Every step on a host
has a deadlinemmdenforces from outside the step; a step whose client
went away is stopped at once, routes a container it had begun to drain to
again, and frees the environment; a rollout step whose client was not
heard from for two minutes (a connection that dropped without SSH
noticing) is stopped the same way; a one-host deployment is on record
from its start, somm deploy statussays whether it finished, failed
with its error, or was interrupted, also when its answer never reached
the client; and a restartedmmdmarks every request it finds
running as interrupted. A second deployment of a one-host target is
refused at once withMM_DEPLOY_RUNNINGinstead of waiting. -
A timeout is reported as
MM_TIMEOUTand a stopped operation as
MM_CANCELLED, naming the host: no longerMM_RUNTIME_RESPONSE
("restricted relay disconnected", "operation deadline exceeded"),
MM_STATE(an MCP call that ran out of time), or a missing capability (an
engine command that hung, "does not support direct_environment_delivery").
A node that failed while it prepared is reported as not changed, not as
rolled back. -
A service whose container exits right after it starts, without a health
check, fails the deployment withMM_RUNTIME_EXITED, and one the engine
keeps restarting (a cluster node's defaultrestart: unless-stopped) with
MM_RUNTIME_RESTARTINGwithin a few looks (on Podman also
MM_RUNTIME_EXITED, when a look finds it exited between two restarts),
instead of reaching the name check after 30 s as "healthy". A container
without a health check counts as healthy once it has run for five seconds. A
deployment that does not become healthy names the runtime's code next to the
service and its last log lines, and on a one-host target fails with that
code instead ofMM_RUNTIME_RESPONSE. -
An access sync waits up to half an hour for its turn behind a deployment
step, saying what it waits for, instead of failing after half a minute. -
A log read of long lines over a slow link could end with
frame length must be between 1 and 8388608 bytesalthough the lines had
arrived. -
A service is no longer shown as degraded because of an exited container
that a newer one replaced, or one that ran once for a job. Such a
container is in the status JSON with"history": true. -
mmd network showon a node reports an engine network that is on other
addresses than the stored ones, asmm service statusdoes. -
The message for a
cluster.networksrange with no room for another
network says where the key is set, as the message for a range a node
already uses does. -
A second request that changes a host can no longer wedge
mmd. Every such
request took a blocking file lock on a thread that also served every
other request and kept it until the request was done, so an access sync
or a command that arrived during a deployment could stop the daemon for
good: nothing was answered, the deployment never finished, a child
process stayed past its timeout, and systemd still reported the unit as
active. Requests that change a host now take turns without stopping a
thread, and one that is still waiting when its time is up fails with the
newMM_HOST_BUSY, which names what is in its way.mm service exec
no longer waits for a deployment. -
mmd access blocktakes effect at once, also during a deployment. It
used to wait for the running operation; now that operation is stopped
within two seconds when its key was blocked. -
Engine and git commands that
mmdstarts are ended with everything they
started when their deadline passes or when the request that needed them
is gone, and their output is read by a thread of its own. A fetch that
timed out used to leavegitrunning. -
The relay process of a client that went away exits within two seconds. It
used to wait for the daemon's answer, for ever when the daemon was stuck. -
A connection that a host dropped is no longer explained with sshd's
remark that the relay account has no home directory. -
A daemon restart in the middle of a rollout step no longer leaves the
node locked until the step's deadline (half an hour with the default
convergence window). -
mm target setupno longer fails with every task "unreachable" when
MM_HOMEis a long path: Ansible's SSH control socket did not fit, so setup
now connects without connection sharing there and retries a failed connect. -
A failed setup playbook reports the task that failed. With a recent Ansible
the error showed only deprecation notices. -
Cluster setup leaves
/etc/hostsand/etc/mm/node.envuntouched when they
are already right, and the storage node's NFS server no longer keeps
rpc.mountdorrpcbindlistening on every address. -
The terminal UI no longer offers actions a remote environment cannot
perform: stopping no longer asks for confirmation and then fails, and
enteron a variable sets it in the configuration instead of saving a
local override the host never reads. -
The terminal UI opens on a remote environment whose deployed commit differs
from your checkout, instead of failing with "configuration changed while the
TUI snapshot was being built". -
./install.shfailed to build sincemm target setupgained the remote access
layer: its build snapshot left out the packaging files thatmmembeds. -
Deployments without local TLS routes no longer require an installed local CA.
-
mm target setupselects its target and runtime like every other command:
--target,--runtime, private preferences, and the environment's settings
were ignored in favour of the project's top-level target. The plan prints
the exactmm target setup applycommand, not a nonexistent
mm target bootstrap apply. -
The HAProxy configuration reused frontend names for backends, which HAProxy
3.3 and later reject. Installed forwarders are replaced on the next reviewed
ingress reconciliation. -
sh install.shon macOS, whereshis Bash in POSIX mode. -
mm target setup applyruns Ansible with a UTF-8 locale. ansible-core 2.14
and later refused to start under theClocale setup used. -
Under
mmd.service, access changes reach sshd. The unit's read-only system
sandbox stoppedmmdfrom rewriting/etc/ssh/mm_authorized_keys, and its
UMask=0077would have made the file unreadable to the relay account. -
On Docker, mm writes files into a volume whose root another user owns with
mode 0700, such as the volumes of a managed OpenBao or Vault provider or a
volume Docker fills from an image directory. Installing a managed provider
failed withPermission denied. The helper container now runs as the owner
of the volume's root with no capabilities, and Docker writes each file with
its owner and mode. -
A managed OpenBao or Vault provider starts on Docker Compose: its Compose
file gave the options of its/tmpmount as separatetmpfsentries,
which the engine refused. -
A build secret without a usable value said only that it was unavailable.
It now says whether the secret is unset or invalid and why: anenv
secret whose variable holds a newline isinvalidand points to the
fileprovider for multi-line values.mm secret statusgives the same
reason.
Security
- A remote host checks a Compose service with what it inherits through
extendsfrom another service of the same file, under the extending
service's own name, and a host'sallowentry for the base does not cover
it. Before,extends: {service: base}let a service run a feature such as
privilegedornetwork_mode: hostthat the host never allowed for it,
also when the base itself does not run in the environment. - On a cluster node, a container on a network of its own host (the engine's
default bridge, a Compose network that is not undernetworks:) no longer
reaches the other nodes through the mesh, where it arrived with its node's
mesh address and could read their service name records. A node's mesh
address, and its address on a cluster network, no longer answer a machine
that routes them at the node's public interface. Two chains do this,
MM-MESHandMM-MESH-IN, loaded with the mesh before the container
engine starts;mm target mesh statusandmm doctorreport a node that
lacks them (MM_MESH_GUARD). Runmm target setup planand apply it to
upgrade the nodes. See
what the mesh carries. - The SSH keys
mmcreates (this device's key and the agent key) are
encrypted with a passphrasemmgenerates and keeps in the system keychain:
the Secret Service on Linux, the login keychain on macOS, and a file beside
the key on a machine with neither.mmhands the passphrase tossh
itself, so commands work as before and never prompt;ssh -i,scpand
gitcannot use the key file, and a copy of it authenticates nowhere. The
agent key's passphrase is released only insidemm mcp serve. These vaults
answer any program running as the user, so a security key remains the
boundary against one's own account; the docs say what is and is not
stopped. A connection is still kept open for this device's key. Using an
encrypted key needs OpenSSH 8.4 on the client. mm target setup deploy-keygenerates the git deploy key in memory. It
used to be written to a temporary file, unencrypted, before it went to the
secret store.- rustls 0.23.46, rustls-webpki 0.103.16, and webpki-roots 1.0.11 fix the TLS
advisories RUSTSEC-2026-0285, -0346, -0348, -0349, -0381, and -0382 in mm's
HTTPS client. - The bundled SQLite in the state database is updated through rusqlite 0.41
(RUSTSEC-2026-0459), and rmcp 3.9 fixes RUSTSEC-2026-0457, -0461, and -0462
in the MCP server.