Repository navigation
v0.1.0-beta.14
Pre-release-
Container labels. The app's Configuration tab has a Container labels card. It lists, read-only, every label
Tugra applies (Traefik routing, the proxy-network pin, the stable alias, compose config fingerprints; basic-auth
hashes and the forward-auth address are hidden), built by the same code that writes the deploy scripts, and lets
you add your own container labels on classic docker-run and swarm apps, with a paste helper forKEY=VALUE
lines and a Reset to defaults button. Changes apply on the next deploy. On a swarm they are container labels
set through a rolling update, and removing or resetting them strips the old ones on the next deploy. Compose apps
declare their own labels in the compose file, and previews do not take custom labels (previews do not inherit
them from their parent). Keys in thetraefik.,tugra.,com.docker.compose.,com.docker.swarm.and
com.docker.stack.namespaces are reserved, and a key set both here and as--labelin Custom Docker options is
refused. Cloning an app copies its custom labels. The deployment diff showscustomLabel.<key>changes without
the values. New endpointsPUT /apps/{id}/custom-labelsandGET /apps/{id}/labels, andtugra apps labels ls|set|rm|reset. -
Changed (behaviour): Custom Docker options reject more label namespaces.
--labelkeys intugra.*and
com.docker.compose.*,com.docker.swarm.*andcom.docker.stack.*are refused in addition totraefik.*(a
tugra.rolelabel could make Tugra's own cleanup remove the app's container, and acom.docker.compose.project
label could spoof compose lookups). An app that already stores such a label fails its next deploy or rollback with
a message naming the label; the running container is not touched. -
Changed (behaviour): compose files may not set Tugra's labels or join its networks. A compose file (pasted,
from a template override, or cloned from git) withtraefik.*,tugra.*orcom.docker.compose|swarm|stack.*
labels on a service (or indeploy.labels), or an external network namedtugra-*/tugra_*(for example
tugra-proxy), is rejected when it is saved and on the next git deploy. Such a label could declare a route for
another team's hostname, and the network lets a service answer for every tenant's routes. -
Changed: the config snapshot records a fingerprint of each custom label value.
-
Changed (behaviour): a pasted compose file may not build reserved names through variables.
${VAR}/$VARin
a label key ("${P:-traefik.}http.routers.x.rule=..."), incontainer_name, or in a top-level networknameis
rejected when the compose is saved, because compose substitutes it only at deploy time and the reserved-namespace
checks would never see the result; label values keep working with variables.label_file, and a service
env_filethat points at a sensitive host path, outside the compose directory or through a variable, are rejected
too, and the compose preview returns a fixed error message instead of the rawdocker composeoutput. -
Compose deploy hooks: the pre-deploy one-off container is started with
traefik.enable=false, so it can no
longer register as a Traefik backend of the live router during a deploy. The post-deploy hook (execin the
running container) is unchanged. -
Custom label values are hidden from API tokens without
read:secrets(customLabelson the app view, and
GET /apps/{id}/labelsnow needs that scope). -
Log drains: fixes. Drain pushes to one server are serialized, so an older drain set can no longer reach the
agent with a newer revision. The agent bounds the total size of a fluentd acknowledgement or handshake reply, retries
a connection that drops during the fluentd handshake (instead of reporting a configuration error), reports a sink
that requires user authentication as such, stops an in-flight HTTP delivery when the drain is removed orlogsis
revoked, and counts GELF messages it cannot send as dropped and syslog lines cut to the size limit as truncated.
Changing a drain's type in the edit form clears its stored token. Old custom-named image tags stay reclaimable
after the image name is cleared. -
Custom pushed image name and an alias tag. On an Image or Git app that pushes to a team registry, Build &
registry now takes an Image name (a repository path under the registry namespace, for exampleteam/web;
empty keepstugra_<app id>) and an optional Alias tag template (latest,{branch},{branch}-{sha};
{sha}is the first 12 characters of the built commit and, like{branch}, is for Git apps only). The immutable
:<deployment id>tag is always pushed and is still what the deployment records and what a rollback pulls; the
alias is an extra, registry-side tag that moves on every build (last built, not last deployed), and a rollback
does not move it. A registry that enforces immutable tags rejects the alias and the deploy fails before the swap
with the old version still serving; clear the alias tag for such a registry. An alias can never take a
deployment-id shape, and a name can never start withtugra_(reserved for default repositories). A repository can
belong to one app per registry (a clash returns 409), and clearing the registry or push clears the name and alias.
PUT /apps/{id}/build-configtakespushImageNameandpushImageTag(undefined keeps, null clears); both are
returned on the app view and recorded in the deployment's config snapshot. Cloning an app no longer shares them:
the clone pushes to its own default repository, because a copied name would be rejected by the unique index and a
copied alias would let two apps race on one tag. -
Fixed: cleanup of pushed local image tags is anchored on the app's own deployment ids. Removing the local copy
of a pushed image (a failed or cancelled deploy, adoption, keep-N pruning) used to match only the
tugra_<app id>:namespace; with a custom repository name it now also accepts a tag whose version is one of the
app's own deployment ids, and never any other image. Apps without a custom name run the same cleanup as before. -
Pre/post-deploy commands for Compose apps. The Pre/post-deploy commands card now appears on single-server
Compose apps with a service picker (a dropdown for a pasted compose file; a text field plus Detect services
for a git-sourced one). The pre-deploy command runs in a one-off container of that service after its image is
pulled or built and before the stack is brought up; a failure fails the deploy with the current stack still
serving. It does not use--no-deps: the service's dependencies are started first so a migration can reach its
database, including on the first deploy, and if the command fails those dependencies keep running (the service
itself is never recreated). The post-deploy command runs withcompose execonce the service is running (and
healthy, when it has a health check) and is best-effort: a failure is logged and never fails the deploy. Both are
part of the one durable deploy command, so a hub restart recovers them with the deploy, and a rollback runs
neither. The service must exist in the compose file: a pasted file is checked when the hooks are saved and when the
file is edited (a file that drops the hooked service is refused); a git-sourced file is checked against the
rendered stack at deploy time.PUT /apps/{id}/deploy-hookstakescomposeHookService. Apps without hooks deploy
exactly as before. -
Resolved compose preview. Compose apps (pasted or from git) get a Preview resolved compose button that
shows the file as Compose resolves it (anchors,extends, normalisation) viaPOST /apps/{id}/compose-preview
(scoperead:secrets, apps:config). The agent runsdocker compose config --no-interpolate, so${VAR}
references are shown unresolved and no environment value is sent to the agent; literalenvironmentand
build-argument values are replaced with<redacted>on the hub, as is any of the app's environment values found
elsewhere in the file. The preview never touches the running stack's files (a git preview clones into a private
temporary directory that is removed afterwards), is not cached, and is not exposed through MCP. It needs a Docker
Compose that supports--no-interpolateon the agent (422 otherwise), and the Tugra routing override added at
deploy is not shown. -
Inline Dockerfile for Dockerfile builds. A Git app built with a Dockerfile can store the Dockerfile text on
the app (Dockerfile source: Inline, up to 48 KiB, must start withFROMafter anyARGs) instead of using
the repository's file. It is passed withdocker build -ffrom a path outside the clone, so the repository is
still the build context (COPYpaths resolve against it and its.dockerignoreapplies). It is not a repository-free
app; the Dockerfile path stays stored and is used again when the inline text is cleared. The text is visible only to
members who can edit the app, is never part of the config snapshot or MCP results (only its size and a
fingerprint), and is copied by clone and by PR previews.PUT /apps/{id}/buildtakesinlineDockerfile. -
File manager: upload, edit, rename, permissions and delete on app volumes. A new opt-in server capability,
files_write, adds write access next to the existing read-onlyfiles(it requiresfiles; the web capabilities
card unchecks it when you uncheckfiles). With it, an app's Files tab can upload files (multi-select or drag
and drop, two at a time, with progress, cancel and retry; a file that already exists asks Overwrite or Skip),
create folders and files, edit text files up to 1 MiB in place (a concurrent change shows Reload or Overwrite
anyway), download, rename, change permissions (an rwx grid kept in sync with the octal value; setuid, setgid and
sticky bits cannot be set) and delete (a folder is a recursive delete and asks you to type its name). Writes run in
a short-lived, network-less helper container with only that one volume mounted read-write and only the CHOWN,
DAC_OVERRIDE and FOWNER capabilities; new files get the owner of the folder they land in, so the app user can read
them, and an overwrite keeps the file's owner and mode. An upload is hashed by the hub, pulled by the agent over a
single-use signed URL, written to a temporary file in the same folder and renamed into place, so an interrupted or
tampered upload leaves nothing behind. Symbolic links are never followed or written through. Every change is
audited with its path and shape, never its content: a change that was dispatched and then failed leaves an
app.file.failedrow, and a request refused before dispatch (policy, capability, path, rate limit) leaves an
app.file.deniedrow with its path and reason code (a busy server leaves none). Changes are paused while a deploy is queued or running, and writing into a running
database or broker volume (detected from its image or template) needs an explicit acknowledgement. API:GET /apps/{id}/files/meta,
GET /apps/{id}/files/stat,GET|PUT /apps/{id}/files/content,POST /apps/{id}/files/mkdir|rename|chmodand
DELETE /apps/{id}/files; a token needswriteandread:secretsfor writes andadminfor delete. Needs an
agent that advertisesfs2_v1(update the agent first; older agents answeragent_too_old).fs2_v1is a new
signed, expiring, replay-protected agent message; the legacy list request is unchanged. -
filesnow also covers file content. The existingfilescapability used to allow only directory listings.
It now also allows stat and downloading a file's content (read:secretsfor tokens), still through the read-only
helper. Grant it only where you are comfortable with writers of the team reading that application data. -
filescan be granted from the web. The server capabilities card now lists Files and File changes;
fileswas previously settable only through the API. -
Container filesystem browser and editor. For users with the
terminalteam permission on a server that has
thefiles,files_writeandterminalcapabilities, an app's Files tab gains a Container (ephemeral)
source: browse, download, replace and upload files in the running container (for example/appand/etc), with
an editable path field and quick links. It works throughdocker cp, so it also works on stopped and distroless
containers. Reads, writes and new folders are performed by the Docker daemon as container-root, so they ignore the
image'sUSERand file modes and can reach files the container's own user could not; rename, permissions and delete
runmv,chmodandrminside the container as the image's default user and reportno_binarywhen the image
does not ship them. Changes are lost when the container is recreated, writes are not
atomic, and a very large directory lists only its first part. Clustered apps are not supported. Every change needs
theadmintoken scope. API:GET /apps/{id}/container-files[/stat|/content],PUT /apps/{id}/container-files/content,
POST /apps/{id}/container-files/mkdir|rename|chmod,DELETE /apps/{id}/container-files. -
Large uploads through the web origin. The web server's generic
/api/v1rewrite buffered request bodies in
memory and cut them at 10 MiB, so a larger upload hung. File uploads and the agent transfer URLs now stream
through dedicated routes with real backpressure, and the generic proxy is a fallback rewrite. An upload that trickles in below a minimum
throughput is cancelled, each user may have two uploads in flight per server, a busy server no longer burns the rate
limit or audit log, a deploy that starts while a body is being received pauses the write, and the web hop to the hub
idles out after 11 minutes (HUB_PROXY_TIMEOUT_MS) instead of fetch's 5. -
Agent toolchain. The agent now builds with Go 1.25 (the file helper needs
os.Rootoperations that arrived in
that release). Overwriting a file replaces its inode, so hard links, extended attributes and ACLs of the old file
are not carried over. -
GPU detection. A server's page has a Detected GPUs card: GPUs found on the PCI bus, the NVIDIA driver
and the Dockernvidiaruntime, and one verdict (ready, driver missing, runtime missing, non-NVIDIA, none, probe
failed). The result is stored per server, so read-only members see the last snapshot; a member with the
servers:opspermission refreshes an unknown or stale one automatically and can re-run detection with a button
(GET /servers/{id}/gpus,POST /servers/{id}/gpus/refresh, capabilitybulk). The probe is a fixed script
that starts an unprivilegednvidia-smihelper container from the agent image (no network, read-only,--pull never) under its own timeout. BMC and hypervisor display adapters (ASPEED, Matrox, VMware, virtio, QEMU, Hyper-V
and similar) are listed as virtual displays, not as GPUs. On an app's Resources card the GPUs field now shows
what was detected on its server, one-click values (all, a count,device=<index or UUID>) and a soft warning
when the value does not match; it never blocks saving. Cloning an app that requests GPUs to a server with no
detected NVIDIA GPU keeps the setting and warns. Servers that were never checked read "Not checked yet", never
"no GPU". -
Pull request previews from GitLab, Gitea, Forgejo and Bitbucket. The per-app webhook now recognises
merge/pull-request events from GitLab, Gitea, Forgejo and Bitbucket (Cloud and Server) as well as GitHub, by
their own event headers, and creates, updates and removes the preview like the GitHub path. Responses carry a
reason(shown in the provider's delivery log) when nothing happens. Behaviour changes: pull requests from a
fork (or with an unknown head repository) are now ignored on every provider, including GitHub, because the
preview builds a branch of the parent repository with the parent's environment and credentials; previews are
created only for Git-built apps (a close event still removes an existing preview); for non-GitHub providers the
event's repository must match the app's repository; a Bitbucket "updated" event rebuilds only when the head
commit changed. Push webhooks are unchanged. -
Image update check for Image apps. An app deployed from a registry image now shows whether its tag has a newer
image upstream: an Image updates card on the overview (Up to date, A newer image is available, Pinned,
Redeploy once to record the digest, and so on), an Update available badge, and a Pull & redeploy button for
members who can deploy. The server the app runs on asks the registry for the tag's manifest digest (the hub never
contacts a registry) and compares it with the digest recorded at the last successful deploy; credentials stored
on the app are used. Apps are checked everyIMAGE_UPDATE_CHECK_INTERVAL_MINminutes (default 360,0turns the
feature off for the whole hub) and again after each deploy; repeated failures back off to once a day.
POST /apps/{id}/image-update-checkchecks now (deploy permission, throttled to one probe per 30 seconds) and
PUT /apps/{id}/image-update-checkturns it off or on for one app. A new notification event,
image_update_available, fires once per new upstream digest; the first check after an upgrade only records the
baseline, so upgrading produces no notifications. Digest-pinned references are never checked, and editing the tag
shows no verdict until the next deploy. The app view also gainscanDeployand the server viewcanOps, so the
UI can hide actions the API would refuse. -
Per-variable environment flags. Each variable of an Image, Git or Compose app can now be marked
Build time (Git apps: passed to the image build as--build-arg/ builder--env; with Available at runtime
off it is build-only and never reaches the running container), Literal (Compose: the value is not expanded,
$VARand${VAR}stay as written; other app types already pass values literally) and Multiline (PEM keys,
JSON).PUT /apps/{id}/envtakes an optionalflagsobject (omitted keeps the stored flags, present replaces
them; the body is now strict, so unknown fields return 400),POST /appstakesenvFlags, and
GET /apps/{id}/env-flagsreturns the stored flags. Multiline (and, on Compose, Literal) values are delivered by
name through the Docker CLI's own environment (env KEY=... docker ...): they are never written to the env file
and never a docker argument (the base64 payload is part of the deploy script, which travels as onebash -c
argument, like the other tokens in it). On Swarm they are decoded inside the container, which needs a shell and
base64in the image; the deploy fails with a clear error otherwise rather than falling back to plain env. The
name of a multiline or Compose-literal variable must be a plain identifier and must not be one that changes how
Docker runs:PATH,HOME,TMPDIR,LD_*,DYLD_*,DOCKER_*,COMPOSE_*,BUILDKIT_*,BUILDX_*,
XDG_*,*_PROXY,SSL_CERT_FILE/SSL_CERT_DIR, shell-special names such asUID,RANDOMorBASH*, and a
short list of ssh and git names that make a process run a program (SSH_AUTH_SOCK,GIT_SSH_COMMAND,
GIT_ASKPASS,GIT_CONFIG_*and similar); names such asSSH_PRIVATE_KEY,GIT_DEPLOY_KEY,SSL_KEYand
SSL_CERTare accepted. Compose lifecycle commands (stop, start, restart, logs, remove and the finalpsof a
deploy) carry the same variables, and when every variable is moved out of the env file the previous plaintext file
is removed. A deploy script that would exceed the one-argument size limit now fails up front with a clear error
for multiline, build-time and Swarm deploys. Apps with no flags deploy exactly as before. Variables from a Vault
secret reference cannot be build-time or build-only. The Coolify importer carries Coolify's four flags, imported
and adopted values with line breaks are marked Multiline, and Dokploy build arguments map to Build time. -
A line break in an environment value no longer corrupts the env file. A value with a line break that is not
marked Multiline - data stored before this release, or reachable through shared variables, the importer, MCP or
the migrator - used to add extra variables to the env file. Saving such a value without the flag is refused (400).
Values already stored that way keep deploying: at deploy and rollback time they are delivered as Multiline
automatically (the deploy log listsauto multiline: KEY, nothing is rewritten); only a value whose name cannot be
a multiline variable, that contains a NUL, or that exceeds 16 KiB fails the deploy, with an error naming the
variable. The same fail-closed check now covers every env-file writer, so an empty,=, CR, LF or NUL in a key,
or a line break in a DNS-challenge credential or a service variable, is refused with the credential named.
DNS-challenge credentials are validated when saved (a single line per value, trailing whitespace trimmed) and
already-stored ones with a trailing newline are trimmed when the proxy is rendered, so they keep working. Shared
variables reject line breaks when saved. -
Per-app log drains, container filter and syslog / GELF / fluentd targets. An app's Logs tab has a Log
drains card: a drain scoped to one app ships only that app's containers (its container, its rolling-deploy
twin, compose services, swarm tasks on every member server), never other apps or databases. Compose apps that
are not deployed to a swarm can narrow a drain to named services; a server-wide drain can narrow itself with
container name patterns. New targets next to HTTP, Loki and Datadog: syslog (RFC 5424 over UDP, TCP or TLS),
GELF 1.1 (UDP with gzip/zlib and chunking, TCP, TLS) and fluentd Forward (TCP or TLS, acknowledgements, optional
shared-key handshake), all written without third-party libraries, with per-sink queues so a dead sink never
stalls the others. Each drain shows a delivery state (delivering, waiting, agent offline, agent update required,
failing with a failure class, and so on) from the agent's own reports, and a server's Log drains tab lists the
app drains shipping from it (name, type, app, delivery; never the endpoint). Egress is restricted: cloud metadata
and link-local addresses are blocked for per-app drains and for server-wide syslog, GELF and fluentd drains
(server-wide http, loki and datadog drains keep their previous unguarded reach), and per-app drains cannot reach loopback, private or CGNAT ranges
unless Allow private network targets is set, which needsservers:opson the app's server team in addition to
apps:config. Drains travel to the agent in a signedlog_drains_v2frame gated on thelogscapability; an agent
without it receives only plain server-wide http/loki/datadog drains (exactly as before) and shows Agent update
required for the rest. Upgrade the hub first. See Log drains for the guarantees: delivery
is best-effort and at-least-once, lines emitted while the agent is disconnected are lost, UDP cannot confirm
delivery, boundary lines can repeat after a tail restart, a container using a log driverdocker logscannot
read is not forwarded, and previews, clones, importers and config snapshots never include drains. Behaviour
changes: server drainPUT/DELETEnow return 404 when the URL's server id does not own the drain (it was
ignored); http, loki and datadog endpoints written through create/update must behttp(s)URLs (stored rows are
not re-validated); on agents withlog_drains_v2, revoking thelogscapability now actually stops drain egress
(logsis granted by default, so default setups are unaffected); the agent keys log tails by container id, reads
stdout and stderr as separate streams and may reorder lines slightly inside a batch; the drain views gain
additive keys (scope,appId,containers,options,allowPrivate,delivery,status). -
Log drains: fixes. A container that restarts quickly is tailed again (the old tail was never removed), a
line longer than 1 MiB no longer stops its tail, and deleting an app re-pushes the drains of the servers it was
shipping from.