Skip to content

Releases

v0.1.0-beta.17

v0.1.0-beta.17 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 20:36
  • "Update now" shows what it is doing. Settings → Updates has a four-step progress view (queued, pulling,
    recreating services, reconnecting and verifying the version) with an elapsed timer and the target version, and
    a Reload button once it finishes. "Check for updates" and saving the update settings now confirm with a toast.
  • No more raw "Failed to fetch" while the hub restarts. A network failure or proxy 502/503/504 now reads
    "Hub is restarting or unreachable", an amber banner watches for the hub to answer and refreshes the page data,
    identical error toasts within two seconds show once, and the enroll-token re-issue and "Log out everywhere"
    buttons report failures instead of hanging.
  • Clicks now answer for apps, databases and the rest. Volume Restore asks first, shows "Restoring…", locks every
    Restore button while it runs and toasts start and finish (it can no longer fire twice); backups, monitor checks,
    channel tests, swarm form/join/add-manager, license activation, environment moves and the tunnel and DNS-01
    switches end in a named toast; cutover Prepare, Check, Lower TTL and Finalize show a spinner and report counts;
    regenerating or removing a deploy key is confirmed and Copy says "Copied"; deleting a token, source, registry,
    credential, variable, saved view, project or team names what went; the Home sheet reuses the keyed Restart,
    Start and Stop toasts.
  • Updates reach beta testers. Signed update checks are now on by default (hourly and whenever the panel is
    opened; --no-update-checks or TUGRA_UPDATE_CHECKS=0 opts out, UPDATE_CHECK_INTERVAL_MIN tunes the interval),
    the release channel follows the running build (a beta hub tracks beta, shown as "Automatic (Beta)" in Settings →
    Updates; pin Stable or Beta to override, and an existing hub left on the old default switches to automatic), the
    card records when it last checked and why a check failed, and auto-update now applies the next beta of the same
    series as well as stable patch releases. Beta → stable and minor/major still wait for you. Hubs on beta.16 or
    older take this one upgrade manually (git pull && ./scripts/install.sh).
    The card also shows how often checks run and disables "Check for updates" with an explanation when checks are
    turned off for the deployment.
  • Restart, Start and Stop now say what they did. A restart finishes with the app still "Running", so the
    click looked like nothing happened; each lifecycle action now ends in a named toast ("Gitea restarted.") or an
    error toast, never silence.
  • Server page actions now confirm themselves. Proxy start, stop and restart end in a toast, network settings and
    proxy dynamic-config saves say "Saved", the Cloudflare Tunnel connect and disconnect show progress and a result,
    and the proxy refresh icon spins and has the right label. "Update agent" shows a restarting state until the new
    version reports in, then toasts it. OS patching toasts when an apply finishes (or fails), flags a pending reboot,
    and the per-package Update button shows its own loading state.
  • Sidebar footer is two short rows and the scrollbars follow the theme. Sponsor is a small distinct pill,
    What's new and Documentation are icon buttons beside it, and Log out and Collapse share a row, so the
    navigation above keeps its room (five stacked rows before). Scrollbars everywhere are thin and tinted from the
    theme tokens instead of the browser's grey default.

v0.1.0-beta.16

v0.1.0-beta.16 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 18:22
  • Settings → Appearance: make the panel look the way you like. A new tab holds per-user, browser-local choices:
    colour theme (Light, System, Dark, or Custom with Tugra Gold / Slate / Forest / Rose presets plus accent and
    surface-tint pickers), UI scale (80 / 90 / 100 %, always 100 % on phones), page width (Full or Centered),
    navigation style (Default or a Floating framed sidebar), a 3D or Flat style, and "Your time + UTC" for chart
    tooltips and deployment timestamps. Everything is applied before first paint, so a reload never flashes the defaults.
  • Deployments show progress and readable logs. RUNNING and QUEUED deployment rows (list and detail header) now
    carry a spinning icon, and build/deploy logs tint ERROR and WARN lines the same way the live container logs do
    (the text is untouched, so copy still yields the original log).
  • Apps and Projects lists can be sorted, and tags filter. A sort bar (name, status, project for apps; name,
    resources, created for projects) toggles direction on a second click and is keyboard-operable. Tag chips on the
    apps list are now buttons that filter the list to that tag (the app name remains the link into the app), and a
    project's environment resources get the same tag filter bar.
  • API tokens show expiry and can be renamed or rotated. Each token lists when it expires, with an amber "N days
    left" badge at 14 days or fewer and an "Expired" badge once past; tokens can be renamed inline and rotated (the
    new secret is shown once, the old one stops immediately) from the existing endpoints, and the create form takes an
    optional expiry in days.
  • Patching warns before restarting the container engine. When the pending updates include docker-ce,
    containerd.io or runc, the server's patching card says applying them restarts Docker and with it every app
    and database on that server.
  • "Disabled" is visible on scheduled tasks and per-volume backup policies. Switched-off rows now carry a
    Disabled badge instead of relying on an unchecked box or muted text.
  • What's new, Documentation and Sponsor in the sidebar. Three links above Log out: the GitHub release notes of
    the running version, the in-repo docs, and the sponsor page.
  • The running version is always in view, and the logo goes home. The sidebar logo is now a link to the
    dashboard, and the running version (v0.1.0-beta.N) sits under the product name — in the logo's tooltip when
    the sidebar is collapsed. Every signed-in member sees it, not only the owner: a new session-guarded
    GET /api/v1/instance/version returns the version, channel and whether a newer release is published (no
    preferences, and nothing for anonymous visitors).
  • "Update available" is shown to every member. The top-bar pill no longer hides from non-owners; for them it
    is a status whose tooltip says the instance owner applies updates from Settings, while the owner's pill still
    opens the Updates card.
  • App header: the Restart (and Start) icon is visible again. The icon's amber/green tint was painted on the
    gold primary fill and vanished. A tinted icon now applies only on quiet (ghost) buttons; on a solid fill the
    icon keeps the fill's contrast colour.

