Skip to content

Changelog ​

All notable changes to Vexlyx are documented here. The format follows Keep a Changelog and releases use Semantic Versioning.

Unreleased ​

Changed ​

  • Explicit any types and stray console.log calls now fail lint and CI (#58). Operational console.warn/console.error calls remain allowed; CLI regression probes verify both API and dashboard enforcement.

Security ​

  • An uploaded custom SSL private key is passed to ssl_manager.py on stdin instead of its command line, so it is no longer readable through ps or /proc/<pid>/cmdline (#190).

  • A private key written by the SSL helper is now readable only by its owner, and deleting a certificate takes the copy that was left beside it (#195). system/python/ssl_manager.py wrote every PEM with Path.write_text(), which means the mode comes from the process umask; the panel's own vexlyx-api image runs as uid=0(root) with umask 0022, so a key landed 0644 — measured inside that image (Python 3.11.2, cryptography 50.0.2), where the new suite run against the helper as it stands on the QA box's checkout (4cbbfb7) reports Ran 12 tests … FAILED (failures=6, errors=5) and the mode assertions answer 420 where they demand 384, i.e. 0644 against 0600. The files live in docker/traefik/certs, which Traefik mounts into its container (/opt/vexlyx/docker/traefik/certs -> /etc/traefik/certs, mode ro), and that directory was 0755 root:root, so anything that could open a file in it could read the key. Who that actually is was measured rather than assumed, on the QA box, across every running container: vexlyx-traefik is the only one that mounts the certs directory and no tenant application container does — the three project containers that mount anything from the checkout (vexlyx-cmw3ihbns00r-app-1, vexlyx-cmvif8bd2012-app-1, vexlyx-cmvif8bd2012-web-1) mount only their own apps/api/workspaces/projects/<id> trees and their own generated deploy/ files — so the reachable reader today is a local account on the host (that box has two login shells in /etc/passwd) or any container an operator later gives a mount of the checkout; the report's PHP-FPM-with-the-directory-mounted shape is a topology an operator can create, not one this box has. Both readers that do matter run as root: vexlyx-traefik (traefik:v3.6) reports uid=0(root) and vexlyx-api reports uid=0(root), so 0600 costs nothing in serving — and the panel already treats key material that way for the same traffic: docker/traefik/acme.json, Let's Encrypt's own store of the same class of secret, is 600 root:root on that box, and system/python/mail_tls_manager.py:62-63 writes its certificate 0644 and its key 0600. The helper now matches it. atomic_write() (ssl_manager.py:87) is the function mail_tls_manager.py:32 has always used — temp file in the target directory, fsync, chmod, os.replace — so the mode is on the bytes before they are reachable under their real name, which is what makes the write safe rather than merely final: write_text() followed by chmod() would have left a window in which the key was world-readable on its way to 0600. PRIVATE_KEY_MODE = 0o600 and CERTIFICATE_MODE = 0o644 are named at :79-80 and applied at all six write sites — the pair in generate_self_signed() (:214-215), its convenience copy (:220-221) and the pair in save_custom_certificate() (:390-391); a certificate deliberately keeps 0644, because it is public and other tooling reads it. The second half of the report was the residue: generate_self_signed() also writes <clean_host>.crt/.key next to the domain's own domain-<id> pair as a convenience, and delete_custom_certificate() removed only the domain-<id> files, so a private key stayed on the host after the certificate it belonged to was deleted. It removes them now, under two guards, because the naming rule is the risky part: the caller has to name the hostname (ssl-service.ts:744, from disableSsl(), now sends { domainId, hostname }) — those names come from the hostname, and an API image built before this change sends none and so keeps exactly the old behaviour, which the suite pins — and each copy is deleted only after its bytes are compared with the file being deleted, because generate_self_signed() writes those very names as its primary output when it is given no domain id, so a hostname-shaped file may belong to something else. Both halves take the name from one function, convenience_copy_name() (:127), so the rule cannot drift out of sync with itself. copiesRemoved is in the answer so the deletion is observable. Nothing outside the helper reads those names: the certificate paths any consumer is configured with are domain-${domain.id}.crt/.key (apps/api/src/modules/domains/service.ts:320), which is what the Traefik dynamic file asks for, so removing the copies cannot reroute or break a site. Verified in the panel's own image on Linux, where the mode tests run instead of skipping: the patched helper gives Ran 12 tests … OK with all twelve executed, the suites that already cover this helper are unchanged on both trees (test_ssl_management 7 with 1 skipped, test_ssl_manager_stdin 6), and the API's vitest suite is 84 files / 780 passed + 3 skipped — one more passing test than before. Both new tests were checked as guards: with { hostname } taken back out of the delete_cert payload the vitest test fails on the payload comparison, and the failure list above is the python suite against the unpatched helper. tests/test_ssl_key_file_modes.py (12) drives the real script in a temporary working directory — get_certs_dir() resolves docker/traefik/certs relative to the cwd, so the repo's own certs directory is never touched — and pins the modes for a generated pair, an uploaded pair and the convenience copy, that rewriting a key already on disk at 0644 tightens it, content round-trip with no . temporary left behind, copies removed on delete including a wildcard's wildcard.-cleaned name, a copy whose bytes are not this certificate's left untouched, and another domain's files untouched. It is wired into the test job (.github/workflows/ci.yml:96) because that job lists Python files one by one and an unnamed tests/test_*.py never runs in CI (#226); its mode assertions are @unittest.skipUnless on POSIX, which is why the CI and image runs are the ones that count. Scope, honestly: four lines were drawn deliberately. An existing certs directory is not chmod'd, only a created one gets 0700 (:123) — a directory mode hides file names, not contents, and after this change the contents are 0600/0644 anyway, while tightening a directory that unknown host tooling may already traverse is a wider decision than this fix; an install that wants 0700 on the directory it already has can chmod it by hand. Keys already on disk are not swept — a file is tightened when the helper next writes that name, so a certificate that is never regenerated or re-uploaded keeps its old mode until then, and no restart or rebuild changes that. Deleting the domain rather than its certificate still leaves the copies: that path is removeTraefikRouter() in apps/api/src/modules/domains/service.ts:386-396, which unlinks only domain-<id>.crt/.key and has no access to the helper's naming rule without either duplicating the derivation in TypeScript — a second source of truth for a filename — or a new cross-module call, so it is left for its own change rather than folded in here. And the pre-existing name collision is documented, not fixed: generate_self_signed() with a domain id writes over whatever sits at <clean_host>.*, which is the same name it uses for its primary output when it has no domain id (measured on the box's image). The API always sends a domain id (ssl-service.ts:344-348), so only a hand-run invocation or a system-layer test takes that second path — and it is why the delete guard compares content instead of trusting a name. No schema, API or configuration change; the panel's screens are unchanged.

  • A Dockerfile that is a symbolic link no longer reads or overwrites files outside its own project (#193). system/python/build_manager.py runs as root inside the API container, and that container bind-mounts the whole host checkout at the same absolute path (docker-compose.prod.yml:181), while a project directory is the checkout of whatever repository its owner connected — and git preserves symlinks. So a repository could arrive with Dockerfile aimed at a panel file: GET /api/projects/:id/dockerfile (apps/api/src/modules/dockerfile/routes.ts:28) handed cmd_dockerfile_get()'s answer straight back to any authenticated project owner, which was the linked file's text verbatim, and PUT on the same route (:44) had cmd_dockerfile_save() call Path.write_text() on the link — which follows it — so the save rewrote the target as root: the panel's own docker-compose.prod.yml, a source file the API imports, or /root/.ssh/authorized_keys. .dockerignore behaved the same way, and the write-through-link existed one layer down too: docker_manager.py guarded the deploy/ directory with assert_deploy_dir_is_not_a_symlink() (:108) but generate_compose_file() (:552), generate_nginx_conf() (:568) and refresh_nginx_conf_for() (:606) wrote deploy/docker-compose.yml and deploy/nginx.conf with write_text(), and application code running in a project can plant those names inside its own directory. Reads now go through read_project_text() (build_manager.py:100), which resolves the path and returns nothing unless the real target stays inside the workspace — an escaping link is now simply a file the panel cannot read, the same answer a missing file gets — and writes through write_project_file() (:115), which refuses a link at the file's own name (UNSAFE_DOCKERFILE_LINK, UNSAFE_DOCKERIGNORE_LINK) and opens the rest with O_NOFOLLOW, which also catches a link swapped in between the check and the open. docker_manager.py:122 gained the same rule as write_generated_file() (UNSAFE_DEPLOY_FILE) for all three generated files. Both write with O_TRUNC on the opened descriptor instead of replacing the path, so a file keeps its inode — which is what a deployed site needs, because its deploy/nginx.conf is bind-mounted as a single file and a new inode at the same path would never reach the running container. Worked today, still works: an ordinary Dockerfile and .dockerignore round-trip byte-for-byte and the parsed EXPOSE/ports come back as before (build_manager.py:324, :1608, :1612), a link to a file inside the same project — a repo sharing one Dockerfile — is still read, and a rewrite of an existing generated file keeps its inode. Measured on the QA box's own vexlyx-api image (Python 3.11.2, real symlinks, both trees): the new tests/test_symlink_safe_project_files.py against the unpatched scripts is Ran 12 tests … FAILED (failures=6) — two of those failures are the deploy generators reporting SystemExit not raised, i.e. writing through the link and into the file behind it — and Ran 12 tests … OK against the patched ones, with the suites that pin the working deploy path green on both trees (test_nginx_conf_refresh 9, test_compose_healthcheck_target 8, test_dockerfile_build_nixpacks_absent 1). Scope, honestly: this closes the panel's own read and save of Dockerfile/.dockerignore and its generated deploy files. The framework-detection helpers in the same file still follow links when they read .nvmrc, .node-version, package.json, requirements.txt, pyproject.toml, Pipfile, setup.py, runtime.txt, manage.py and composer.json (build_manager.py:412-843), but none of them returns file text to the caller: each read either feeds a digit-only version regex, a keyword test (django/flask/fastapi, dependency or script names), or a manage.py settings-module pattern whose match is placed into the proposed start command (:625) — so a linked file can change which command is proposed and, in that one bounded shape, echo a short substring of a file that literally contains DJANGO_SETTINGS_MODULE="<text>.settings". Widening the containment there re-tests the detection phase that every deploy runs through (apps/api/src/modules/build/service.ts:493), so it is deliberately left for a supervised change rather than folded in here. The suite is wired into the test job (.github/workflows/ci.yml:97) because that job lists Python files one by one and a tests/test_*.py not named there never runs in CI (#226); it plants real links, so it self-skips where symlink() is not permitted and runs on the Linux runner. No API, schema or configuration change, and no docs change — nothing to set up.

  • A deploy no longer lets the domain override write itself into another project's proxy rules (#192). POST /api/projects/:id/deploy (apps/api/src/modules/deploy/routes.ts:38) checked that override only as "any string up to 253 characters" (schema.ts:4 — z.string().max(253).optional()), and the string then travels verbatim to the process that renders the project's compose file: deploy/service.ts:575 hands it to system/python/docker_manager.py, where :848 makes it the hostname (payload.get("domain") or f"{slug}.{base_domain}") and generate_compose_file() substitutes it into the two Host(`{{hostname}}`) label lines of each of the eight templates (system/templates/docker-compose/*.yml). That substitution sits inside a double-quoted YAML string whose value is rule source, so the value never had to be a name at all: a backtick closes Host() and reopens it, and a quote plus a newline closes the label and starts another one. Measured on the QA box inside its own running vexlyx-api image (Python 3.11.2) against the unpatched generator that box has checked out (4cbbfb7), app.example.com`) or Host(`victim.example.org produced a manifest docker compose config accepted — exit 0, two rules, Host(`app.example.com`) and Host(`victim.example.org`), so the project is now routed on a hostname its owner was never granted — and the same trick with a quote and a newline added an arbitrary extra traefik.http.* label, also accepted, which is how a router gets pointed at another tenant's container. A third attempt (newline plus a top-level volumes: mapping) was rejected, but only because {{hostname}} is substituted twice and the second copy makes the YAML key a duplicate: an accident of the template, not a defence, and nothing below relies on it. The writer now refuses before it renders: assert_hostname_is_rule_safe() (docker_manager.py:128-140, called on the first line of generate_compose_file() at :558) fullmatches the value against [A-Za-z0-9._*-]{1,253} — the characters a name or an address is made of, with backtick, quote, newline, space, /, : and \ all absent, so a value can neither end the rule, start a new label, nor read as a path — and answers INVALID_HOSTNAME, which deploy/service.ts:145 already turns into the usual 422 {error, code} body. That set is deliberately about rule safety, not hostname syntax, and the syntax is decided once rather than twice: the body now reuses the panel's own validator (schema.ts:9-13, z.union([HostnameSchema, IPv4])), the same @vexlyx/shared HostnameSchema that CreateDomainSchema applies to a domain a user adds, so a deploy override is exactly as strict as the domain it is meant to match and arrives trimmed and lower-cased the way a stored one does — a URL, a port, a space, a single label, an IPv6 literal or a 254-character name now gets 400 VALIDATION_ERROR from plugins/error-handler.ts:73 instead of a deploy. Worked today, still works, all measured in the same run: a legitimate hostname renders a manifest docker compose config still accepts with exactly the same two rule lines; every hostname currently live in a running Traefik rule on the box — 8 of them, including the {slug}.qa.atlantiqs.org shapes the panel builds itself — passes the new guard, so no existing project's next deploy changes; the hostname the panel builds itself is unchanged and passes the guard on a normal install, whose base domain is a plain hostname; the nginx templates take no hostname at all (server_name _; — grep hostname system/templates/nginx/ finds nothing), so there was no second sink inside the deploy templates themselves; and the suites that pin the deploy path stay green (test_nginx_conf_refresh 9, test_compose_healthcheck_target 8, test_symlink_safe_project_files 12, test_dockerfile_build_nixpacks_absent 1, plus the API's own 83 files / 776 vitest tests). tests/test_deploy_hostname_guard.py (9 tests) drives the real generator — 8 accepted shapes asserted rule-for-rule, 15 refused shapes asserted to refuse and leave no manifest in the deploy directory, a refusal asserted not to disturb a manifest already there — and one test reads all eight templates and pins that the placeholder appears once per line and only inside a Host() backtick pair, which is what keeps the guard's character set tied to the text it protects; it is wired into the test job (.github/workflows/ci.yml:97), which lists Python files one by one (#226). apps/api/src/modules/deploy/schema.test.ts (19 cases) covers the body, including the fact that a rejection names the shape it wanted (domain must be a hostname (app.example.com or *.example.com) or an IPv4 address) instead of zod's generic union message, measured through the error handler that builds the 400 body. Scope, honestly: this closes the deploy compose sink — the one the report described, where the value arrives from a request body. It is not the only place a hostname reaches a Traefik rule. apps/api/src/modules/domains/service.ts:290-293 renders the per-domain dynamic route file (rule: ${rule}, written unquoted at :328, :334, :351) from domain.hostname plus domain.pathPrefix, and while the hostname there is covered — the same HostnameSchema rejects a backtick, a quote or a newline — pathPrefix is only checked by CreateDomainSchema to start with / (packages/shared/src/schemas/domains.ts:128-136), so it arrives in a PathPrefix() rule argument with no character limit at all. Traced through the code, not measured end-to-end: closing it needs its own guard plus a YAML-quoted scalar, and it is a different route, a different writer (the API process, not the root helper) and a different file, so it is deliberately not folded into this change. One consequence for a normal install: the panel's own {slug}.{base_domain} fallback goes through the same guard as an override, because :848 feeds both into one call — so an install whose BASE_DOMAIN is not name-shaped (a port or a slash in it) now refuses the deploy with INVALID_HOSTNAME instead of rendering a rule Traefik would never match.

  • Uploading a custom certificate no longer puts its private key in the SSL helper's command line (#190). POST /api/domains/:id/ssl/upload (apps/api/src/modules/domains/routes.ts:479, :485) hands the uploaded pair to uploadCustomCert(), which builds the save_custom payload with privateKey: input.privateKey (apps/api/src/modules/domains/ssl-service.ts:506-509) and passed it to runSslManager(), which started the helper as spawn(pythonExe, [scriptPath, command, JSON.stringify(payload)]) (:131 before this change) — the entire document, key included, as argv[2] of a process the API runs as root. argv is ambient: the same text is what ps prints and what /proc/<pid>/cmdline serves, which a default Linux opens to every local process (mode 0444, no hidepid), and it stays there for the helper's whole lifetime — normally a second or two, but the watchdog allows an SSL helper 15 minutes (apps/api/src/utils/processWatchdog.ts:51). Measured inside the panel's own vexlyx-api image on the QA box (Python 3.11.2, cryptography 50.0.2, checkout 4cbbfb7) using validate_pair — the command that consumes a key and writes nothing — with a throwaway self-signed pair built in memory, sampling the live child's /proc/<pid>/cmdline from a side thread and reporting only whether key material was present: the old argv invocation gives key_visible_in_cmdline: true, the stdin one gives false, and both answer identically (stdout_lines: 1, exit: 0, success: true). The request moved, not the helper: ssl_manager.py's main() has long read {"command", "payload"} off stdin whenever it is given no argument (system/python/ssl_manager.py:374-386), the API's spawn had already opened a stdin pipe (stdio: ["pipe", "pipe", "pipe"]), and every other python call site in the API already feeds its helper that way — so runSslManager() now writes the document and closes the pipe (ssl-service.ts:205-207) and argv carries the script path alone. child.stdin.on("error", () => undefined) came with it, the guard the house already uses wherever it writes to a helper (apps/api/src/modules/files/service.ts:170, apps/api/src/modules/mail/state-sync.ts:120): a helper that dies before reading closes the pipe, and an unhandled error on a writable is what turns that into a crashed API process, while the existing close handler (:167) already reports the real failure. Worked today, still works: a matched pair over stdin answers success: true and a mismatched one answers the same sentence as before (Private key does not match the certificate's public key.); an unknown command and malformed stdin each still produce exactly one document and exit 1 (Unknown command: not_a_command, Invalid JSON stdin: …); the other two runSslManager() callers keep working over the same transport, and neither ever carried a secret — generate_self_signed (:344) sends only hostname, domain id, SANs and days because the helper builds and writes the key itself (system/python/ssl_manager.py:100, written at :164), and delete_cert (:742) sends only a domain id. argv stays supported on purpose (:384-386): that is the CLI's form, and the form tests/test_ssl_management.py (7 tests, 1 skipped) still uses, unchanged and green. Two new suites: tests/test_ssl_manager_stdin.py (6) drives the real script both ways and pins that stdin and argv give the same answer for the same payload — the two parsed documents compared, and success asserted so the equality cannot be vacuous, wired into the test job (.github/workflows/ci.yml:92) because that job lists Python files one by one and an unnamed tests/test_*.py never runs in CI (#226); and apps/api/src/modules/domains/ssl-manager-spawn.test.ts (2 vitest) guards the caller, mocking node:child_process to record what went on the command line and what arrived on stdin, then asserting the private key appears in none of the arguments. That second file is the regression test, and it was checked as one: with the argv transport temporarily restored, both of its tests fail — the second quoting the key back verbatim inside the reconstructed command line — and the API suite is otherwise unchanged at 84 files / 779 tests. Scope, honestly: this closes the ambient-argv disclosure for the SSL helper, and the audit behind it says the helper was the only such site in the API — every other spawn passes the script path alone (build/service.ts:93, :186, :285; deploy/service.ts:106, :249, :339, :425; databases/service.ts:61; dockerfile/service.ts:49) or the script plus a fixed command name (mail/service.ts:151, :256, :361; mail/state-sync.ts:25), so nothing user-supplied rides in a process title anywhere else. It changes nothing about what the helper does once it has the key: it still writes it to disk with the modes and the extra copy that #195 describes, and the upload still encrypts its own DB copy (ssl-service.ts:524) — neither is touched here, and #195 remains open.

Fixed ​

  • "Host DNS on Vexlyx" no longer tells users to set nameservers nobody operates (#247). DNS_NAMESERVERS defaulted to ns1.vexlyx.com,ns2.vexlyx.com, so an install that never set it showed those names as "Set these nameservers at your registrar", and a user who followed them broke their domain. The variable now has no default (also removed from docker-compose.prod.yml): when unset, the delegation check answers configured: false with no nameservers, PATCH /api/domains/:id/dns-mode to MANAGED (including "Prepare zone") returns 409 DNS_HOSTING_NOT_CONFIGURED, and the dashboard shows "DNS hosting is not set up on this server" with advice to add an A record at the current DNS provider. Behaviour with DNS_NAMESERVERS set is unchanged, and the zone-file fallback for existing zones is untouched. Operators who relied on the old default must now set DNS_NAMESERVERS explicitly.

  • CI now runs the Python suites it was silently skipping, and fails when a new one is left out (#226). .github/workflows/ci.yml had no test discovery: every suite was named by hand, as python3 -m unittest discover -s tests -p test_<name>.py or python3 -m unittest tests.test_<name> -v, so the workflow was a per-file allowlist with nothing checking it was complete. Measured on main at 6eebfa5: 58 files matched tests/test_*.py and 26 were named anywhere in the workflow — the other 32 had never run in CI. That is not a hypothetical. PR #225 added tests/test_git_branch_switch.py, whose four tests were the entire evidence for its fix; the first push came back lint / typecheck / build / test all pass, genuinely green, and the suite had never executed because nothing named it. A reviewer reading "test: pass" cannot tell the difference, and that is the defect. tests/check_ci_suite_coverage.py is now a step in the test job and fails on a suite that is neither named nor deliberately excluded. It also reports a named suite from which unittest discover collects nothing: ten of the files under tests/ define module-level test_* functions and a main() with no unittest.TestCase, so wiring one in as-is is not a working test — measured on Python 3.12.3 and 3.14.6, discover on such a file prints Ran 0 tests / NO TESTS RAN and exits 5 (_NO_TESTS_EXITCODE, /usr/lib/python3.12/unittest/main.py:12), a red job that names no file and explains nothing, so the guard says which suite and why instead. The check is static (AST, never an import) on purpose: importing a suite to ask would run its top-level code, and several of these reach for a live panel or a docker daemon. Only actual run: steps count, block scalars included, so a comment mentioning a suite name cannot make it look covered. Exclusions now live in tests/ci-excluded-suites.txt, one filename per line with a required one-line reason, so the decision is written down instead of implicit in the workflow; the guard also fails on an entry with no reason, an entry naming a file that no longer exists, a duplicate, and a suite that is both excluded and run. Ten of the 32 were hermetic and are wired in — test_backup_database_restore (4), test_build_install_command (9), test_compose_healthcheck_target (8), test_container_health_status (8), test_github_app_git_credentials (2), test_installer_output (7), test_mail_tls (4), test_postfix_map_rebuild (4), test_ssl_management (7, 1 skipped) and test_subprocess_timeouts (13) — 66 tests, each executed before being added rather than assumed, on Windows and on a Linux sandbox built from git archive of the same revision, all OK; two of them (test_ssl_management, test_mail_tls) the report itself listed as needing infrastructure, which measurement contradicted. The workflow now reads 59 suites, 37 run, 22 excluded with a reason. tests/test_ci_suite_coverage.py (27 tests) drives the guard against synthetic repositories in both directions — each invocation form, a glob pattern, a block-scalar step, a comment that must not count, every exclusion-list error, and the collection check including a transitive local TestCase base — and one of its tests runs the guard against this repository, so deleting the guard's step from the workflow does not quietly delete the check. The guard was verified to bite on the real tree, not only on fixtures: an added unnamed suite gives exit 1 naming it, and a named script-style suite gives exit 1 quoting the 0-test shape. Scope, honestly: the 22 exclusions are not all "needs a mail server". Six are excluded because the suite is stale or broken against today's code and would fail for reasons unrelated to coverage — test_opendkim_reload raises ModuleNotFoundError at import (:14 loads postfix_manager without system/python on sys.path), test_nextjs_runtime:174 asserts connect(3000,'127.0.0.1' while next.yml:25 probes require('os').hostname() (#202), test_php_wordpress_runtime expects wp-config.php/.htaccess scaffolding that build_manager.py:1488-1493 replaced with wp-content only, and test_dovecot_imap:36 plus test_mailbox_management/test_postfix_smtp still read config paths that moved to active_directory() / docker/mail-data/state. Each reason names the file and line, so the next person fixes the suite instead of guessing; none of those defects is fixed here. test_installer_dns_guidance is hermetic but measured at 291s for 3 tests — its fake cert store never matches, so 16-summary.sh sleeps 2s up to 45 times per test — and is excluded on cost with that number written down. The guard checks the whole workflow file, not per job, so a suite named only in mail-state or mail-credential-security counts as covered even though it does not run in the test job; and it checks that a suite is named and collects tests, not that it passes — a named suite that fails still fails the job on its own. No runtime, API, schema or configuration change: this is CI and tests only.

Upgrade notes ​

  • For #195 the two halves arrive at different times, and both are safe on their own. system/python/ssl_manager.py is read from the bind-mounted checkout (docker-compose.prod.yml:181) every time the API invokes it, so a git pull starts writing every key 0600 on the next certificate generation or upload — no restart, no rebuild, no downtime. Naming the hostname for the copy cleanup is TypeScript inside the API image (ssl-service.ts:744), so deleting a certificate keeps its old behaviour until vexlyx-api is next built: it removes domain-<id>.crt/.key and leaves the <host>.crt/.key copies behind, exactly as before. That is an unfinished fix, not a broken one, and the helper is built to take a payload without a hostname on purpose.
  • Nothing on disk is rewritten by the upgrade. A key that is already there keeps the mode it was created with until the helper next writes that name — a rewrite is what tightens it, which the suite pins — so an install that wants its existing keys tightened does it by hand: sudo chmod 600 /opt/vexlyx/docker/traefik/certs/*.key. The .crt files can stay 644; they are public and other tooling reads them. Tightening the directory to 0700 is likewise left to the operator (sudo chmod 700 /opt/vexlyx/docker/traefik/certs) — the two things that read it, vexlyx-traefik and vexlyx-api, are both root on the QA box, so it is safe there, but only they were measured and an install may have added a mount of its own.
  • A key that was world-readable stayed world-readable until now, so changing the mode does not undo the exposure: whether to reissue such a certificate is the operator's call, and it turns on the same question as #190 — whether anything untrusted could read the host's files while the mode was 0644. Nothing in the panel's screens changes and no certificate is reissued automatically.
  • Nothing extra to do and no image is involved. system/python/build_manager.py and system/python/docker_manager.py are read from the bind-mounted checkout (docker-compose.prod.yml:181) every time the API spawns one of their commands, so pulling the new revision delivers the fix on the next Dockerfile read, save or deploy — no container restart, no rebuild, no downtime.
  • A project whose Dockerfile is a link out of its own directory stops showing its contents in the project's Dockerfile panel (apps/dashboard/src/components/projects/DockerfilePanel.tsx) and its Save now reports an error naming the path instead of writing to it. That is the intended behaviour, not a regression: the link and what it points at belong to the project owner, and the panel no longer reads or writes through it.
  • For #192 nothing is configured, and the half that does the blocking arrives the same way: system/python/docker_manager.py is read from the bind-mounted checkout per command, so a git pull starts refusing an unsafe hostname on the next deploy with no restart and no downtime. The earlier, friendlier 400 lives in the API image, so it appears on the next rebuild — until then an API client that sends a bad domain gets the 422 INVALID_HOSTNAME from the deploy itself, which is the same decision made one layer down.
  • One behaviour change to know about: POST /api/projects/:id/deploy with a domain that is not a hostname or an IPv4 address — a URL, a host:port, a value with a space or a trailing slash, a single label like localhost, an IPv6 address — is now refused instead of being deployed. Nothing in the panel sends that: the dashboard never passes domain (no /deploy call exists in apps/dashboard/src), and the hostname the panel builds itself ({slug}.{base_domain}) is unchanged and still passes. An operator who scripted the override with something looser has to name a real hostname now.
  • For #190 there is nothing to configure, no schema or file to migrate, and no certificate to re-upload — system/python/ssl_manager.py is not part of the change, because its stdin mode already existed. The caller that changed is TypeScript compiled into the API image, so this one, unlike #192 and #193, is not delivered by a git pull: an installed panel keeps putting the uploaded key in the helper's argv until vexlyx-api is next built. The usual API container replacement is all it needs, and the disclosure window for a key already uploaded does not reopen after that — deciding whether such a key should be rotated is the operator's call, and it turns on whether anything untrusted can read process listings on the host.
  • Anyone who runs the helper by hand, or from the system-layer suites, can keep using [script, command, json-payload]; the form the API now uses is [script] with {"command", "payload"} on stdin, and both answer the same.
  • For #226 an installed panel does nothing — no file it reads changes. It changes what a contributor has to do: adding tests/test_*.py now means either naming it in the test job or adding a line to tests/ci-excluded-suites.txt with the reason, because python3 tests/check_ci_suite_coverage.py fails the job otherwise. The same check runs locally in tests/test_ci_suite_coverage.py, and the guard prints the offending filenames, so the fix is named for you.

[0.4.8] - 2026-11-05 ​

Fixed ​

  • Detecting the framework for a project that ships its own Dockerfile no longer needs Nixpacks installed (#222). cmd_plan() in system/python/build_manager.py resolved the Nixpacks binary four lines after reading the payload and only looked for a Dockerfile thirty lines later, even though that branch answers the request from parse_dockerfile_info() alone and never runs nixpacks plan — so on a host with Docker but no Nixpacks the resolver's failure path (NIXPACKS_NOT_FOUND, exit 1) killed a request that would never have called it. The same defect was removed from cmd_build() one layer down by a44b565, and it mattered more than its twin because a deploy detects first (apps/api/src/modules/build/service.ts:493, "Phase 1 — detect framework") and only then builds: a Dockerfile project's deploy failed before the build-side fix could help, and so does the F5.34 Detect button (:822). The lookup now sits immediately before the nixpacks plan invocation (:1086-1090), which is also what makes a missing workspace report PROJECT_DIR_NOT_FOUND — the true cause — instead of NIXPACKS_NOT_FOUND. Scope, honestly: a stock install is not exposed today, because the API image installs Nixpacks itself (apps/api/Dockerfile:68) and these scripts run inside that container; what this affects is a source checkout running the API on the host (DEV.md:159's pnpm dev, which spawns build_manager.py on the host interpreter) and any install that later stops shipping Nixpacks. tests/test_dockerfile_plan_nixpacks_absent.py pins the ordering three ways — a Dockerfile project planned with the resolver rigged to fail if it is consulted, a project without one where the resolver must still run and its error must still reach the caller as a single document (the guard moved, it was not removed), and the missing-directory case — measured to fail 2 of 3 against the unpatched file and to pass 3 of 3 on the QA box's own vexlyx-api image (Python 3.11.2), where running the real cmd_plan against both a Dockerfile project and a Flask project produced byte-identical output before and after, so nothing that works today changes. Wired into the test job (.github/workflows/ci.yml:91-93) because that job lists Python files one by one and a tests/test_*.py not named there never runs (#226). No API, schema or configuration change; nothing to set up.

  • Switching a project to a branch created after its first clone now works on the first build (#153). system/python/git_manager.py clones with --single-branch, which writes a restricted fetch refspec — +refs/heads/main:refs/remotes/origin/main — so the sync path's plain git fetch origin never learned a branch added later, git checkout <branch> failed with error: pathspec '…' did not match any file(s) known to git, and the build ended FAILED; the next build succeeded only because the workspace had been re-cloned in between. cmd_clone now sets the wildcard refspec before fetching (:86-90), which is what makes git's branch guessing available again. The fix the report suggested does not work and was measured rather than assumed: git fetch origin <branch> alone only writes FETCH_HEAD, and even a refspec-qualified fetch that does create origin/<branch> leaves git checkout <branch> failing with the same pathspec error, because guessing stays disabled while the remote's fetch config names a single branch. After the change the switched-to branch is ordinary — vexlyx-docker tracking origin/vexlyx-docker — switching back to main works, and the data-safety rule is untouched: a sync that fails against the same repository still reports its error and never re-clones over a workspace. tests/test_git_branch_switch.py runs the real git binary against a local repository rewired behind https://github.com/team/repo through GIT_CONFIG_GLOBAL, so the URL policy under test is exactly the production one and the refspec behaviour is git's own; verified to fail without the fix, reproducing the reporter's message, and the four suites already covering git_manager.py (23 tests) still pass. The new suite is wired into the test job (.github/workflows/ci.yml:79-81), which lists Python files one by one — a tests/test_*.py that is not named there does not run in CI at all, which is how this one nearly shipped untested. The report's second request — exactly one JSON document per call — is deliberately not addressed here: the two documents in its log come from the repository-switch fall-through, and changing that path decides what happens to a customer workspace when a project is repointed at a different repository. No schema, API or configuration change; nothing to set up.

  • Webmail now names the reason it cannot reach the mail server when the mail hostname is blank. docker/roundcube/config/local.inc.php applied ROUNDCUBE_MAIL_TLS_PEER_NAME only when it was a non-empty string, and with no name PHP validates the certificate against the service name the client actually connected to — tls://dovecot, tls://postfix — which no mail certificate is issued for, so strict verification refused every IMAP and SMTP connection while the login page kept serving and nothing on screen or in a log mentioned the cause. The blank case now writes one line to the webmail container's error log (docker logs vexlyx-roundcube) naming both variables, at :30-38: ROUNDCUBE_MAIL_TLS_PEER_NAME for the operator reading the config, and VEXLYX_MAIL_HOSTNAME because that is the value the prod overlay renders into it (docker-compose.prod.yml:116) and the one the installer always fills (system/scripts/install/config.sh:43, default mail.$VEXLYX_DOMAIN), so the reachable case is a production stack started without the rendered env file rather than an installed panel. docs/dev/email/webmail.md:122 records the same in the TLS policy section, next to the note at :125 about the self-signed fallback. Verification is still fail-secure and nothing else changes: the setting is not disabled, startup is not aborted, the login page still serves, and a value that arrives padded is now trimmed (:20) instead of being compared literally — measured against the shipped file with PHP 8.5 across seven env postures, so the four-key option matrix for a configured name and for ROUNDCUBE_MAIL_TLS_VERIFY=false is byte-for-byte what it was. tests/test_roundcube_tls.py pins the three blank shapes (absent, empty, whitespace-only) to "verification on, no peer_name, one log line", pins a configured name and the development posture to logging nothing, and asserts the full option set rather than a subset so the diagnostic cannot become a route to weakening it. The line is written on each config load, so a misconfigured webmail that is being used repeats it — the trade for the message existing at all. This is the third item of #129; its other three are owner decisions (a second CI job pulling two images, a Playwright dev dependency, tenant-wide certificate visibility for admins) and stay open there. Nothing to configure; no certificate, listener or mail-server behaviour changes.

Documentation ​

  • The docs no longer describe a Redis eviction policy and Redis uses the panel does not have (#109). docs/dev/infrastructure.md:63 stated eviction was allkeys-lru and :71 listed "API response caching, rate limiting" as Redis consumers, but the shipped command line is --maxmemory-policy noeviction (docker-compose.yml:68) and CONFIG GET maxmemory-policy against the QA panel's running vexlyx-redis answers noeviction (measured 2026-11-05), while neither use exists in the code: the only thing cached in Redis is the 6-hour release lookup keyed system:update-info (apps/api/src/modules/system/update-service.ts:11-12) and @fastify/rate-limit is registered with no store option (apps/api/src/modules/auth/routes.ts:20-24), so it counts in the process's own memory and login counters start over on an API restart. The corrected rows record what the same measurement showed actually running — AOF plus the default save 3600 1 300 100 60 10000 snapshot schedule, which the command line does not override — and the bullets name what really writes here: the scheduled-task overlap lock (apps/api/src/modules/scheduled-tasks/service.ts:371), the 24-hour GitHub webhook delivery claim (apps/api/src/modules/webhooks/delivery.ts:3-18) and short-lived OAuth state and 2FA/reset values. docs/reference/infrastructure.md needed no matching edit: it is generated from this file by docs/scripts/sync-docs.mjs and git-ignored (docs/dev/docs-site.md:23), so the stale copy of the same table on a developer disk was never a second source of truth. F5.30 in FEATURES.md carried the same two claims about the panel's own Redis (:2493) and now describes it correctly; its licensing note also records a measurement for whoever picks the feature up — redis:7-alpine pins only the major, and the container on that box reports redis_version:7.4.11, already inside the RSALv2/SSPL range the note warns about, so the panel's own session store carries the same floating-image decision. That decision is not made here: changing the Redis image means restarting the panel's session store and queues. F5.30 itself stays unstarted, and that was verified rather than assumed — on main and on the box's checkout there is no RedisInstance model or maxRedisInstances quota in apps/api/prisma/schema.prisma, no system/python/redis_manager.py, no apps/api/src/modules/redis/ and no shared schema, and DatabaseType still has exactly two values; meanwhile the isolation the feature prescribes for tenant instances is already the production topology, because vexlyx-redis joins only traefik-net and vexlyx_default, publishes nothing on the host (docker-compose.prod.yml:37, nothing listening on 6379), and a container attached to vexlyx-apps alone could not open its socket. Documentation only — no behaviour, configuration or container change; nothing to set up.

  • The F5.2 acceptance list in FEATURES.md no longer credits a headline it did not earn: Support for custom build commands override was ticked from the API side alone, while the panel that makes it reachable is F5.34, so the line now names that (#200, :438). Nothing else in the file changed, and no behaviour, code or configuration is involved.

Upgrade notes ​

  • Upgrade the normal way — re-run the installer. Step 09 rebuilds the panel on the host and step 14 force-recreates the API and dashboard containers, so the version the panel reports moves to 0.4.8 along with everything below.

  • On the two build-path fixes (#153, #222): nothing extra to do, and no image is involved. The API image ships only the runtime toolchain (apps/api/Dockerfile:10-20) — the /opt/vexlyx checkout is bind-mounted into the container at the same path the host uses (docker-compose.prod.yml:181) and system/python/git_manager.py and build_manager.py are read from it each time a build runs. Pulling the new revision is what delivers both. A project that was already failing its branch switch (#153) succeeds on the next build; no workspace needs re-cloning.

  • On webmail (#129): nothing to do — docker/roundcube/config/local.inc.php is bind-mounted read-only from the checkout (docker-compose.yml:234) and Roundcube evaluates it per request, so the new diagnostic is live as soon as the file is on disk. A production panel that already renders VEXLYX_MAIL_HOSTNAME sees no change at all; the log line appears only where the mail hostname is blank, which is the misconfiguration it names.

  • On #222, for operators running the panel from a source checkout without Nixpacks installed: this removes the failure for a project that ships its own Dockerfile — detection and the F5.34 Detect button now answer without consulting the resolver. A project without a Dockerfile still needs Nixpacks, which is unchanged and still what the API image installs (apps/api/Dockerfile:68).

  • On #109 and #200: documentation only. Nothing to set, and no container, image or Redis configuration changes — the panel's Redis keeps running with the noeviction policy the docs now describe.

[0.4.7] - 2026-11-05 ​

Fixed ​

  • The installer no longer warns "No Let's Encrypt certificate detected" on a server that has the certificates. The summary step read Traefik's ACME store by piping docker compose exec -T traefik cat acme.json into grep -Eq, and grep -q exits the instant it matches — so the writer was still delivering the rest of the store when its read end closed, it died of SIGPIPE, and set -o pipefail at the top of the step made the whole pipeline report failure even though the match had succeeded. Any store bigger than the kernel's ~64 KB pipe buffer hit this, which is every panel holding more than a couple of certificates, and 2>/dev/null hid the only error message that would have explained it. The store is now read into a variable once and matched in the shell, so no early-exiting reader is involved. The check also reports each hostname it cannot find on its own line instead of a single warning covering domain and api.domain together, so a partially-issued pair says which name is actually missing. The existing test could not have caught this because it re-implemented the lookup inline against a 60-byte fixture; the new tests execute the step file's real function text under the step file's own pipefail, against a store that is both multi-line (Traefik pretty-prints its JSON, and a single-line fixture forces the reader to consume the whole file, which hides the bug entirely) and far larger than the pipe buffer, and while one of them asserts the block never pipes into grep again another asserts that the old shape really does fail on that fixture — so the fixture cannot quietly stop testing anything (#184).

  • A fresh install no longer ships somebody else's DKIM keys. Four default.txt public records for developer test domains (vexlyx-test.com, wp-blogs.vexlyx.localhost, api.wp-blogs.vexlyx.localhost, test-postfix-mailer.org) were committed back in F4.1 and stayed in the index ever since, even though .gitignore has ignored docker/postfix/opendkim/keys/*/ the whole time — an ignore rule never applies to a path that is already tracked, so the directory looked correctly excluded while git ls-files -i -c --exclude-standard — which is exactly the check for that contradiction — still returned them. They are inert on a running server (Postfix reads its keys from the mail-state directory, not the checkout, and the live KeyTable never referenced them), but they were not harmless: mail_state_migrate.py copies every file it finds under docker/postfix/opendkim, keys/ included, into a real server's mail-state root as legacy state, so an upgrade carried a developer's domains into a customer's mail data. They are removed from the checkout now, and a new test fails if any file under that directory is tracked again — the existing one filtered on .private and so passed straight over them, which is how this survived a security test written for precisely this directory. The rest of the report behind this was already fixed and is recorded here rather than re-fixed: the runtime tables (KeyTable, SigningTable, TrustedHosts, the Postfix virtual maps, Dovecot's users) are untracked and regenerated, so no install starts with a Windows path or a developer's domain in it, and the pull guard compares with core.fileMode=false, which is what makes the chmod -R the Postfix entrypoint runs on key files a non-event instead of a reason to refuse an upgrade — confirmed on a server whose git status lists four modified key files while the guard itself returns nothing (#139).

  • A fresh install no longer depends on a GitHub rename redirect. install.sh (:206) and system/scripts/install/config.sh (:49) each defaulted VEXLYX_REPO_URL to https://github.com/atlantiqs-org/vexlyx.git — the org slug from before the rename to atlantiqshq — and it resolved only because GitHub redirects a renamed owner: measured on a live server, atlantiqs-org/vexlyx answers 301 while atlantiqshq/vexlyx answers 200. The clone then records the URL it was given, so every later fetch kept leaning on that redirect, and the old slug is not ours to keep reserved. This is the one place where the launch checklist and the code disagreed: the landing page's DEPLOY.md already tells the releaseer to "check install.sh and system/scripts/install/config.sh in atlantiqshq/vexlyx both point at https://github.com/atlantiqshq/vexlyx.git", and both files pointed somewhere else. Both defaults now name the current slug, and an operator-set VEXLYX_REPO_URL still wins because the expansion is unchanged — that is the fork/mirror install path. Nothing was broken before this, and it is written as a dependency removed rather than a failure repaired: the same probe run installed v0.4.6 correctly through the old URL (resolved as a tag, cloned, VEXLYX_VERSION in the tree reading 0.4.6). The reason for a test instead of a grep is that the default lives in two files that have to stay matched — tests/test_installer_repo_url.py fails if the bootstrap and the orchestrator disagree, if either stops naming the current slug, or if either stops honouring an override. DEV.md's older atlantiqs-org line is left alone deliberately: it is inside "Create Your GitHub Repository", where the URL is the reader's own repo, not a remote the installer uses.

  • The Mail client setup dialog now says what a mail app has to be set to, not only which ports exist. It listed Port (SSL/TLS) 993, Port (STARTTLS) 143 and Port (STARTTLS) 587 — which names both security modes but leaves the reader to work out which one the app's own Connection security dropdown has to be on, never mentions Authentication at all, and says nothing about the port clients guess first. That combination is how a working server reads as a broken password: the submission listener runs with smtpd_tls_security_level=encrypt (docker/postfix/master.cf:8,10) and Dovecot has disable_plaintext_auth = yes (docker/dovecot/dovecot.conf:40), so a client left on None is refused at the password step with Must issue a STARTTLS command first, and nothing in the panel told the user that error is the server requiring TLS rather than a wrong password. Every port row now states the mode to select, both sections carry an Authentication: Normal password row naming what the server actually offers (auth_mechanisms = plain login, docker/dovecot/dovecot.conf:41), and the SMTP section states that 587 is the only submission port because there is no 465 listener to offer — master.cf defines smtp and submission and nothing else, docker-compose.yml publishes 25/587/143/993, and searching the repo for 465 returns nothing, so the old silence on that port was a claim by omission. The values behind the copy buttons are unchanged and stay single paste-ready tokens (993, 143, 587, the hostname, the address); the new prose is rendered beside them, and Authentication, being a dropdown choice rather than text to paste, gets no copy button. MailboxesPanel.test.tsx pins the copy to the configuration it was written from — the exact port list, each port's security mode, Normal password in both sections, the server's own refusal string, the 465 statement, and the rule that no copyable value gains whitespace — so the test fails if the panel's advice drifts away from the mail server's real listeners. docs/guide/email.md already stated the security modes the dialog omitted; its table now carries the same Authentication column, the 143 row and the 465 note. The Phase 2 half of #160 is not in this release: serving Thunderbird autoconfig XML and Outlook autodiscover needs a route per mail domain, two more records in the required-DNS list, and decisions about which hostname an app is supposed to probe and how that route is issued a certificate — nothing like it exists in the repo today, and the issue stays open for it. Nothing to configure; no port, listener or certificate changes.

  • A Dockerfile build path no longer pays for a tool it never calls. cmd_build() resolved the Nixpacks binary at the top of the function, ahead of its own Dockerfile branch, so a caller that reached cmd_build() on a host with Docker but without Nixpacks failed with NIXPACKS_NOT_FOUND on a build that only ever runs docker build. The lookup now sits after that branch returns, at system/python/build_manager.py:1242, which is the first line that uses it — so no path that reaches Nixpacks skips the lookup and no Dockerfile path pays for it. tests/test_dockerfile_build_nixpacks_absent.py drives the real cmd_build() against a fake docker on PATH with Nixpacks deliberately unresolvable, asserts the build reports done: true and that the resolver is never consulted, and is wired into the CI test job, so the guard fails if the call moves back up the function rather than only if behaviour changes. Scope stated plainly, because the change is narrower than its title: this does not yet make a Dockerfile project deployable on a Nixpacks-less host. The deploy job runs framework detection before it ever calls cmd_build() (apps/api/src/modules/build/service.ts:493), and cmd_plan() still resolves the binary at build_manager.py:1059 — ahead of the same Dockerfile branch, which answers from parse_dockerfile_info() and returns at :1087 without touching nixpacks_bin, only consumed from :1089 — so both the Detect button and a deploy of a Dockerfile project still require a resolvable Nixpacks. That half is tracked as #222. It also means the failure this fixes was not reachable on a stock install, where the API image installs Nixpacks itself (apps/api/Dockerfile:68, since #124) and these scripts run inside that container: what changes here is correctness for a checkout running the API outside the image, and for any install that stops shipping it. Nothing to configure — build_manager.py is read from the repo checkout each time a build runs, and projects that use Nixpacks build exactly as they did.

Changed ​

  • Verifying a custom domain now requests its HTTPS certificate, instead of leaving the domain on plain HTTP until someone also pressed Provision SSL. Ownership is proven at verification, which is the right moment to ask Let's Encrypt for the certificate, and a hostname whose A record has not propagated yet simply fails the challenge and is retried by Traefik until it lands — so HTTPS arrives without a second action either way — and a domain that looked finished while serving unencrypted traffic is the kind of gap that does not announce itself. The automatic request goes through the same code and the same schema defaults as the manual button (Let's Encrypt, force HTTPS, auto-renew), so the two cannot drift apart. It is skipped where it cannot work: a wildcard hostname (*.example.com) is left alone because the resolver here is configured for the HTTP-01 challenge only, which cannot issue for a *.… name, and ordering one anyway would spend Let's Encrypt's failed-validation budget on every retry; a domain that already has SSL enabled is not re-ordered, so verifying twice does not ask for a second certificate. Nothing here can turn a verification that genuinely succeeded into a failed request — provisioning is attempted after the status change is committed, and a certificate that cannot be ordered is logged for the operator while the response still reports the domain verified over HTTP, with the manual action unchanged. Subdomains that a parent's verification auto-activates are deliberately not given certificates in this step: they are separate hostnames whose own A records were never challenged here, so each is provisioned on its own. Nothing here reintroduces #156 — the proxy restart that used to drop connections for every other site on the server when a domain changed — which was fixed and shipped in 0.4.1: securing a domain, automatically or from the button, only writes a route file for Traefik's file watcher to pick up, and neither the verify route nor the certificate helper restarts the proxy (#161).

Documentation ​

  • The custom-Dockerfile runtime guide now says what actually happens to a Docker project's storage. The compose template declares no volumes: key, so the only storage a project can have is whatever its image declares with VOLUME, and Compose reattaches that anonymous volume on every redeploy — up -d --force-recreate --pull missing is not -V. That is why runtime uploads survive a push while content baked into a rebuilt image never reaches the site, and why Remove (down --volumes --remove-orphans) is the one action that deletes the data the site accumulated. The behaviour was measured on a live server with a two-tag probe image rather than taken from Docker's documentation, which is also how it surfaced that a volume reattached across a --force-recreate can survive its own down --volumes as an orphan that only docker volume prune reclaims. The dashboard's Remove copy is quoted rather than paraphrased: it does say the volumes go, so the real gap is that it names the volume and not the data inside it. #157 stays open — named volumes, a volume view in the dashboard and a deliberate "delete data" action need product decisions, not documentation. Nothing to do; this describes behaviour that is already live and changes none.

  • The deployment-engine lifecycle doc now names the pull flag the deploy actually uses. It said docker compose up -d --force-recreate --pull never while system/python/docker_manager.py:889 has run --pull missing since a5bc003 (2026-09-10, the no-build static and WordPress serving path), which replaced the --pull never that b64729b first wrote — so the repo's two deploy docs disagreed with each other, docs/dev/runtimes/custom-dockerfile.md:137 quoting --pull missing and being the one that was right. The flag is the part a reader takes as a statement about image caching, so the corrected line says what missing does rather than only naming it: an image Nixpacks built seconds earlier is already local and is reused as-is, while a fixed base image (nginx:alpine, wordpress:php8.3-fpm-alpine) is fetched on its first deploy. Nothing else was changed. FEATURES.md's F5.15 description keeps its --pull never deliberately: it is dated by git blame to f716b9d, committed the same day but roughly twelve hours before a5bc003, so it records what the code did when that feature was specced, and the image-accumulation finding it rests on does not depend on which pull flag was in the command. Nothing to do; no code changed.

Upgrade notes ​

  • Upgrade the normal way — re-run the installer. Step 09 rebuilds the panel on the host and step 14 force-recreates the API and dashboard containers, which is what puts the domain change (#161) and the mail client setup copy (#160) in front of users; the four notes below say which parts of this release need nothing beyond that.

  • Nothing to do. system/scripts/install/steps/16-summary.sh is read from the repo checkout on each installer run, so pulling the new code is enough — no image rebuild, and no behaviour of a healthy install changes apart from the warning that was wrong.

  • On domains (#161): no existing domain changes — only a verification performed after this release also requests a certificate. Operators close to Let's Encrypt's issuance limits (the relevant one here is certificates per registered domain per week) should know that each verified hostname now consumes one, including on a re-verify of a hostname that never got its certificate. Domains that already have SSL enabled are skipped, and wildcard hostnames are never requested. Nothing needs to be set; if an installation ever needs to stop automatic certificate requests, that is a one-line change at the verify route rather than a new configuration surface.

  • On mail (#139): nothing to do. The next install.sh run deletes the four developer-domain default.txt records from /opt/vexlyx as part of checking out the new revision, and a mode-dirty copy of one of them does not stop that checkout because the comparison ignores file modes. Servers that ever used one of those keys should rotate DKIM for that domain from the Mail screen and publish the new TXT record; removal from the checkout is not rotation, and the keys remain in Git history.

  • Nothing to do. An existing checkout is untouched — this default only applies where VEXLYX_REPO_URL was never set, and an install that already recorded the old URL keeps following the redirect until its next fresh install.

[0.4.6] - 2026-11-05 ​

Fixed ​

  • A deploy whose app binds only 127.0.0.1 now says so in the build log instead of finishing silent. For an image that declares no HEALTHCHECK, Docker has nothing to grade, so the container came up running, the deployment reported success, and the domain returned 502 — the app answered loopback while nothing outside the container could reach it. Once the container is up, the deployer opens a TCP connection to the host port Vexlyx published for it, through the host's address on the container's bridge, retries three times, and logs either Routable check <gw>:<port> answered — this container accepts connections from outside its own loopback or a warning naming that port, the domain, and the fix (bind to $HOSTNAME or 0.0.0.0). A published port is forwarded by the kernel to the container's routable address, so it refuses a loopback-only app exactly as the router does — and unlike the container's vexlyx-apps address, which the panel's own container is firewalled from by the network isolation, so probing that would have warned on every deploy. The check is informational: it can not fail a deploy, and images that do declare a healthcheck are skipped so their own probe stays the single verdict (#202).

Upgrade notes ​

  • Re-run the installer to rebuild the API and dashboard. No schema change and no API change — the verdict is one line in the existing build log. Projects on images that declare a HEALTHCHECK deploy exactly as before; the rest gain a few seconds of post-startup probing. Because docker_manager.py is read from the repo checkout each time a deploy runs, pulling this code already changes deploy behaviour before any image is rebuilt.

[0.4.5] - 2026-11-02 ​

Fixed ​

  • A container that fails its own healthcheck is no longer reported as a healthy deployment. The panel read only Docker's .State.Status, and that says the process is up — an app that binds 127.0.0.1 instead of the address Traefik routes to keeps its process up, keeps its in-container probe passing, and answers nothing, so the project page said "Running" while the domain returned 502. docker inspect now reads .State.Health alongside the status in the same call, and the project page shows Unhealthy with the reason instead of Running, or Waiting for healthcheck while the image is still inside its start period. Images that declare no healthcheck at all report nothing rather than a false pass (#202).

  • Switching a project to a branch created after the first clone now fetches its remote-tracking ref before checkout, preventing the “pathspec did not match” error. Failed updates preserve existing files and return one JSON response (#153).

  • Every project healthcheck now probes the address Traefik actually connects to. The compose templates probed 127.0.0.1 or localhost, and loopback answers even when the app refuses the routable interface, which is the 502-while-"healthy" case above. Checking each template against live containers turned up three probes that could not work as written: the Next.js image Nixpacks builds ships no wget at all, so any wget-based check there exits 127; busybox resolves localhost to ::1 before 127.0.0.1, so an app correctly bound to IPv4 loopback looked unhealthy; and the nginx check test $? -ne 4 only trips GNU wget's network-failure code, while nginx:alpine's busybox wget returns 1 for a refused connection — that healthcheck could never have reported a dead container. Probes are now TCP-level and use whatever the image is certain to ship (node, python, php, or nc on nginx), stopping at "is something listening where the router points": an app that answers 404 or 502 is still reachable, and that is a content problem rather than a routing one (#202).

Upgrade notes ​

  • Re-run the installer to rebuild the API and dashboard. No schema change: the health status is read live from Docker and is not stored, and GET /api/projects/:id/container/status only gains an extra containerHealth field (healthy / unhealthy / starting, or null when the image declares no healthcheck).
  • The new healthchecks live in the compose templates, which are read when a project deploys, so a project that is already running keeps its old probe until its next deploy. After upgrading, redeploy to move one. A site that has been quietly returning 502 will therefore start showing Unhealthy — that is the old false pass surfacing, not a new failure.

[0.4.4] - 2026-11-01 ​

Added ​

  • A project now has Build Settings on its Deploy tab: install, build and start commands plus the container port, each left blank to keep auto-detection in charge. Detect runs Nixpacks' plan over the current source and shows what each blank field would use, Save & Deploy deploys with what you typed, and Auto clears every override at once. buildCmd, startCmd and port already existed on the project and were shown read-only, with no panel to edit them, and an install command was accepted by the build script but never sent to it by the API — so nixpacks build --install-cmd had no effect on any deploy (#200, F5.34).

Upgrade notes ​

  • Re-run the installer. It applies one new nullable column (projects.install_cmd) and rebuilds the API and dashboard. Existing projects keep the commands they had, and nothing about a running site changes until you set an override and redeploy.

[0.4.3] - 2026-10-30 ​

Added ​

  • Administrators now see an in-panel notice when a newer stable release is published, linking to its release notes and the upgrade guide. The API compares the running version with the newest GitHub release and caches the answer in Redis for six hours (a failed check for one), so the dashboard never calls GitHub itself. The check is display-only: nothing is downloaded or installed, and it stays separate from anonymous telemetry (F5.32). Set UPDATE_CHECK_ENABLED=false on an air-gapped server, or UPDATE_CHECK_REPO to publish from a different repository.

Fixed ​

  • WordPress plugin and theme uploads accept real archives again: the panel streams them as multipart/form-data instead of base64 inside a JSON body, so a several-megabyte theme no longer fails with 413 Request body is too large. Temporary archives are removed on every exit path, concurrent uploads of the same filename no longer collide, and client filenames are sanitized before they reach the disk (#154).
  • Connecting or updating a git project no longer deletes files git does not track. A failed fetch, checkout or pull (network, authentication, local changes) now fails with its error and leaves the workspace untouched; previously it re-cloned the project and lost uploads and other untracked files. Switching a project to another repository, or connecting git to a workspace that already has files, keeps the old workspace next to the project as <id>.replaced-<timestamp> (reported as previousWorkspace) and restores it if the clone fails (#182).

Upgrade notes ​

  • Re-run the installer. There is no schema or configuration change: it rebuilds the API and dashboard containers, and the update notice appears for administrators on the next sign-in.
  • If the panel cannot reach api.github.com, the notice stays hidden and nothing else is affected; UPDATE_CHECK_ENABLED=false skips the lookup entirely.

[0.4.2] - 2026-10-26 ​

Security ​

  • Redis now requires a password. The installer generates REDIS_PASSWORD on a new install and adds it to an existing server's secrets file on upgrade (an existing value is never replaced). The panel API and the job queues use it, and in production the API refuses to start without it.
  • Project containers now run on their own vexlyx-apps network, shared only with Traefik and the database servers, instead of the network that carries Redis, the API, the dashboard, mail and DNS. Existing projects are moved without a restart.

Upgrade notes ​

  • Re-run the installer. It creates the new network, generates the Redis password, and recreates Redis, Traefik, the database servers, the API and the dashboard, so every site pauses for a few seconds.
  • After a PHP or WordPress project moves, its nginx container is reloaded (restarted if the reload fails), so those sites can pause briefly once more. If a project cannot be moved the installer warns and retries on the next run.
  • Existing logins and queued jobs are kept: Redis data lives in its volume.
  • Anything of yours that connects to Redis directly now needs the password in /etc/vexlyx/vexlyx.env (REDIS_PASSWORD).

[0.4.1] - 2026-10-25 ​

Security ​

  • Static and no-build PHP sites now only serve site content: the panel's deploy folder and dot files such as .git and .env answer 404, while /.well-known/ stays reachable. Existing sites are updated on upgrade without a redeploy.
  • The legacy per-project GitHub webhook returns one identical 401 for unknown projects, projects without a secret and bad signatures (no more project-ID enumeration) and ignores replayed x-github-delivery IDs; requests without that header get 400 (#67).
  • The installer installs Node.js from the NodeSource apt repository with a fingerprint-pinned signing key (exactly one key accepted) instead of piping a remote script into root bash, and a generated admin password is shown on a real terminal only, never written to /etc/vexlyx/install.log or to redirected output (#72). Delete /etc/vexlyx/install.log on servers installed earlier.

Fixed ​

  • Large or slow file uploads are no longer cut off after 60 seconds, and an interrupted upload leaves no partial file behind, so a retry works (#155).
  • Adding, verifying, securing or removing a domain no longer restarts the shared Traefik proxy, so other sites on the server stay online (#156).
  • Custom domains on WordPress and no-build PHP projects route to the nginx container instead of PHP-FPM, ending the 502; existing route files are repaired automatically when the API starts (#150).
  • PHP-FPM can create, modify and delete files in the docroot of no-build PHP projects (and in WordPress's wp-content), so self-installing apps such as a Duplicator migration work; files saved or uploaded in the File Manager stay modifiable by the application, existing projects are fixed on upgrade, and the panel's deploy/ directory stays out of PHP's reach. The root of a git-connected project stays root-owned (PHP can write in its subfolders only), so pulls and auto-deploys keep working (#151).
  • Mail clients such as Thunderbird can add and test an account again: the authenticated submission port (587) accepts a pipelined EHLO/QUIT probe, while port 25 stays strict (#158).
  • A domain whose DNS is managed elsewhere now lists its DKIM record, together with MX, SPF and DMARC, the first time its mail authentication is checked, instead of only after "regenerate". The key is created once and never rotated by checking (#159).
  • A GitHub webhook whose build cannot be queued now marks its deployment FAILED and lets GitHub's retry succeed with one active deployment, instead of leaving a deployment QUEUED forever and duplicating it on redelivery (#68).
  • Deployed projects now get 512 MB of memory by default instead of 128 MB (DEPLOY_MEMORY_LIMIT). WordPress on Apache sat at its 128 MB limit and stopped answering requests.
  • The installer now recreates the API and dashboard containers after every run. They serve a build kept on the host, and Compose only recreated them when their configuration changed, so an upgrade that changed only code left the previous API process running.
  • Upgrading a v0.3.x server no longer stops over untracked files (such as .pnpm-store/) or file-mode-only changes on the tracked OpenDKIM key files; edits to tracked files are still protected.
  • Keep the dashboard's jsdom dependency compatible with the declared Node 22 minimum, and remove tracked development DKIM private keys from the checkout.
  • Dashboard tests now collect React component tests in jsdom while keeping utility tests in Node, with initial login and project-list smoke coverage (#54).
  • Switching to two-factor verification starts with an empty code field instead of retaining the sign-in email address, caught by the new login smoke test.

Upgrade notes ​

  • Re-run the installer; it applies everything below. From a v0.3.x server, upgrade to v0.4.0 mail state first as described in the 0.4.0 notes; the installer no longer stops for untracked files or mode-only changes.
  • Traefik restarts once (new upload timeouts), so every site is offline for a few seconds.
  • Postfix is recreated (submission-port change): mail delivery pauses for a few seconds and senders retry.
  • Site nginx configuration is refreshed for existing static and PHP sites, and the docroot ownership of existing no-build PHP and WordPress projects is repaired once (a marker file keeps it from repeating). Neither needs a redeploy.
  • Custom-domain route files are regenerated the first time the new API starts.
  • Existing projects keep their old 128 MB limit until they are redeployed. Set DEPLOY_MEMORY_LIMIT in /etc/vexlyx/vexlyx.env to choose another value, then redeploy the project.
  • Delete /etc/vexlyx/install.log if the server was installed before this version, since it may hold the generated admin password.

[0.4.0] - 2026-10-21 ​

Added ​

  • Scheduled tasks run project commands on a cron schedule, with manual runs, run history, server timezone support, per-user and reseller quotas, and optional failure emails. Commands run inside the project's application container with timeouts, bounded output, and overlap protection (#132).

Fixed ​

  • Mailbox, password, and alias changes now activate through validated Postfix and Dovecot state generations. Runtime maps and credentials persist across container recreation; failed activation returns an actionable error and rolls back to the previous state. Failed preparations remove unused generations, and development state ownership lets the host API write while keeping password files private (#100).
  • Release notes exclude prerelease tags when selecting the previous release boundary (#143).

Upgrade notes ​

  • Back up existing mail state and migrate it before updating the checkout. Follow docs/dev/email/mail-credential-remediation.md to preserve routing maps and signing tables, then restart the mail services with the updated Compose configuration (#100).
  • Apply the database migrations before starting the updated API; scheduled tasks adds task and run tables and the maxScheduledTasks user quota (#132).

[0.3.0] - 2026-10-20 ​

Changed ​

  • The one-line installer now installs the newest tagged release instead of the main branch, so a new server runs code that was tagged and tested. VEXLYX_REPO_REF still accepts an exact tag (v0.3.0) or a branch (main); re-running the installer moves a release install to the next release, and an install that already follows a branch keeps following it unless VEXLYX_REPO_REF=latest is set (#123).

Fixed ​

  • /api/health still reported version 0.0.1 after 0.2.0; a test now fails if any package version and VEXLYX_VERSION disagree (#121).
  • The installer no longer prints "Nixpacks install could not be verified" on working servers. Project builds run Nixpacks inside the API container, so the host copy was removed and Nixpacks is checked in the built API image instead (#124).
  • Restoring a MySQL or PostgreSQL database from a backup always failed with flush of closed file, and a MySQL database that had been dropped could not be restored at all. The restore now streams the dump correctly and recreates a missing MySQL database first. Found while testing a fresh server.
  • A normal install no longer ends with error-looking output: the mail images are built before the services start (no "pull access denied" lines, #133), the installer waits for the Let's Encrypt certificates before deciding whether to warn (#134), and the pnpm download prompt is gone (#135).
  • Outgoing mail was sent without a DKIM signature as soon as a mail domain was added or a key regenerated: the panel told OpenDKIM to reload with SIGHUP, which makes it exit. It now uses SIGUSR1, which reloads the tables and keeps the signer running (#138).
  • Mail from a newly added mail domain was refused with 451 Service unavailable until the Postfix container was restarted, because the panel created the DKIM private key with permissions OpenDKIM rejects. New keys are now created 0600 and handed to the opendkim user before the signer reloads (#141).

Security ​

  • Deleting a user now ends all of their sessions. Previously the deleted user's login cookie kept working for up to 24 hours (their requests were answered with empty data).
  • Known-password development mailboxes are no longer committed or mounted in production (#41). Dovecot refuses to start in production while a publicly known fixture credential is present; fresh installs create their runtime users file empty. Upgrading an existing server needs the one-time steps in docs/dev/email/mail-credential-remediation.md, because the installer leaves a checkout with local changes alone.
  • Auth rate limiting behind Traefik now counts per client IP instead of one shared bucket (new TRUST_PROXY setting).
  • Development Postgres, MySQL and Redis ports are bound to loopback only, and the MySQL healthcheck no longer exposes the root password in its command line.
  • Dashboard responses now carry a Content-Security-Policy (including frame-ancestors 'none'), X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy and, in production, HSTS.

Tests ​

  • Strict webmail TLS is now covered by a certificate matrix run against the real Roundcube image in CI: only a trusted certificate with the right host name succeeds, every rejected peer receives no credentials (#127).

Documentation ​

  • The FEATURES.md status table is recounted (it was out of date), the troubleshooting guide documents the forgot-password flow, the operations guide warns about upgrading servers installed before this release, and the release steps are written down in docs/dev/ci-cd.md and CONTRIBUTING.md (#130, #121).

Upgrade notes ​

  • Servers installed before 0.3.0 are not upgraded by re-running the installer. Older versions committed a mailbox file with publicly known credentials that the panel keeps rewriting, so Git refuses to update the checkout. Follow docs/dev/email/mail-credential-remediation.md first (it backs the file up, updates the checkout and removes the known credentials; Dovecot refuses to start in production while they are present), then re-run the installer so the new TRUST_PROXY setting is applied. Servers installed from 0.3.0 on are not affected.

[0.2.0] - 2026-10-16 ​

Added ​

  • File Manager permissions and archives: change file and folder permissions (octal and rwx editor, opt-in recursion), extract .zip, .tar, .tar.gz and .tar.bz2 archives, and compress a selection into a .zip, with zip-slip, link, size and compression-ratio protections. Limits are configurable through FILE_ARCHIVE_MAX_BYTES, FILE_ARCHIVE_MAX_ENTRIES and FILE_ARCHIVE_MAX_RATIO (F5.24).

Fixed ​

  • Every system script command and spawned manager is now time-limited, so a hung Docker, nixpacks or git call can no longer leave orphaned processes (#52).

Security ​

  • ENCRYPTION_KEY is now required in production and must differ from SESSION_SECRET, so a leaked session secret can no longer decrypt stored credentials (#69).

Documentation ​

  • Specifications for Redis instances (F5.30), MongoDB databases (F5.31) and opt-in anonymous usage statistics (F5.32).

Upgrade notes ​

  • Breaking for production installs that never set ENCRYPTION_KEY: the API will not start until you set it. To keep existing data readable, set ENCRYPTION_KEY_LEGACY_FALLBACK=true temporarily, run pnpm db:reencrypt, then remove the flag. Installer-generated installs already have a key. See docs/dev/environment-variables.md.

[0.1.0] - 2026-10-14 ​

Added ​

  • GitHub App integration with repository and branch selection, short-lived installation tokens, and automatic deployment webhooks.
  • One-command local development bootstrap with prerequisite checks, generated secrets, infrastructure startup, migrations, and seed data.
  • VitePress documentation site with installation, operations, troubleshooting, developer, and generated API references.

Changed ​

  • Runtime container health checks now avoid unavailable application dependencies.
  • GitHub App setup uses a streamlined self-hosted manifest flow.
  • Documentation is organized by user intent and publishes project changelog entries automatically.

Fixed ​

  • GitHub App manifest OAuth configuration.
  • Production domain assignment and routing behavior.
  • System transactional email sender configuration.

Release automation updates this file from Conventional Commits through git-cliff. See docs/dev/ci-cd.md.

Released under the MIT license.