Skip to content

v0.1.0-beta.14

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 07:22
· 452 commits to main since this 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 for KEY=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 the traefik., tugra., com.docker.compose., com.docker.swarm. and
    com.docker.stack. namespaces are reserved, and a key set both here and as --label in Custom Docker options is
    refused. Cloning an app copies its custom labels. The deployment diff shows customLabel.<key> changes without
    the values. New endpoints PUT /apps/{id}/custom-labels and GET /apps/{id}/labels, and tugra apps labels ls|set|rm|reset.

  • Changed (behaviour): Custom Docker options reject more label namespaces. --label keys in tugra.* and
    com.docker.compose.*, com.docker.swarm.* and com.docker.stack.* are refused in addition to traefik.* (a
    tugra.role label could make Tugra's own cleanup remove the app's container, and a com.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) with traefik.*, tugra.* or com.docker.compose|swarm|stack.*
    labels on a service (or in deploy.labels), or an external network named tugra-* / 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} / $VAR in
    a label key ("${P:-traefik.}http.routers.x.rule=..."), in container_name, or in a top-level network name is
    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_file that 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 raw docker compose output.

  • 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 (exec in the
    running container) is unchanged.

  • Custom label values are hidden from API tokens without read:secrets (customLabels on the app view, and
    GET /apps/{id}/labels now 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 or logs is
    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 example team/web;
    empty keeps tugra_<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 with tugra_ (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-config takes pushImageName and pushImageTag (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 with compose exec once 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-hooks takes composeHookService. 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) via POST /apps/{id}/compose-preview
    (scope read:secrets, apps:config). The agent runs docker compose config --no-interpolate, so ${VAR}
    references are shown unresolved and no environment value is sent to the agent; literal environment and
    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-interpolate on 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 with FROM after any ARGs) instead of using
    the repository's file. It is passed with docker build -f from a path outside the clone, so the repository is
    still the build context (COPY paths resolve against it and its .dockerignore applies). 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}/build takes inlineDockerfile.

  • 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-only files (it requires files; the web capabilities
    card unchecks it when you uncheck files). 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.failed row, and a request refused before dispatch (policy, capability, path, rate limit) leaves an
    app.file.denied row 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|chmod and
    DELETE /apps/{id}/files; a token needs write and read:secrets for writes and admin for delete. Needs an
    agent that advertises fs2_v1 (update the agent first; older agents answer agent_too_old). fs2_v1 is a new
    signed, expiring, replay-protected agent message; the legacy list request is unchanged.

  • files now also covers file content. The existing files capability used to allow only directory listings.
    It now also allows stat and downloading a file's content (read:secrets for tokens), still through the read-only
    helper. Grant it only where you are comfortable with writers of the team reading that application data.

  • files can be granted from the web. The server capabilities card now lists Files and File changes;
    files was previously settable only through the API.

  • Container filesystem browser and editor. For users with the terminal team permission on a server that has
    the files, files_write and terminal capabilities, an app's Files tab gains a Container (ephemeral)
    source: browse, download, replace and upload files in the running container (for example /app and /etc), with
    an editable path field and quick links. It works through docker 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's USER and file modes and can reach files the container's own user could not; rename, permissions and delete
    run mv, chmod and rm inside the container as the image's default user and report no_binary when 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
    the admin token 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/v1 rewrite 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.Root operations 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 Docker nvidia runtime, 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:ops permission refreshes an unknown or stale one automatically and can re-run detection with a button
    (GET /servers/{id}/gpus, POST /servers/{id}/gpus/refresh, capability bulk). The probe is a fixed script
    that starts an unprivileged nvidia-smi helper 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 every IMAGE_UPDATE_CHECK_INTERVAL_MIN minutes (default 360, 0 turns 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-check checks now (deploy permission, throttled to one probe per 30 seconds) and
    PUT /apps/{id}/image-update-check turns 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 gains canDeploy and the server view canOps, 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,
    $VAR and ${VAR} stay as written; other app types already pass values literally) and Multiline (PEM keys,
    JSON). PUT /apps/{id}/env takes an optional flags object (omitted keeps the stored flags, present replaces
    them; the body is now strict, so unknown fields return 400), POST /apps takes envFlags, and
    GET /apps/{id}/env-flags returns 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 one bash -c
    argument, like the other tokens in it). On Swarm they are decoded inside the container, which needs a shell and
    base64 in 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 as UID, RANDOM or BASH*, 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 as SSH_PRIVATE_KEY, GIT_DEPLOY_KEY, SSL_KEY and
    SSL_CERT are accepted. Compose lifecycle commands (stop, start, restart, logs, remove and the final ps of 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 lists auto 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 needs servers:ops on the app's server team in addition to
    apps:config. Drains travel to the agent in a signed log_drains_v2 frame gated on the logs capability; 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 driver docker logs cannot
    read is not forwarded, and previews, clones, importers and config snapshots never include drains. Behaviour
    changes: server drain PUT/DELETE now 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 be http(s) URLs (stored rows are
    not re-validated); on agents with log_drains_v2, revoking the logs capability now actually stops drain egress
    (logs is 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.