v0.1.0-beta.15

v0.1.0-beta.15 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 16:15
  • 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
    lon...
Read more

v0.1.0-beta.14

v0.1.0-beta.14 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 07:22
  • 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 o...

Read more

v0.1.0-beta.13

v0.1.0-beta.13 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 14 Nov 22:50
  • No container-log stream before the first deploy. The Logs tab of a never-deployed app no longer opens a
    docker logs --follow on a container that does not exist yet (it used to print "No such container" on every
    reconnect). The card says that container logs appear after the first deploy; GET /apps/{id}/logs/stream and
    /logs/download answer 409 for an app in the NEW state.

  • Cleanup options when deleting an app. The delete dialog can also remove the app's custom Docker networks
    and prune dangling build cache. Networks are removed only if Tugra created them (they now carry a
    tugra.managed=true label), no other app on the server lists them and nothing is still attached; tugra-proxy,
    tugra-net, tugra-apps and networks you made by hand are never touched. Networks created before this release
    have no label (Docker cannot add one to an existing network) and are left in place. The build cache is
    host-wide, so it is pruned on the build server (or the app's server) and may make another app's next build
    slower. The API takes pruneNetworks=1 and pruneBuildCache=1 on DELETE /apps/{id}, and all four delete
    query parameters are now documented as optional.

  • More resource limits for Image and Git apps. Memory plus swap, a maximum process count, shared-memory
    size, CPU weight and CPU pinning, next to the existing memory and CPU limits. They are docker run flags, so
    Compose and Swarm apps refuse to set them (clearing is always allowed); the Resources card shows them for
    single-server apps. Unset, the run line is unchanged. A flag you also set in Docker options takes precedence.
    A rollback re-renders from the current settings, so it applies today's limits, not the ones from the deploy
    being restored.

  • Honest app status. The app header, list and Overview now read from the container-health poll: Running,
    Running (unhealthy), Running (no healthcheck) or Starting, instead of the lifecycle status alone. A
    crash-looping container shows as unhealthy; missing or stale data never raises an alarm. HTTP and auto health
    checks still gate deploys only, so an app that relies on one reads plain Running. The app API gains
    containerHealth.

  • Per-app container operations and networking. Set a graceful stop window (--stop-timeout, also used by
    deploy swaps, Stop and Restart), a drain pause for zero-downtime deploys (both versions keep serving for N
    seconds before the old one stops), a cap on on-failure restart retries, a stable container name that
    resolves on every network the app joins, and extra Docker networks per app. The app page shows the internal
    address other containers can reach it on. Unset, nothing about a deploy changes.

  • Behaviour change: apps without a domain now join the shared tugra-apps network. A classic Image/Git app
    with no domain, no managed-database link and no --network in its Docker options is created on a per-server
    tugra-apps bridge on its next deploy instead of Docker's default bridge, so apps on the server can reach
    each other by container name. Anything that relied on default-bridge addressing (the docker0 gateway, a
    fixed bridge IP) must be adjusted; add --network in the app's Docker options to keep full control.

  • Git and build settings per app. Git submodules, Git LFS, shallow clone, disabling the build cache, passing
    env vars as build arguments, and a source commit mode (SOURCE_COMMIT off / runtime / build and runtime). Two
    behaviour changes for existing Git apps on their next deploy: the container now gets a runtime SOURCE_COMMIT
    env (a SOURCE_COMMIT you set yourself wins; Build settings, Source commit, Off opts out), and the clone
    exports GIT_LFS_SKIP_SMUDGE=1 unless Git LFS is enabled, so LFS files stay pointer stubs (the build log
    warns when .gitattributes uses LFS). Submodules and LFS authenticate with the app's token for any repository
    on the same git host; previews never clone submodules or pull LFS. The agent image now ships git-lfs.

  • Breadcrumb shows the environment. App and database pages now read Projects, project, environment, then the
    resource, and the environment crumb jumps straight to that environment's card on the project page.

  • Clone an app into another environment. The clone dialog now has an Environment picker (this team's
    environments, defaulting to the app's own) and shows what was not carried over once the clone is created. The
    hub also checks the caller's access to the destination project when moving or cloning an app to another
    environment.

  • Link a Git provider from the app's Source card. Pick a connected provider (GitHub App, Gitea, Forgejo,
    Codeberg) for a Git or Git-compose app, or unlink it, without leaving the app. Only this team's providers for
    the repository's host are offered, and a linked provider takes precedence over a stored personal access token.
    GET /git-sources now also returns each source's cloneHost.

  • "Links" menu in the app header. Apps with more than one address (alias domains, per-service domains on a
    compose app, published compose ports) get a "Links (n)" menu that opens each one in a new tab, visible to every
    viewer; the Overview's Live URL row lists them all. Apps and GET /apps responses gain a links array (primary
    first); per-service domains are included on GET /apps and GET /apps/:id only.

  • Analytics tab on every app. The same visitor analytics as the Traffic page (requests, status classes,
    bandwidth, latency, unique visitors, countries, paths, browsers), scoped to the app's own primary, alias and
    per-service domains, with a domain picker and clear empty states (no domain, analytics off on the server, no data
    yet). GET /traffic/* gains an appId filter that needs access to that app and can only narrow, never widen,
    what a caller sees. A clustered app shows traffic recorded on its own server only.

v0.1.0-beta.12

v0.1.0-beta.12 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 14 Nov 16:47
  • Per-deployment detail page. Every deployment row opens its own page: a queued → started → finished
    timeline with queue wait and run time, who or what triggered it, the deployed commit (linked to the
    repository), image tag and digest, the configuration diff against the previous deployment, the full build
    log (following live while the deploy runs), and cancel / roll back / analyze actions — with honest notes
    when a deploy was interrupted, recovered, auto-rolled-back or cancelled. The deployments list no longer
    carries every build log, so the app page polls far less data.
  • PostgreSQL point-in-time recovery. Enable PITR per database: WAL archiving is turned on with a verified
    restart, segments are shipped to the database's backup destination, physical base backups run on demand or
    on a schedule, and the panel shows the recoverable window with a picker to restore to any second into a new
    database. Retention is WAL-aware so a restorable base is never left without its WAL.
  • Restore-verify drills. Prove a backup restores: on demand or on a schedule, the latest backup is
    restored into a disposable database and the result is recorded on the source; a watchdog alerts when the
    drill stops running or starts failing.
  • Fleet rollouts. Deploy a release across many apps as canary → waves with a per-app health gate, a bake
    window, fail-fast halt, resume, and a one-click fleet rollback to each app's previous version, with
    notifications for halted / completed / rolled-back rollouts.
  • Post-cutover auto-rollback (opt-in per app). Rolling deploys can keep the previous container through a
    soak window after traffic switches and revert automatically if the new version fails its health checks early.
  • Build secrets. Dockerfile builds can mount secrets via BuildKit --secret so tokens never land in the
    image or its history (unlike build args).
  • Secrets key rotation. Rotate SECRETS_ENCRYPTION_KEY without re-entering any secret or touching your
    apps (the hub restarts twice): keep the old key as a previous key, re-encrypt every stored secret from
    Settings → Instance, then drop the old key once the panel says it is safe.
  • Digest-pinned updates. The signed release manifest now records each image's digest; the self-updater
    pulls hub and web by digest and refuses an image whose version label does not match the release. Older
    manifests keep updating by tag.
  • Safer installer and updater. A mandatory pre-update restore point (database dump + .env copy) before
    any update; X-Forwarded-For is trusted only from private, loopback or explicitly listed proxy peers; an
    existing install turning HTTPS moves its raw ports to loopback (--keep-raw-ports opts out); atomic .env
    writes; the updater also refreshes the bundled agent; bootstrap.sh fetches by branch, tag or commit and
    leaves a checkout that git pull can update; abort paths restore the pre-run .env.
  • Deploys survive a hub restart. A deploy that is running when the hub restarts (or when the agent's
    connection drops) is no longer marked failed blind. The agent keeps running it and keeps a local command
    journal; when it reconnects the hub picks the deploy back up and records the real outcome — success,
    failure, auto-rollback or cancelled — with the live log continuing in the panel. Only when the result
    genuinely cannot be known (the agent itself restarted, or it never reports back before the deadline) does
    the deploy show as interrupted, and the app's status is never changed on a guess. Requires the updated
    agent (older agents keep the previous behaviour until they are updated via Update agent).

v0.1.0-beta.11

v0.1.0-beta.11 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 12 Nov 21:03

Release v0.1.0-beta.11

v0.1.0-beta.10

v0.1.0-beta.10 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 12 Nov 16:27

Release v0.1.0-beta.10

v0.1.0-beta.9

v0.1.0-beta.9 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 11 Nov 12:07

Release v0.1.0-beta.9

v0.1.0-beta.7

v0.1.0-beta.7 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 11 Nov 09:49

Release v0.1.0-beta.7