Changelog
All notable changes to Vexlyx are documented here. The format follows Keep a Changelog and releases use Semantic Versioning.
Unreleased
Changed
- Explicit
anytypes and strayconsole.logcalls now fail lint and CI (#58). Operationalconsole.warn/console.errorcalls remain allowed; CLI regression probes verify both API and dashboard enforcement.
Security
An uploaded custom SSL private key is passed to
ssl_manager.pyon stdin instead of its command line, so it is no longer readable throughpsor/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.pywrote every PEM withPath.write_text(), which means the mode comes from the process umask; the panel's ownvexlyx-apiimage runs asuid=0(root)with umask0022, so a key landed0644— 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) reportsRan 12 tests … FAILED (failures=6, errors=5)and the mode assertions answer420where they demand384, i.e.0644against0600. The files live indocker/traefik/certs, which Traefik mounts into its container (/opt/vexlyx/docker/traefik/certs -> /etc/traefik/certs, modero), and that directory was0755 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-traefikis 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 ownapps/api/workspaces/projects/<id>trees and their own generateddeploy/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) reportsuid=0(root)andvexlyx-apireportsuid=0(root), so0600costs 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, is600 root:rooton that box, andsystem/python/mail_tls_manager.py:62-63writes its certificate0644and its key0600. The helper now matches it.atomic_write()(ssl_manager.py:87) is the functionmail_tls_manager.py:32has 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 bychmod()would have left a window in which the key was world-readable on its way to0600.PRIVATE_KEY_MODE = 0o600andCERTIFICATE_MODE = 0o644are named at:79-80and applied at all six write sites — the pair ingenerate_self_signed()(:214-215), its convenience copy (:220-221) and the pair insave_custom_certificate()(:390-391); a certificate deliberately keeps0644, 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/.keynext to the domain's owndomain-<id>pair as a convenience, anddelete_custom_certificate()removed only thedomain-<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, fromdisableSsl(), 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, becausegenerate_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.copiesRemovedis in the answer so the deletion is observable. Nothing outside the helper reads those names: the certificate paths any consumer is configured with aredomain-${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 givesRan 12 tests … OKwith all twelve executed, the suites that already cover this helper are unchanged on both trees (test_ssl_management7 with 1 skipped,test_ssl_manager_stdin6), 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 thedelete_certpayload 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()resolvesdocker/traefik/certsrelative 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 at0644tightens it, content round-trip with no.temporary left behind, copies removed on delete including a wildcard'swildcard.-cleaned name, a copy whose bytes are not this certificate's left untouched, and another domain's files untouched. It is wired into thetestjob (.github/workflows/ci.yml:96) because that job lists Python files one by one and an unnamedtests/test_*.pynever runs in CI (#226); its mode assertions are@unittest.skipUnlesson 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 gets0700(:123) — a directory mode hides file names, not contents, and after this change the contents are0600/0644anyway, while tightening a directory that unknown host tooling may already traverse is a wider decision than this fix; an install that wants0700on the directory it already has canchmodit 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 isremoveTraefikRouter()inapps/api/src/modules/domains/service.ts:386-396, which unlinks onlydomain-<id>.crt/.keyand 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
Dockerfilethat is a symbolic link no longer reads or overwrites files outside its own project (#193).system/python/build_manager.pyruns 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 withDockerfileaimed at a panel file:GET /api/projects/:id/dockerfile(apps/api/src/modules/dockerfile/routes.ts:28) handedcmd_dockerfile_get()'s answer straight back to any authenticated project owner, which was the linked file's text verbatim, andPUTon the same route (:44) hadcmd_dockerfile_save()callPath.write_text()on the link — which follows it — so the save rewrote the target as root: the panel's owndocker-compose.prod.yml, a source file the API imports, or/root/.ssh/authorized_keys..dockerignorebehaved the same way, and the write-through-link existed one layer down too:docker_manager.pyguarded thedeploy/directory withassert_deploy_dir_is_not_a_symlink()(:108) butgenerate_compose_file()(:552),generate_nginx_conf()(:568) andrefresh_nginx_conf_for()(:606) wrotedeploy/docker-compose.ymlanddeploy/nginx.confwithwrite_text(), and application code running in a project can plant those names inside its own directory. Reads now go throughread_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 throughwrite_project_file()(:115), which refuses a link at the file's own name (UNSAFE_DOCKERFILE_LINK,UNSAFE_DOCKERIGNORE_LINK) and opens the rest withO_NOFOLLOW, which also catches a link swapped in between the check and the open.docker_manager.py:122gained the same rule aswrite_generated_file()(UNSAFE_DEPLOY_FILE) for all three generated files. Both write withO_TRUNCon the opened descriptor instead of replacing the path, so a file keeps its inode — which is what a deployed site needs, because itsdeploy/nginx.confis 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 ordinaryDockerfileand.dockerignoreround-trip byte-for-byte and the parsedEXPOSE/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 ownvexlyx-apiimage (Python 3.11.2, real symlinks, both trees): the newtests/test_symlink_safe_project_files.pyagainst the unpatched scripts isRan 12 tests … FAILED (failures=6)— two of those failures are the deploy generators reportingSystemExit not raised, i.e. writing through the link and into the file behind it — andRan 12 tests … OKagainst the patched ones, with the suites that pin the working deploy path green on both trees (test_nginx_conf_refresh9,test_compose_healthcheck_target8,test_dockerfile_build_nixpacks_absent1). Scope, honestly: this closes the panel's own read and save ofDockerfile/.dockerignoreand 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.pyandcomposer.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 amanage.pysettings-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 containsDJANGO_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 thetestjob (.github/workflows/ci.yml:97) because that job lists Python files one by one and atests/test_*.pynot named there never runs in CI (#226); it plants real links, so it self-skips wheresymlink()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
domainoverride 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:575hands it tosystem/python/docker_manager.py, where:848makes it the hostname (payload.get("domain") or f"{slug}.{base_domain}") andgenerate_compose_file()substitutes it into the twoHost(`{{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 closesHost()and reopens it, and a quote plus a newline closes the label and starts another one. Measured on the QA box inside its own runningvexlyx-apiimage (Python 3.11.2) against the unpatched generator that box has checked out (4cbbfb7),app.example.com`) or Host(`victim.example.orgproduced a manifestdocker compose configaccepted — exit 0, two rules,Host(`app.example.com`)andHost(`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 extratraefik.http.*label, also accepted, which is how a router gets pointed at another tenant's container. A third attempt (newline plus a top-levelvolumes: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 ofgenerate_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 answersINVALID_HOSTNAME, whichdeploy/service.ts:145already 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/sharedHostnameSchemathatCreateDomainSchemaapplies 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 400VALIDATION_ERRORfromplugins/error-handler.ts:73instead of a deploy. Worked today, still works, all measured in the same run: a legitimate hostname renders a manifestdocker compose configstill 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.orgshapes 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_refresh9,test_compose_healthcheck_target8,test_symlink_safe_project_files12,test_dockerfile_build_nixpacks_absent1, 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 aHost()backtick pair, which is what keeps the guard's character set tied to the text it protects; it is wired into thetestjob (.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-293renders the per-domain dynamic route file (rule: ${rule}, written unquoted at:328,:334,:351) fromdomain.hostnameplusdomain.pathPrefix, and while the hostname there is covered — the sameHostnameSchemarejects a backtick, a quote or a newline —pathPrefixis only checked byCreateDomainSchemato start with/(packages/shared/src/schemas/domains.ts:128-136), so it arrives in aPathPrefix()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:848feeds both into one call — so an install whoseBASE_DOMAINis not name-shaped (a port or a slash in it) now refuses the deploy withINVALID_HOSTNAMEinstead 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 touploadCustomCert(), which builds thesave_custompayload withprivateKey: input.privateKey(apps/api/src/modules/domains/ssl-service.ts:506-509) and passed it torunSslManager(), which started the helper asspawn(pythonExe, [scriptPath, command, JSON.stringify(payload)])(:131before 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 whatpsprints and what/proc/<pid>/cmdlineserves, which a default Linux opens to every local process (mode 0444, nohidepid), 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 ownvexlyx-apiimage on the QA box (Python 3.11.2, cryptography 50.0.2, checkout4cbbfb7) usingvalidate_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>/cmdlinefrom a side thread and reporting only whether key material was present: the old argv invocation giveskey_visible_in_cmdline: true, the stdin one givesfalse, and both answer identically (stdout_lines: 1,exit: 0,success: true). The request moved, not the helper:ssl_manager.py'smain()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 — sorunSslManager()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 unhandlederroron a writable is what turns that into a crashed API process, while the existingclosehandler (:167) already reports the real failure. Worked today, still works: a matched pair over stdin answerssuccess: trueand 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 tworunSslManager()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), anddelete_cert(:742) sends only a domain id. argv stays supported on purpose (:384-386): that is the CLI's form, and the formtests/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, andsuccessasserted so the equality cannot be vacuous, wired into thetestjob (.github/workflows/ci.yml:92) because that job lists Python files one by one and an unnamedtests/test_*.pynever runs in CI (#226); andapps/api/src/modules/domains/ssl-manager-spawn.test.ts(2 vitest) guards the caller, mockingnode:child_processto 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_NAMESERVERSdefaulted tons1.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 fromdocker-compose.prod.yml): when unset, the delegation check answersconfigured: falsewith no nameservers,PATCH /api/domains/:id/dns-modetoMANAGED(including "Prepare zone") returns 409DNS_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 withDNS_NAMESERVERSset is unchanged, and the zone-file fallback for existing zones is untouched. Operators who relied on the old default must now setDNS_NAMESERVERSexplicitly.CI now runs the Python suites it was silently skipping, and fails when a new one is left out (#226).
.github/workflows/ci.ymlhad no test discovery: every suite was named by hand, aspython3 -m unittest discover -s tests -p test_<name>.pyorpython3 -m unittest tests.test_<name> -v, so the workflow was a per-file allowlist with nothing checking it was complete. Measured onmainat6eebfa5: 58 files matchedtests/test_*.pyand 26 were named anywhere in the workflow — the other 32 had never run in CI. That is not a hypothetical. PR #225 addedtests/test_git_branch_switch.py, whose four tests were the entire evidence for its fix; the first push came backlint / typecheck / build / testall 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.pyis now a step in thetestjob and fails on a suite that is neither named nor deliberately excluded. It also reports a named suite from whichunittest discovercollects nothing: ten of the files undertests/define module-leveltest_*functions and amain()with nounittest.TestCase, so wiring one in as-is is not a working test — measured on Python 3.12.3 and 3.14.6,discoveron such a file printsRan 0 tests/NO TESTS RANand 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 actualrun:steps count, block scalars included, so a comment mentioning a suite name cannot make it look covered. Exclusions now live intests/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) andtest_subprocess_timeouts(13) — 66 tests, each executed before being added rather than assumed, on Windows and on a Linux sandbox built fromgit archiveof 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 reads59 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 localTestCasebase — 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_reloadraisesModuleNotFoundErrorat import (:14loadspostfix_managerwithoutsystem/pythononsys.path),test_nextjs_runtime:174assertsconnect(3000,'127.0.0.1'whilenext.yml:25probesrequire('os').hostname()(#202),test_php_wordpress_runtimeexpectswp-config.php/.htaccessscaffolding thatbuild_manager.py:1488-1493replaced withwp-contentonly, andtest_dovecot_imap:36plustest_mailbox_management/test_postfix_smtpstill read config paths that moved toactive_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_guidanceis hermetic but measured at 291s for 3 tests — its fake cert store never matches, so16-summary.shsleeps 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 inmail-stateormail-credential-securitycounts as covered even though it does not run in thetestjob; 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.pyis read from the bind-mounted checkout (docker-compose.prod.yml:181) every time the API invokes it, so agit pullstarts writing every key0600on 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 untilvexlyx-apiis next built: it removesdomain-<id>.crt/.keyand leaves the<host>.crt/.keycopies 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.crtfiles can stay644; they are public and other tooling reads them. Tightening the directory to0700is likewise left to the operator (sudo chmod 700 /opt/vexlyx/docker/traefik/certs) — the two things that read it,vexlyx-traefikandvexlyx-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.pyandsystem/python/docker_manager.pyare 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
Dockerfileis 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.pyis read from the bind-mounted checkout per command, so agit pullstarts 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 baddomaingets the 422INVALID_HOSTNAMEfrom the deploy itself, which is the same decision made one layer down. - One behaviour change to know about:
POST /api/projects/:id/deploywith adomainthat is not a hostname or an IPv4 address — a URL, ahost:port, a value with a space or a trailing slash, a single label likelocalhost, an IPv6 address — is now refused instead of being deployed. Nothing in the panel sends that: the dashboard never passesdomain(no/deploycall exists inapps/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.pyis 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 agit pull: an installed panel keeps putting the uploaded key in the helper's argv untilvexlyx-apiis 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_*.pynow means either naming it in thetestjob or adding a line totests/ci-excluded-suites.txtwith the reason, becausepython3 tests/check_ci_suite_coverage.pyfails the job otherwise. The same check runs locally intests/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
Dockerfileno longer needs Nixpacks installed (#222).cmd_plan()insystem/python/build_manager.pyresolved the Nixpacks binary four lines after reading the payload and only looked for aDockerfilethirty lines later, even though that branch answers the request fromparse_dockerfile_info()alone and never runsnixpacks 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 fromcmd_build()one layer down bya44b565, 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 thenixpacks planinvocation (:1086-1090), which is also what makes a missing workspace reportPROJECT_DIR_NOT_FOUND— the true cause — instead ofNIXPACKS_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'spnpm dev, which spawnsbuild_manager.pyon the host interpreter) and any install that later stops shipping Nixpacks.tests/test_dockerfile_plan_nixpacks_absent.pypins the ordering three ways — aDockerfileproject 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 ownvexlyx-apiimage (Python 3.11.2), where running the realcmd_planagainst both aDockerfileproject and a Flask project produced byte-identical output before and after, so nothing that works today changes. Wired into thetestjob (.github/workflows/ci.yml:91-93) because that job lists Python files one by one and atests/test_*.pynot 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.pyclones with--single-branch, which writes a restricted fetch refspec —+refs/heads/main:refs/remotes/origin/main— so the sync path's plaingit fetch originnever learned a branch added later,git checkout <branch>failed witherror: 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_clonenow 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 writesFETCH_HEAD, and even a refspec-qualified fetch that does createorigin/<branch>leavesgit 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-dockertrackingorigin/vexlyx-docker— switching back tomainworks, 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.pyruns the real git binary against a local repository rewired behindhttps://github.com/team/repothroughGIT_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 coveringgit_manager.py(23 tests) still pass. The new suite is wired into thetestjob (.github/workflows/ci.yml:79-81), which lists Python files one by one — atests/test_*.pythat 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.phpappliedROUNDCUBE_MAIL_TLS_PEER_NAMEonly 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_NAMEfor the operator reading the config, andVEXLYX_MAIL_HOSTNAMEbecause 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, defaultmail.$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:122records the same in the TLS policy section, next to the note at:125about 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 forROUNDCUBE_MAIL_TLS_VERIFY=falseis byte-for-byte what it was.tests/test_roundcube_tls.pypins the three blank shapes (absent, empty, whitespace-only) to "verification on, nopeer_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:63stated eviction wasallkeys-lruand:71listed "API response caching, rate limiting" as Redis consumers, but the shipped command line is--maxmemory-policy noeviction(docker-compose.yml:68) andCONFIG GET maxmemory-policyagainst the QA panel's runningvexlyx-redisanswersnoeviction(measured 2026-11-05), while neither use exists in the code: the only thing cached in Redis is the 6-hour release lookup keyedsystem:update-info(apps/api/src/modules/system/update-service.ts:11-12) and@fastify/rate-limitis registered with nostoreoption (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 defaultsave 3600 1 300 100 60 10000snapshot 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.mdneeded no matching edit: it is generated from this file bydocs/scripts/sync-docs.mjsand 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 inFEATURES.mdcarried 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-alpinepins only the major, and the container on that box reportsredis_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 — onmainand on the box's checkout there is noRedisInstancemodel ormaxRedisInstancesquota inapps/api/prisma/schema.prisma, nosystem/python/redis_manager.py, noapps/api/src/modules/redis/and no shared schema, andDatabaseTypestill has exactly two values; meanwhile the isolation the feature prescribes for tenant instances is already the production topology, becausevexlyx-redisjoins onlytraefik-netandvexlyx_default, publishes nothing on the host (docker-compose.prod.yml:37, nothing listening on6379), and a container attached tovexlyx-appsalone could not open its socket. Documentation only — no behaviour, configuration or container change; nothing to set up.The F5.2 acceptance list in
FEATURES.mdno longer credits a headline it did not earn:Support for custom build commands overridewas 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/vexlyxcheckout is bind-mounted into the container at the same path the host uses (docker-compose.prod.yml:181) andsystem/python/git_manager.pyandbuild_manager.pyare 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.phpis 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 rendersVEXLYX_MAIL_HOSTNAMEsees 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 aDockerfilestill 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
noevictionpolicy 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.jsonintogrep -Eq, andgrep -qexits the instant it matches — so the writer was still delivering the rest of the store when its read end closed, it died ofSIGPIPE, andset -o pipefailat 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, and2>/dev/nullhid 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 coveringdomainandapi.domaintogether, 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 ownpipefail, 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 intogrepagain 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.txtpublic 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.gitignorehas ignoreddocker/postfix/opendkim/keys/*/the whole time — an ignore rule never applies to a path that is already tracked, so the directory looked correctly excluded whilegit 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 liveKeyTablenever referenced them), but they were not harmless:mail_state_migrate.pycopies every file it finds underdocker/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.privateand 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'susers) are untracked and regenerated, so no install starts with a Windows path or a developer's domain in it, and the pull guard compares withcore.fileMode=false, which is what makes thechmod -Rthe Postfix entrypoint runs on key files a non-event instead of a reason to refuse an upgrade — confirmed on a server whosegit statuslists 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) andsystem/scripts/install/config.sh(:49) each defaultedVEXLYX_REPO_URLtohttps://github.com/atlantiqs-org/vexlyx.git— the org slug from before the rename toatlantiqshq— and it resolved only because GitHub redirects a renamed owner: measured on a live server,atlantiqs-org/vexlyxanswers301whileatlantiqshq/vexlyxanswers200. 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'sDEPLOY.mdalready tells the releaseer to "checkinstall.shandsystem/scripts/install/config.shinatlantiqshq/vexlyxboth point athttps://github.com/atlantiqshq/vexlyx.git", and both files pointed somewhere else. Both defaults now name the current slug, and an operator-setVEXLYX_REPO_URLstill 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 installedv0.4.6correctly through the old URL (resolved as a tag, cloned,VEXLYX_VERSIONin the tree reading0.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.pyfails if the bootstrap and the orchestrator disagree, if either stops naming the current slug, or if either stops honouring an override.DEV.md's olderatlantiqs-orgline 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) 143andPort (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 withsmtpd_tls_security_level=encrypt(docker/postfix/master.cf:8,10) and Dovecot hasdisable_plaintext_auth = yes(docker/dovecot/dovecot.conf:40), so a client left on None is refused at the password step withMust 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 that587is the only submission port because there is no465listener to offer —master.cfdefinessmtpandsubmissionand nothing else,docker-compose.ymlpublishes25/587/143/993, and searching the repo for465returns 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.tsxpins the copy to the configuration it was written from — the exact port list, each port's security mode,Normal passwordin both sections, the server's own refusal string, the465statement, 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.mdalready stated the security modes the dialog omitted; its table now carries the same Authentication column, the143row and the465note. The Phase 2 half of #160 is not in this release: serving ThunderbirdautoconfigXML and Outlookautodiscoverneeds 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
Dockerfilebuild 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 reachedcmd_build()on a host with Docker but without Nixpacks failed withNIXPACKS_NOT_FOUNDon a build that only ever runsdocker build. The lookup now sits after that branch returns, atsystem/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.pydrives the realcmd_build()against a fakedockeronPATHwith Nixpacks deliberately unresolvable, asserts the build reportsdone: trueand 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 callscmd_build()(apps/api/src/modules/build/service.ts:493), andcmd_plan()still resolves the binary atbuild_manager.py:1059— ahead of the same Dockerfile branch, which answers fromparse_dockerfile_info()and returns at:1087without touchingnixpacks_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.pyis 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 withVOLUME, and Compose reattaches that anonymous volume on every redeploy —up -d --force-recreate --pull missingis 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-recreatecan survive its owndown --volumesas an orphan that onlydocker volume prunereclaims. 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 neverwhilesystem/python/docker_manager.py:889has run--pull missingsincea5bc003(2026-09-10, the no-build static and WordPress serving path), which replaced the--pull neverthatb64729bfirst wrote — so the repo's two deploy docs disagreed with each other,docs/dev/runtimes/custom-dockerfile.md:137quoting--pull missingand 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 whatmissingdoes 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 neverdeliberately: it is dated bygit blametof716b9d, committed the same day but roughly twelve hours beforea5bc003, 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.shis 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.shrun deletes the four developer-domaindefault.txtrecords from/opt/vexlyxas 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_URLwas 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.1now says so in the build log instead of finishing silent. For an image that declares noHEALTHCHECK, 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 eitherRoutable check <gw>:<port> answered — this container accepts connections from outside its own loopbackor a warning naming that port, the domain, and the fix (bind to$HOSTNAMEor0.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'svexlyx-appsaddress, 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
HEALTHCHECKdeploy exactly as before; the rest gain a few seconds of post-startup probing. Becausedocker_manager.pyis 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 binds127.0.0.1instead 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 inspectnow reads.State.Healthalongside 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.1orlocalhost, 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 nowgetat all, so anywget-based check there exits 127; busybox resolveslocalhostto::1before127.0.0.1, so an app correctly bound to IPv4 loopback looked unhealthy; and the nginx checktest $? -ne 4only trips GNU wget's network-failure code, whilenginx: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, orncon 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/statusonly gains an extracontainerHealthfield (healthy/unhealthy/starting, ornullwhen 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,startCmdandportalready 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 — sonixpacks build --install-cmdhad 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=falseon an air-gapped server, orUPDATE_CHECK_REPOto publish from a different repository.
Fixed
- WordPress plugin and theme uploads accept real archives again: the panel streams them as
multipart/form-datainstead of base64 inside a JSON body, so a several-megabyte theme no longer fails with413 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 aspreviousWorkspace) 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=falseskips the lookup entirely.
[0.4.2] - 2026-10-26
Security
- Redis now requires a password. The installer generates
REDIS_PASSWORDon 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-appsnetwork, 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
deployfolder and dot files such as.gitand.envanswer 404, while/.well-known/stays reachable. Existing sites are updated on upgrade without a redeploy. - The legacy per-project GitHub webhook returns one identical
401for unknown projects, projects without a secret and bad signatures (no more project-ID enumeration) and ignores replayedx-github-deliveryIDs; requests without that header get400(#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.logor to redirected output (#72). Delete/etc/vexlyx/install.logon 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'sdeploy/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/QUITprobe, 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_LIMITin/etc/vexlyx/vexlyx.envto choose another value, then redeploy the project. - Delete
/etc/vexlyx/install.logif 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.mdto 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
maxScheduledTasksuser quota (#132).
[0.3.0] - 2026-10-20
Changed
- The one-line installer now installs the newest tagged release instead of the
mainbranch, so a new server runs code that was tagged and tested.VEXLYX_REPO_REFstill 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 unlessVEXLYX_REPO_REF=latestis set (#123).
Fixed
/api/healthstill reported version0.0.1after0.2.0; a test now fails if any package version andVEXLYX_VERSIONdisagree (#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 unavailableuntil the Postfix container was restarted, because the panel created the DKIM private key with permissions OpenDKIM rejects. New keys are now created0600and handed to theopendkimuser 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_PROXYsetting). - 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-Policyand, 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.mdstatus 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 indocs/dev/ci-cd.mdandCONTRIBUTING.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.mdfirst (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 newTRUST_PROXYsetting 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.gzand.tar.bz2archives, and compress a selection into a.zip, with zip-slip, link, size and compression-ratio protections. Limits are configurable throughFILE_ARCHIVE_MAX_BYTES,FILE_ARCHIVE_MAX_ENTRIESandFILE_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_KEYis now required in production and must differ fromSESSION_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, setENCRYPTION_KEY_LEGACY_FALLBACK=truetemporarily, runpnpm db:reencrypt, then remove the flag. Installer-generated installs already have a key. Seedocs/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.