Repository navigation
v0.1.0-beta.15
Pre-release-
Migrator: a volume-mode Postgres is no longer dumped by the database arm. With
--arms allthe database row of a
Postgres set to the physical volume copy is left to the volume arm (before, it was dumped, uploaded and refused by
the hub on every run, or reportednot-runningand made the run exit partial). With--arms databasesit is
reportedskippedwith reasonvolume-mode; a hub refusal of the logical route now also readsvolume-mode. -
Cutover certificate seeding no longer overwrites a large target
acme.json. A target proxy store bigger than one
agent command result (about 48 KiB) used to be read back cut off, treated as empty and replaced, losing the ACME
account and every certificate already issued there. The store is now read in verified chunks (length and sha256
checked, up to 2 MiB), and any truncated or inconsistent read stops the seed with nothing written; the proxy is still
recreated. -
Cutover: apps and databases moved by the streamed volume copy are no longer "stateful" forever. The plan now
counts a finished streamed volume copy (an app's volumes, or a volume-mode Postgres) as its data being moved, so the
flip no longer demands the data-risk acknowledgement and keeps auto-revert for them. -
Cutover certificate transfer: staged hosts come from the certificate itself. The
sanslist sent by the
migrator is no longer trusted or stored; the hosts of a staged certificate (and what gets written into the target's
acme.json) are taken from the certificate's own names only, each checked as a valid hostname. -
Import wizard: "Review & rename" now carries what you chose on the plan step. Environment-variable acknowledgements,
per-service choices (skip, rename, placement, volumes) and the PostgreSQL "Volume copy" modes were dropped when you
continued into the review step, so acknowledged apps were skipped as blocked, a skipped service was imported anyway,
and a plan with a Volume-copy database was refused as changed. They are now sent with both the preview and the apply,
and Continue stays disabled while an acknowledgeable blocker is open or a service has no target, like the one-click
apply. The mapping preview also treats an acknowledged item as importable (its project and environment are created
and it lands there), the mapping hash now covers the acknowledgements, a plan hash no longer depends on the order the
data modes were toggled in, and the MCPimport_applytool acceptsacks. -
Backup destinations: the encryption test no longer fails at random on a fresh agent. The test's encrypt and
decrypt gpg processes run at the same time and both tried to create the gpg home on first use; on an agent that had
just started (or self-updated) one of them could die withcan't create directory '/root/.gnupg': File existsand
the destination showed an encryption failure. The gpg home is now created before the pair starts. Backup and
restore scripts run a single gpg each, were never affected and are unchanged. -
App moves: the preflight now measures the target host, not the agent's container. Free space and the device id
of the docker root (the daemon's realDockerRootDir) and of the staging disk are read through a throwaway
container with the host path bound (the helper image, or the agent's own image when the helper is not on the host
yet), so a target whose staging dir and docker root share one disk is sized with the shared-disk rule instead of the
weaker two-disk one. Ports in use on the target are listed from the host's network namespace the same way (netstat,
else/proc/net/tcp), so host listeners such as sshd, DNS or a host nginx now count in the port-conflict check and
host-port reallocation; before, the list was always empty. If the ports cannot be listed the preflight fails with
probe_failedinstead of assuming none are in use. The probe still never pulls an image. Unknown device ids are
sized as one shared disk (the stricter rule). -
Changed (behaviour): Coolify imports are strict about environment variables. The plan now reports, per app and by
NAME only (never a value), the variables an import cannot carry: unresolved or unexpanded shared variables, Coolify
magic variables, and names that are not valid environment keys. Each is a blocker you can acknowledge (per app, or
all at once) to create the app WITHOUT those variables; until then the app is not imported. A Coolify API token that
cannot read variable values (noread:sensitive) is one non-acknowledgeable blocker per app instead of silently
importing apps with missing variables. Preview-environment variables are counted and listed as not imported. The apply
request takes an optionalackslist (existing API, CLI and MCP callers that omit it now see these blockers; the
acknowledgement is the escape hatch). Dokploy and local imports are unchanged. An env value that still points at an old
Coolify service host (for example MinIO) is now listed for review in the env-remap preview instead of staying silently
unchanged. -
Changed (behaviour): imported git apps are linked by repository visibility. The old rule "link when the team has
exactly one installed GitHub source" is gone: it could link an App that cannot see the repository. Each git app is now
matched against the connected GitHub Apps (and Gitea/Forgejo/Codeberg tokens) that can actually see its repo, keyed by
the repo URL host, so https repositories link too. Zero or several matches leave the app unlinked and listed (recoverable
with Link now /POST /import/operations/:opId/git-links/relink). SSH repositories that a connected GitHub App covers are
created as their https twin; the others keep their generated deploy key, whose public key is shown on the import
timeline. New:POST /import/git-links(preview before apply), the "connect GitHub once, link N apps" panel, agit.hosts
list in the import preflight (GitLab/Bitbucket hosts are reported as unsupported, never linked) andtugra import git-links. -
Object migration (MinIO / S3). New
Object migrationscreens, API (/object-migrations) andtugra objectscommands
mirror buckets between two S3-compatible stores. The TARGET server's agent runsmc mirrorin a detached helper
container of its own image (the pinned, sha256-verifiedmcrelease is now vendored into the agent image; see NOTICE),
so the data never passes through the hub. Seed is live and copies missing keys only; the final pass (after you stop the
writers, with an explicit acknowledgement) overwrites changes, and deleting extra destination objects is off by default
behind its own acknowledgement. Verification compares keys and sizes (mc diff); it is not a content-hash check.
Object versions, IAM users and keys, replication, notifications, SSE keys and object lock are not carried. -
Coolify services import as stopped compose apps. Each Coolify service (Meilisearch, MinIO, Gotenberg, SigNoz,
Beszel, cloudflared, your own compose stacks) becomes one stopped Tugra compose app built from the service's own compose
file; nothing is deployed. Secrets are carried, never regenerated. Named volumes are declared (a host folder bind
becomes a named volume),container_name, published ports andcoolify.*/traefik.*labels are stripped and
reported, members that need the Docker socket or other host access are dropped, and config files kept next to the
compose become config mounts when the token can read them. The review screen shows a per-service verdict, members,
volumes, domains and variable names (never values), with per-service choices, and the timeline ends with a post-import
checklist. An internal-only service joins a private network under a stable alias: a newPUT /apps/{id}/compose-networks
attaches a compose service to a hub-owned network (one additive migration). Service data is still copied by hand. -
SSL/DNS cutover for imported apps. A new cutover step in the import wizard (and
tugra import cutover <opId>)
moves each imported hostname through certificate ready, DNS at source, switched, verified: it checks the app
through the Tugra proxy (Host header + SNI at the server IP), switches Cloudflare records in paced batches
(5 hosts, 30 s apart, target TTL 60 s, proxied kept, SSL mode checked) with a rollback ledger, verifies after the
switch and reverts only on request (auto-revert is off). Coolify-generated hostnames and tunnel-routed hosts are
excluded/blocked, a stateful app needs an explicitacceptDataRisk, and the steps to stop the source app are
printed (the Coolify token is read-only). It does not promise zero downtime; seedocs/runbooks/cutover.md. -
Per-host DNS-01 for custom domains. A new app domain option issues the certificate with DNS-01 per host (no
wildcard) so it exists before DNS points at the server. A server can reuse a team Cloudflare DNS credential for its
DNS-01 resolver (tugra servers dns-credential); the token is copied, so re-apply it after rotating the credential.
Existing apps' deploys and labels are unchanged. -
Opt-in
--certsfor the migrator.migrate --certsalso copies the source proxy's ACME certificates for the
op's hostnames (private keys travel to the hub, are encrypted at rest and purged after they are applied to the
target proxy's ownacme.json; the ACME account key is never sent). Off by default. -
Dependencies. The glob override moved to 14 (minimatch 11), clearing two dev-tooling advisories (minimatch
GHSA-g3hv-75wg-m249, glob GHSA-3g3m-2fjr-6pw4). The vite lock was refreshed to 8.3.8. No runtime behaviour change. -
Updater. The pre-update restore point now refuses to start when the backup directory clearly lacks free space for
the dump (nothing is changed). -
Security. X-Forwarded-For entries from a trusted proxy are now validated as IP addresses (a malformed value is no
longer recorded as the client IP or matched against the allowlist). New opt-inHUB_TRUSTED_PROXY_STRICT=truetrusts
onlyHUB_TRUSTED_PROXY_CIDRSpeers; off by default. -
Streamed volume copy for the Coolify/Dokploy migration. The one-click migrator has a volume arm
(--arms volumes|all) that copies a stopped source container's declared volumes to the target in resumable ~128 MiB
parts through the hub's memory relay: no size cap, no hub disk, owner/group/mode preserved, resumable by part (a
changed source isvolume-diverged, never overwritten),--dry-runinventory with the target's free space,
--stop-source(only that container, restarted on failure),--speedtest-mib(measures the real link before a window is chosen) and explicitvolume-not-migratedexclusions. A
PostgreSQL database can opt into a physical Volume copy data mode behind strict gates (same image and major,
credentials carried, data at the volume root, never-started destination); the dry run reports the image, major and
mount so the answer is known before any window. New Import wizard panel,tugra import volumes, hub env
MIGRATION_VX_*,MIGRATION_RELAY_CONCURRENCYandMIGRATION_TOKEN_MAX_LIFE_HOURS. Limits: one hub, device nodes
refuse the copy, xattrs/ACLs/capabilities/sockets are not copied, compose/service volumes are out of scope. The
existing database dump path, the hub-staged upload and app moves behave as before; the migrator image installer
now setsTUGRA_SELF_IMAGEand caps a volume run at 768 MiB. -
Dokploy in the Import wizard. The wizard has a source picker (Coolify or Dokploy); the URL, key and hint
wording follow the source, and the same source is used to connect, preview and apply. -
The import preview lists what is not carried over. Per app, a collapsed "What isn't carried over" list names the
fields the source has that Tugra does not carry (field names and fixed reasons, never values), including a warning
when a Coolify app was gated by HTTP basic auth, which now imports ungated. The apply timeline shows what each app
could not carry and what was applied. -
Changed (behaviour, new imports only): Coolify imports carry custom container labels and the inline Dockerfile.
Coolify imports now carry the app's custom container labels (labels in reserved namespaces such astraefik.*are
dropped and named in the timeline; a dropped access-control middleware label is flagged for review) and, for
Dockerfile apps with a repository, the inline Dockerfile text. It affects only new import operations: apps that were
already imported and existing rows are never rewritten (the executor skips DONE tasks). Imported apps are created
withdeploy:false, so labels and the Dockerfile take effect only at the first deploy. Each setter is best-effort:
a failure is reported on the task, never thrown. The token hint now notes that labels and Dockerfile text are read
at apply time (needsread:sensitive). -
Rotate the secrets encryption key from Settings without restarting the hub (data keys wrapped by
SECRETS_ENCRYPTION_KEY). Existing installs are unchanged until an owner rotates. Settings → Instance → Secrets encryption key → Rotate key makes a new random data key active immediately (no.envedit, no restart), starts the re-encrypt job by default, and lists every key with how many secrets it still protects; a replaced key can be retired once nothing uses it and restored later. The data keys live in Postgres only wrapped under your.envpassphrase, so a database dump alone still decrypts nothing, andSECRETS_ENCRYPTION_KEYstays the root of trust (it is not rotated by this; two-factor recovery codes, hub-backup.gpgfiles and file-transfer / import signatures still follow it). This supersedes the "(the hub restarts twice)" description of the earlier rotation for data keys; changing the.envpassphrase itself is still the manual restart flow, and the hub now re-wraps its data keys under the new passphrase automatically at boot. New owner-only endpointsPOST /instance/secrets-key/rotate,POST /instance/secrets-key/keys/{keyId}/retireand.../restore;GET /instance/secrets-keygains the key list (additive). -
Rollback caveat for rotated keys. After the first rotation, a Tugra release that predates the key ring cannot read values stored under a data key. Before rolling back to an older release (or relying on
update.shrecovery across such a version), use Back to .env key on the same card and let the re-encrypt finish (the card then shows the downgrade is safe). -
Changed (behaviour): post-cutover soak is on by default for new apps. New apps now default to a 30-second post-cutover soak on zero-downtime rolling deploys: the previous version is kept for 30 s and restored automatically if the new one fails 3 health checks in a row. Existing apps are unchanged (still off unless you set it); set 0 in Deploy settings to turn it off. Imported apps count as new. PR previews and compose/swarm apps are excluded. Each eligible deploy, and each fleet-rollout wave per app, takes about 30 s longer and holds the app's deploy slot for that time; a revert restarts the previous container (brief downtime). A soak-enabled app's first deploy no longer waits out the window.
-
Changed (behaviour): backup destinations are encrypted by default.
POST /backup-destinations(and the CLI and
MCP tools that call it) withoutencryptionEnablednow creates an AES-256 (gpg symmetric) encrypted destination, S3
or LOCAL. SendencryptionEnabled: falseto opt out; an explicitfalseis honoured and audited as unencrypted. The
web form already defaulted on. Existing destinations are unchanged. The implicit "server disk" path (no destination
chosen) is still unencrypted. -
Changed (behaviour): the create response carries a one-time
recoveryKey. The plaintext data key is returned
exactly once, by the create call (Cache-Control: no-store), and is never returned byGET, never logged and never
audited. The web app shows it in a "save this key" dialog with copy and download. -
Changed (behaviour): deleting an encrypted destination is guarded.
DELETE /backup-destinations/{id}returns 409
while the destination still has successful database, volume or base backups, because deleting it destroys the key
they need; pass?discardBackups=trueto confirm. Deleting a destination now also clears the app volume-backup and
hub-backup pointers (it already cleared databases), in one transaction. -
Changed (behaviour): an enabled volume schedule needs an interval or a cron.
PUT /apps/{id}/volume-backups/config
withenabled: trueand neither now returns 400 instead of silently never running. The destination must belong to the
app's team. Existing stored schedules are untouched. -
Fixed: LOCAL-type encrypted destinations stored volume backups in cleartext. Volume backups resolved a LOCAL
destination without its encryption settings. Backups now go through one shared destination resolver (also used by
database and hub backups) that fails closed when encryption is on but the key is missing, never running gpg with an
empty passphrase. Volume restore decides decryption by the.gpgsuffix, so cleartext backups written before the fix
keep restoring, and an encrypted LOCAL volume backup is written to a.partfile and renamed. -
Fixed: a missing gpg on the backup host is now an explicit failure. Encrypted backup and restore scripts check for
gpg first and fail withTUGRA_GPG_MISSING(exit 5), which becomes the backup's error message and the failure
notification, instead of an opaque pipe error. -
Added: cron schedules and age/size retention. Volume backups and the hub backup accept a 5-field cron (at most
hourly),retentionDaysandmaxSizeGb; database logical backups acceptmaxSizeGb. Prune removes whatever exceeds
the keep-N count, the age, or the total size (oldest first, sizes in GiB), always keeps the newest backup of each
volume, and logs when only protected backups remain over budget. Base backups and WAL stay under the existing
WAL-aware cleanup, and objects whose remote delete failed are not counted. -
Added: per-volume backup policies.
PUTandDELETE /apps/{id}/volume-backups/policies/{volumeName}give one
volume its own cron or interval, switch it off, or override retention. The app-wide job skips such volumes, the
missing-backup watchdog alerts per policy volume, and cloning an app copies its policies (inert until volume backups
are enabled on the clone).GET /apps/{id}/volume-backups/configreturns the schedule, policies, next run and storage
usage per size pool. -
Added: schedule preview and encryption-key export.
GET /backup-schedules/preview?cron=shows the next runs (in
the hub's timezone) and the shortest gap. The instance owner can download every encrypted destination's key in a
sealed file (POST /instance/backup/destination-keys/export, opens withopenssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -md sha256), andscripts/hub-migrate.sh packnow includesdestination-keys.json(mode 600) when hub-api is
running. The destination test also round-trips a canary through gpg with the stored key. -
Move an app to another server. An app can be relocated, with its data, to another server of the same team
(app Settings, General, Move to server). It keeps its identity: the same app ID, settings, secrets, webhooks,
scheduled tasks and history. The dialog runs a read-only preflight on both servers (disk space, tools, ports,
aliases, volumes, GPU and CPU fit, DNS and domain consequences, an optional real link-speed test), asks you to
acknowledge each consequence, and starts the move after you type the app name. The app is stopped on the old server
(checked, not assumed), each volume is packed, sent through the hub in bounded parts (verified by size and SHA-256 at
both ends, retried per part) and unpacked on the new server with ownership preserved, the app is switched to the new
server in one database transaction, deployed there, and the old container is removed. The old server keeps a stopped
copy of the data for the archive period you choose (default 7 days; Remove old copy now and an hourly sweeper
purge it, guarded when the app lives there again). Any failure before the switch leaves the app untouched on the old
server and restarts it; a failed deploy on the new server restores the app (server, generated domain, host port,
log drains) from a snapshot and restarts the old copy. A hub restart at any point ends with the app on exactly one
server (rolled back before the switch, completed or rolled back after it). The move shows live progress and a cancel
button on the app page until the switch; completion, rollback and failure fire theapp_move_completed,
app_move_rolled_backandapp_move_failednotifications. New endpointsPOST /apps/{id}/move/preflight,
POST /apps/{id}/move,GET /apps/{id}/moves,GET /apps/{id}/moves/{moveId},POST /apps/{id}/moves/{moveId}/cancel
andPOST /apps/{id}/moves/{moveId}/purge-source;AppView.moveis additive. Swarm/cluster apps, apps with previews or
linked managed databases, and apps with an active rollout or deploy are refused. -
Agent:
hub_origin_env_v1. The agent exportsTUGRA_HUB_ORIGIN(derived from its own configured hub URL, never
from the hub's message) tobackup-capability commands only, so a hub-built script can reach a signed relay path.
Update agents before moving an app; an agent that cannot update itself cleanly has to be moved by hand once
(the preflight reportsagent_too_old). New hub settingsMOVE_PART_MIB(default 256, clamped 32 to 1024) and
MOVE_MAX_CONCURRENT_RELAYS(default 2); lowerMOVE_PART_MIBwhen a proxy in front of the hub caps request bodies.
Route/api/v1/agent-vx/straight to the hub, like/api/v1/agent-fs/. -
Changed (behaviour, only while or after a move). While an app is being moved these return 409
app_move_in_progress: config edits, start, stop, restart, delete, rollback, restoring a volume backup, importing a
volume, creating or deleting a database link, and file-manager writes and moves of volume files. Manual volume
backups of the app are refused the same way and scheduled ones skip that tick. A pull-request preview webhook is
skipped and audited aspreview.skipped(reasonapp-move-in-progress). Deploys keep queueing but wait until the
move ends (a deploy that is already running when the move starts is waited out for up to 10 minutes, then the move
rolls back with the app untouched).Idempotency-Keyvalues starting withmove:are reserved and return 400 for
every client, likerollout:; the move's own deploys use them and are exempt from the per-app queue cap.
Deployments gain a nullablerunServerIdand themovetrigger (additive). After a move, a rollback target that only
exists as a local image tag on the previous server returns 409rollback_predates_move(registry and digest-pinned
deployments are unaffected); restoring a LOCAL volume backup made on a previous server returns 409
backup_on_other_server; deleting a server is refused (409server_in_active_move) while it is part of a move or
still holds a move's archived data. Deleting an app best-effort removes the old server's archive too, unless you chose
to keep its volumes: then the archive stays and the hourly sweeper removes it after the archive period. A move is also
refused while a migration import is still filling the app (migration_import_active). When a move fails and the app
cannot be restarted on the old server it stays flagged as needing attention (with a critical notification) until you
clear it with Remove old copy now, which never removes data that is live on the new server. If an unpacking step
could not be undone cleanly, the replaced data is kept on the new server as a recovery volume (shown on the move card)
until you remove it with that same button. Nothing is on by default: the migration adds one table and two nullable
columns, existing rows are untouched. -
Known limits of app moves. Downtime equals the copy time (a cold move; no incremental sync). Extended attributes,
ACLs and sparse files are not preserved. The copy is unpacked by the BusyBoxtarof the pinned helper image
(alpine:3.21): every regular file's content, mode, owner and modification time, directory modes and owners, hard
links and symlink targets are restored exactly, but the owner of a symlink itself (it comes outroot:root) and the
modification times of non-empty directories and of symlinks are not (they read as the unpack time). Exactly the same
limit applies to volume backup restores and volume imports, which use the same helper; a database does not care,
an mtime-based cache in front of a web root may. Follow-up: a helper with GNU tar would lift it. Host bind-mount data and composeexternal:/name:volumes are not
transferred (each needs an acknowledgement). Metrics and traffic history split at the move. The move deploy uses the
configured tag or commit, so a mutablelatestor a branch may resolve to something newer. Managed databases,
swarm apps, previews and the CLI/MCP surface are out of scope for now. A fronting proxy that caps request bodies below
MOVE_PART_MIBmakes the transfer fail cleanly (the app is restored); the link test only detects limits up to 16 MiB.
A compose app whose YAML publishes fixed ports cannot have them checked for conflicts on the new server (only
template-installed ports are), so a clash surfaces as a failed deploy and a rollback.