Skip to content

v0.1.0-beta.15

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 16:15
· 343 commits to main since this release
  • Migrator: a volume-mode Postgres is no longer dumped by the database arm. With --arms all the 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 reported not-running and made the run exit partial). With --arms databases it is
    reported skipped with reason volume-mode; a hub refusal of the logical route now also reads volume-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 sans list 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 MCP import_apply tool accepts acks.

  • 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 with can't create directory '/root/.gnupg': File exists and
    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 real DockerRootDir) 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_failed instead 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 (no read: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 optional acks list (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, a git.hosts
    list in the import preflight (GitLab/Bitbucket hosts are reported as unsupported, never linked) and tugra import git-links.

  • Object migration (MinIO / S3). New Object migration screens, API (/object-migrations) and tugra objects commands
    mirror buckets between two S3-compatible stores. The TARGET server's agent runs mc mirror in a detached helper
    container of its own image (the pinned, sha256-verified mc release 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 and coolify.* / 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 new PUT /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 explicit acceptDataRisk, and the steps to stop the source app are
    printed (the Coolify token is read-only). It does not promise zero downtime; see docs/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 --certs for the migrator. migrate --certs also 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 own acme.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-in HUB_TRUSTED_PROXY_STRICT=true trusts
    only HUB_TRUSTED_PROXY_CIDRS peers; 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 is volume-diverged, never overwritten), --dry-run inventory 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 explicit volume-not-migrated exclusions. 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_CONCURRENCY and MIGRATION_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 sets TUGRA_SELF_IMAGE and 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 as traefik.* 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
    with deploy: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 (needs read: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 .env edit, 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 .env passphrase, so a database dump alone still decrypts nothing, and SECRETS_ENCRYPTION_KEY stays the root of trust (it is not rotated by this; two-factor recovery codes, hub-backup .gpg files 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 .env passphrase 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 endpoints POST /instance/secrets-key/rotate, POST /instance/secrets-key/keys/{keyId}/retire and .../restore; GET /instance/secrets-key gains 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.sh recovery 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) without encryptionEnabled now creates an AES-256 (gpg symmetric) encrypted destination, S3
    or LOCAL. Send encryptionEnabled: false to opt out; an explicit false is 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 by GET, 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=true to 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
    with enabled: true and 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 .gpg suffix, so cleartext backups written before the fix
    keep restoring, and an encrypted LOCAL volume backup is written to a .part file 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 with TUGRA_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), retentionDays and maxSizeGb; database logical backups accept maxSizeGb. 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. PUT and DELETE /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/config returns 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 with openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -md sha256), and scripts/hub-migrate.sh pack now includes destination-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 the app_move_completed,
    app_move_rolled_back and app_move_failed notifications. New endpoints POST /apps/{id}/move/preflight,
    POST /apps/{id}/move, GET /apps/{id}/moves, GET /apps/{id}/moves/{moveId}, POST /apps/{id}/moves/{moveId}/cancel
    and POST /apps/{id}/moves/{moveId}/purge-source; AppView.move is 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 exports TUGRA_HUB_ORIGIN (derived from its own configured hub URL, never
    from the hub's message) to backup-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 reports agent_too_old). New hub settings MOVE_PART_MIB (default 256, clamped 32 to 1024) and
    MOVE_MAX_CONCURRENT_RELAYS (default 2); lower MOVE_PART_MIB when 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 as preview.skipped (reason app-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-Key values starting with move: are reserved and return 400 for
    every client, like rollout:; the move's own deploys use them and are exempt from the per-app queue cap.
    Deployments gain a nullable runServerId and the move trigger (additive). After a move, a rollback target that only
    exists as a local image tag on the previous server returns 409 rollback_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 (409 server_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 BusyBox tar of 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 out root: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 compose external: / 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 mutable latest or 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_MIB makes 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.