Skip to content
SHC Docs

Licensing postures

Upstream licensing is not static. Projects move capabilities into paid tiers, relicense whole codebases, and carve proprietary directories out of otherwise-open repos, and each of those events arrives in a catalog as an ordinary-looking version bump. This page documents the recurring patterns and the posture SHC takes for each, so a catalog decision that looks odd in isolation (“why are there two DefectDojo apps?”) reads as the application of a rule.

Every license claim on this page was verified against a primary source, not repeated from memory, and which primary source is itself a rule. A package’s own terms come from the upstream project’s licence files. What an image BUNDLES comes from the image: its apk/rpm/dpkg database, its jar contents, the %license payloads it actually ships. An upstream LICENSE is the right answer to the first question and the wrong answer to the second, and the component audit below is what reading the images rather than the repos turned up. Where a claim has not been checked that way, it says unverified in place; one does today (Redpanda’s Additional Use Grant on the tag Huly pins). Keygen’s Fair Core License was read on 2026-11-01. A licensing page that quietly rounds an unchecked claim up to a verified one is worse than no page.

This page is the doctrine. The per-app facts live in each package’s own app.yaml, under a top-level license: key:

license:
id: AGPL-3.0-or-later
source: docs/guide/apps/licensing-postures.md

Note the -or-later. Bare AGPL-3.0, GPL-3.0 and LGPL-3.0 are DEPRECATED SPDX identifiers: SPDX split each into an -only and an -or-later form precisely because the bare token does not say whether the “or (at your option) any later version” sentence applies, and that sentence is the difference between two different licences. Read the project’s file headers, not its LICENSE file: the LICENSE is the same GNU text either way, and the election lives in the per-file notice. A bare token here is a declaration that has not finished being made; it shipped on openobserve until 2026-08-07.

Every shippable package declares one, enforced by scripts/arch-fitness.sh’s app-license-declared check, so “which apps are AGPL?” is a grep rather than an archaeology exercise. The full field reference is in app definition.

The honest part of that inventory is id: unverified, which means no in-repo source establishes this app’s licence yet. It is a legitimate declaration and a work item, not a failure: at the time the field landed (2026-08-07) 62 of 79 packages were unverified, because only 17 had a licence fact verified anywhere in this repository. Resolving one means doing the verification this page describes (reading the upstream’s own licence files) and then citing the result in source:. Do not close the gap by guessing.

The 2026-11-01 pass took the count from 71 to 32; see the upstream licence register.

The built-in packages, and why they were the last to be recorded

Section titled “The built-in packages, and why they were the last to be recorded”

Four packages ship inside the shc binary rather than through the catalog: postgres, keycloak, openobserve and traefik (the list in apps/BUILTINS). All four live in the ce repo at modules/<app>/, and make modules/stage assembles them into apps/<app> as a build product. Nothing commits those staged copies. (license was a fifth until 2026-08-18, when the app-licence socket was amputated and the broker moved to a deployfile; see docs/decisions/2026-08-18-builtin-vs-deploy-placement.md.)

branding was a sixth until 2026-08-18, when it was retired to the daemon (the S3-only ruling): its brand store moved to the estate’s S3 connection and shcd serves the assets, so there is no package and no image left to licence. Its row is kept below for the archive; the component audit it triggered is still the reason the second corpus exists.

That staging step is why they were the last packages in the estate to get a license: field. make lint is hermetic by design (it has no configure prerequisite), so in CI apps/ never contains a built-in and the catalog-wide check walked straight past all five without ever saying so. The fix is a second corpus with its own floors (addon-license-declared, reading the source trees rather than the staged copies); the facts it now demands are these.

PackageidWhat was verified
postgresPostgreSQLPercona’s own licensing page for the 16 line: Percona Distribution for PostgreSQL is “licensed under the PostgreSQL license and licenses of all components included in the Distribution”. PostgreSQL’s COPYRIGHT carries the BSD-style PostgreSQL License. The percona-docker build files are Apache-2.0: packaging, not the server. Six components: carry what Percona adds on top, read from the image’s own RPM database; see the component audit below.
keycloakApache-2.0keycloak/keycloak LICENSE.txt is Apache License 2.0. The pinned image is SHC’s build on the multiplatform.one Keycloak image, itself Apache-2.0, but its login theme is Keycloakify output and therefore MIT, which is a components: entry. See the component audit below.
openobserveAGPL-3.0-or-laterTwo builds, one package, and the id names the one that ships by default: the AGPL build since 2026-11-01 (FZ-8773). See below.
traefikMITtraefik/traefik LICENSE.md is “The MIT License (MIT)”. The pinned image is SHC’s build of that release with SHC’s own local Yaegi plugin baked in. Its init sidecar is Busybox, whose LICENSE states version 2 is the only version it may be distributed under (GPL-2.0-only).
branding (retired 2026-08-18)LicenseRef-SHC-EESHC’s own package; there was no upstream. The software it deployed was a stock nginx image (nginx/nginx LICENSE, 2-clause BSD) on an Alpine base whose userland is GPL-2.0-only and whose envsubst is GPL-3.0-or-later. See the component audit below.

The id column above records each package’s own terms. Those were recorded from upstream licence files, which is the right source for the primary claim and the wrong one for everything an image bundles. So the five deployed images were read directly (apk/rpm databases and jar contents at the pinned digests), and the results below are what that measurement found. Three of them contradict what was recorded.

Re-measured 2026-08-07 (second pass), and the corrections landed in ce. Every claim below was checked again from the images rather than carried forward from the first pass, on the principle that a licence field asserted on secondhand evidence is the failure mode this whole section exists to close. Two of the first pass’s own numbers moved (the BSD-2-Clause arm on postgres does not exist, and percona-telemetry-agent is AGPL rather than GPL-3), and both are written up in place below rather than quietly amended.

★ postgres’s id: PostgreSQL was not reproducible, and the fix has LANDED in ce. The Percona sentence the declaration quotes says the distribution is licensed under the PostgreSQL license “and licenses of all components included in the Distribution”: that trailing clause is the load-bearing half, and the declaration dropped its force. Percona does not enumerate those components, so the pinned image was read instead: of 526 RPMs, the server and its extensions (pgaudit, pg_stat_monitor, pgvector, set_user, pg-telemetry, libpq) are PostgreSQL, but patroni and pgbackrest are MIT, pg_repack and wal2json are BSD, postgresql-common is GPL-2.0-or-later, and percona-telemetry-agent and percona-release are GPL-3-family. A single-token PostgreSQL claim over that is a declaration nobody can reproduce.

Of the two shapes this section originally proposed (a compound id expression or a components: list), components: is the one that landed, because a flattened PostgreSQL AND MIT AND BSD-3-Clause AND ... answers “which licences are in here” while destroying “which component carries which”, and the second question is the one an auditor actually asks. The id therefore still reads PostgreSQL: it is the licence of the software this package deploys, which is the field’s definition, and the six components: entries carry the rest, each naming the RPM it came from. The note beside them gives the reproduction command (rpm -qa --qf '%{NAME}\t%{VERSION}\t%{LICENSE}\n' inside the image) so the whole set can be re-derived rather than trusted. Exposure is low: nothing is source-available or non-commercial, and the GPL items are separate executables (mere aggregation), not linked into the server. This is a declaration-accuracy defect, not a resale one.

Two corrections to the numbers this section first recorded, both measured against the pinned digest on 2026-08-07:

  • The BSD arm is BSD-3-Clause only: there is no BSD-2-Clause component. Both RPMs carry RPM’s bare legacy BSD tag, which does not say which; reorg/pg_repack’s COPYRIGHT at ver_1.5.3 and eulerto/wal2json’s LICENSE at wal2json_2_6 both carry the three-clause text, non-endorsement clause included.
  • ★ percona-telemetry-agent is AGPL, and its RPM tag hides it. The tag says License: GPLv3. The project the same RPM names in its own URL field (github.com/percona/telemetry-agent) ships the AGPLv3 text as its LICENSE at v1.0.14, and cmd/telemetry-agent/main.go’s header reads “either version 3 of the License, or (at your option) any later version”. So the correct id is AGPL-3.0-or-later, and this image does contain AGPL software. It is dormant: the RPM’s only launcher is /usr/lib/systemd/system/percona-telemetry-agent.service, there is no systemd in the container, and /entrypoint.sh (which runs postgres) never mentions telemetry in its 327 lines. A separate, unstarted executable is mere aggregation, and §13 needs a user interacting with it over a network.

★ percona-pg_cron_16 is tagged AGPLv3 in RPM metadata and is not AGPL. The licence file inside the image (/usr/share/licenses/percona-pg_cron_16/LICENSE) is byte-identical to citusdata/pg_cron’s LICENSE at v1.6.7, the Citus Data permissive grant, the PostgreSQL License text. So there is no network-copyleft exposure from it, but it is the only AGPL string in all 526 RPM tags, so any SBOM scanner reading RPM metadata will report AGPLv3 inside the production database image, and an auditor who finds it before finding this paragraph will treat it as a finding. It is a Percona packaging bug; record it, do not chase it.

★ The two RPM-tag defects point opposite ways, and that is the trap. pg_cron’s tag over-states (says AGPL, is not) and telemetry-agent’s under-states (says GPLv3, is AGPL). Dismissing the scanner’s single AGPL hit is correct; concluding from that dismissal that the image contains no AGPL is not. Both facts are recorded together in modules/postgres/app.yaml’s components:, deliberately on the package rather than only here, because the reader who needs them is an SBOM triager holding a scanner report, and the manifest is what a scanner points at.

keycloak’s Apache-2.0 stands: keycloak/keycloak LICENSE.txt at 26.7.0, the version the pinned digest reports, with corrections to what the image was believed to contain. keycloakify is MIT, not Apache-2.0, and that one is now a components: entry in ce. It is the correction with the most surface behind it: the login theme is not hand-written Keycloak FreeMarker but Keycloakify output, and the evidence is in the shipped jar rather than in a build file: all 50 .ftl files under theme/platform-keycloak/login in multiplatform-theme.jar carry the <#assign xKeycloakify={... "keycloakifyVersion": "11.15.3" ...}> preamble Keycloakify emits. keycloakify/keycloakify is MIT at exactly that tag, by both its LICENSE and its package.json.

The rest of the image’s bundled jars are measured and named here but are not enumerated in components: yet, and that is a deliberate stop rather than an oversight. Reading /opt/keycloak/providers at the pinned digest finds six jars, not the three the note named: multiplatform-keycloak.jar and multiplatform-theme.jar (com.bitspur), shc-keycloak.jar (first-party, the licence gate), keycloak-domain.jar (com.bitspur, shading Apache Kerby), keycloak-siww.jar (com.bitspur, shading web3j, com.moonstoneid:siwe-java 1.0.1 and apg-java 1.1.1, snakeyaml 2.2), and keycloak-scim-1.0-SNAPSHOT-all.jar, a 15 MB shaded fat jar carrying de.captaingoldfish:scim-sdk-{client,common} 1.25.1, Bouncy Castle, Jackson, Apache Commons, HttpComponents and the Jakarta APIs, whose META-INF holds Apache-2.0 and EPL-2.0 licence files at once. de.captaingoldfish’s SCIM-SDK is BSD-3-Clause upstream, and the near-miss is worth keeping: the same author sells a commercially licensed “scim-for-keycloak” product, and this is not it. Nothing found so far is resale-restricted. But attributing SPDX ids across a shaded fat jar is a per-artifact pass, not a hand-list written from package roots, and a partial components: list would read as a complete one. It stays a counted gap here until that pass is done.

openobserve’s split is confirmed against the EULA itself, re-read at openobserve.ai/legal/enterprise-license on 2026-08-07 (50 GB/day, per legal entity, affiliates aggregated, no key, no registration, and the free grant expressly conditioned on telemetry). Two corrections, both now LANDED in ce. The SPDX id was wrong on both counts: upstream’s source headers read “either version 3 of the License, or (at your option) any later version”, so the arm is AGPL-3.0-or-later, and bare AGPL-3.0 is a deprecated identifier besides. And ★ the OR hid which arm ships. EULA §2.1 grants use “solely for Licensee’s internal business operations” and §3 forbids providing the software to third parties “including as part of MSP, SaaS, or hosting services”, so the default build (enterprise: true) is resale-prohibited while the AGPL arm is not. A reader of the expression alone could not tell that, and the resale-axis inventory needs to.

★ The fix was to delete the OR, not to modernise the token inside it, and that decision is worth stating, because the obvious repair (LicenseRef-OpenObserve-Enterprise-EULA OR AGPL-3.0-or-later) would have left the concealment exactly where it was. An OR in an SPDX expression means the licensee may elect either. That is true of a genuinely dual-licensed project (Redis 8 below is the real case), and it is false here: these are two different images from two different repositories, and the one this package renders is chosen by a variable, not by the licensee. Whichever image an estate is running, it holds one licence and not a choice of two. So the id names the arm the default build actually takes, as a single token, and the note beside it records the opt-in alternative in full. grep LicenseRef-OpenObserve-Enterprise-EULA now answers “does this estate ship the resale blocker?” without a reader having to know which side of an OR is live.

This is a schema gap, and it is recorded as one rather than papered over. license.id is one claim about one artifact; a package that renders one of several images from a variable has no field in which to say which arm the default build takes. Nothing in the shape (id, source, note, components) expresses it, and no syntax was invented to pretend otherwise: the fact lives in note:, which the field reference defines as “anything an operator needs to know: an obligation, a carve-out, a caveat”, and which is the only place it can currently live. The cost is that the posture is prose: machine-readable to a grep, not to a schema. If a second package ever acquires a variable-selected licence, that is the point at which the field needs a real answer rather than a convention.

★ openobserve’s app.yaml prose in ce was stale, and had already been repaired before this pass reached it. The defect recorded here (a two-tier “10 GB unregistered / 50 GB with a free key” regime, and telemetryEnabled documented as “(default false)” when the real default is true) is not present on ce main: the comment block now states the flat 50 GB allowance and the @boolean line says “default true”. One residual error was found and fixed in this pass: the telemetry condition was cited as EULA §3, which is the restrictions list; the conditional grant is §5.1, pointed at from §2.1. Miscitation of the clause that voids the free grant is the same class of defect as the stale default, just quieter.

traefik is correct as recorded, both the MIT primary (traefik/traefik LICENSE.md at v3.6.25) and the GPL-2.0-only busybox sidecar. Nothing owed, and nothing was changed.

★ One observation traefik raises that is deliberately NOT acted on here. The SHC traefik image’s own base is Alpine 3.24.1, and its apk database lists busybox, busybox-binsh, ssl_client, alpine-baselayout, apk-tools, libapk and scanelf as GPL-2.0-only, structurally the same finding that put a base-userland component on branding. It is not the same case on the fact that decided branding: nothing in the traefik container invokes them (the entrypoint is the Go shc-traefik-boot binary and the command: is a list of -- flags), where nginx’s official entrypoint really does run envsubst. But the redistribution half of the branding argument applies to every built-in equally, and keycloak (Rocky Linux 9.8) and postgres (RHEL9-family) sit in the same position. Whether base userland gets declared on all five or on none is one catalogue-wide ruling, not four package-sized ones, and taking it package by package would recreate exactly the “one fact, three different stories” problem the branding note was written to close. Recorded here so the inconsistency is counted rather than invisible.

branding’s nginx claim is correct: nginx.org/LICENSE is two-clause BSD and did not change under F5, but the declaration listed nginx alone and the Alpine base underneath it carries GPL-2.0-only (busybox, apk-tools, alpine-baselayout) and GPL-3.0-or-later (gettext-envsubst, which the official entrypoint actually invokes for config templating). That matters more here than elsewhere: branding is an EE package SHC redistributes, and GPL-2.0-only carries a source-availability obligation on redistribution, dischargeable by pointing at Alpine’s published sources, but it has to be discharged. Fixed in addons/branding/app.yaml, which is the one built-in resident in this repo.

What has landed, and what is left. Four of the five built-ins live in ce, so their id:/components: edits had to land there; they now have. The postgres components, the openobserve identifier and its OR, the keycloak keycloakify component, and the openobserve §3/§5.1 miscitation are all on ce main. Two items remain open and are described above rather than hidden: the keycloak fat-jar component pass, and the catalogue-wide ruling on whether base userland gets declared on every built-in. None of the landed edits reaches CI until the ce pin next moves: the pin is owned by the release lane and was deliberately not bumped for this, so make lint here still measures the previous pin’s built-ins until it does.

OpenObserve is the one that is not a single licence, and the split is operator-visible rather than academic: vars.enterprise chooses the build. The default is false, the AGPL build, on every estate (Clay’s ruling of 2026-11-01, FZ-8773): AGPL-3.0-or-later, unlimited ingestion, no telemetry condition and no resale restriction. It has no SSO or RBAC of its own, so its UI sits behind SHC’s forward-auth gate, open to platform operators, with one shared OpenObserve login behind it; the ingest and API paths keep OpenObserve’s own auth. Setting enterprise=true opts into the Self-Hosted Enterprise image under OpenObserve’s Enterprise License Agreement, which grants free use below a flat 50 GB/day ingestion ceiling, with no licence key and no registration (§2.1), counted across a legal entity’s affiliates together rather than per install. That grant is conditioned on usage telemetry staying enabled (§5.1), which is the reason vars.telemetryEnabled defaults on and why turning it off on the enterprise build is a licence question, not a privacy preference. And it is the arm that cannot be resold: §2.1 confines use to “Licensee’s internal business operations”, §3 forbids providing the software to third parties “including as part of MSP, SaaS, or hosting services”, and §2.2’s paid grant repeats the internal-use confinement verbatim, so a subscription raises the ingestion ceiling and never that boundary. Until 2026-11-01 the enterprise arm was the default; the AGPL id comes from the openobserve/openobserve source headers.

The four ce-resident packages cite this page in source: even though it lives in this repository. That is deliberate: the built-ins are shipped by the shc deb, this page is where the catalog’s licence facts are kept, and a second copy of them in ce would be a second thing to keep true.

The shape openobserve has is worth naming, because the next package to acquire it will look like an ordinary dual-licence at first glance and is not. A dual-licensed project ships one artifact under two sets of terms and lets the licensee elect (Redis 8 below: RSALv2 OR SSPLv1 OR AGPLv3, and electing AGPLv3 closes the question). Two images, one package ships two different artifacts, from two different repositories, under two unrelated licences, and a package variable, not the licensee, decides which one an estate runs.

The declaration rule that follows: id names the arm the default render takes, as a single token, and the alternative goes in note: with the flag that selects it. Never an OR, which claims an election that does not exist and, worse, hides which arm is live behind a reading of the expression that nobody performs. The test for which pattern applies is one question: can the licensee choose, holding what they already have? If yes, it is an OR. If choosing means deploying different bytes, it is this pattern.

Only openobserve carries this shape today. It is written up as a pattern rather than as one package’s quirk because the same construction (a vars.<flag> that swaps the image for an “enterprise” or “community” build ) is common enough in the catalog that the next one will arrive without announcing itself.

The pattern. An upstream removes a capability from its free line. The capability does not die with the removal: the catalog keeps a sibling app, named <app>-classic, frozen at the last capable version, with the reason stated in the app’s own description. The unsuffixed app tracks current upstream, minus the capability.

DefectDojo carries the pattern:

App pairWhat the free line lostThe classic line
defectdojo / defectdojo-classicSingle sign-on: the current 3.x open-source line has no SSO of its ownThe classic 2.58 line, which still carries OIDC (EOL upstream; the description says so). The current app installs behind the edge gate instead.

The defectdojo packaging records which authentication backends its pinned version supports. See apps/enterprise/defectdojo/vars.yaml.

Both DefectDojo packages declare BSD-3-Clause. This split is about a capability. When the license itself moves, the next pattern applies.

License splits: keeping a differently-licensed line alive

Section titled “License splits: keeping a differently-licensed line alive”

The pattern. An upstream relicenses. Where the older license line still receives upstream maintenance, the catalog can carry both: the current line under the new license, and a -classic sibling on the last release train under the old one, so an operator whose compliance rules exclude the new license is not silently upgraded into it.

Upcoming: midpoint / midpoint-classic. This pair is in review and not yet in the published catalog; it is described here because it is the motivating case. midPoint’s code was dual-licensed Apache-2.0 / EUPL-1.2 through 4.9 and is EUPL-1.2-only from 4.10 (both verified against the LICENSE file at the respective tags). midPoint 4.8 is upstream’s LTS release, dual-licensed, and supported by the vendor until October 2028, which makes a classic app on the 4.8 line a maintained, not merely frozen, alternative for estates that want the Apache-2.0 option. When the pair lands, this section becomes its record; until then, treat it as intent.

Enterprise directories: open repo, closed code

Section titled “Enterprise directories: open repo, closed code”

Several projects the catalog ships are open-core with the boundary drawn inside the repository: the repo is public, most of it is open source, and a top-level enterprise directory sits under a separate proprietary license. Two examples, both stated from the projects’ own LICENSE files:

  • Metabase: “Outside of the top-level ‘enterprise’ directory, source code in a given file is licensed under the AGPL. … Within the top-level ‘enterprise’ directory, source code … is licensed under the Metabase Commercial License.”
  • highlight.io: Apache-2.0, with “all content that resides under the ‘enterprise/’ directory … licensed under the license defined in ‘enterprise/LICENSE’.” (highlight was RETIRED from the catalog on 2026-08-11 (see apps/RETIRED) for want of a maintained upstream, not over its licence. The quotation stands as an illustration of the pattern.)
  • OpenReplay: core AGPLv3, with a separately-licensed ee/ tree whose API refuses to serve without a licence key. This is the live example in the catalog today, and it is also the one that shows where the boundary of the posture below actually runs.

The posture: SHC never fork-enables enterprise-directory code, ever. Repo visibility is not a license grant. Code under a commercial license is proprietary regardless of whether you can read it, and building it in, patching it on, or working around its license checks would violate terms the vendors state plainly and are entitled to. Both projects here draw their boundary clearly and publish genuinely useful software outside it, the catalog respects the boundary in both directions: it pins the community builds (metabase/metabase, not the enterprise image; OpenReplay’s CE images, which ship LICENSE_KEY="" and build as default-foss), and it does not ship, enable, or emulate what sits inside the enterprise tree.

Where the line actually runs: WRITING THE FEATURE YOURSELF IS NOT FORK-ENABLING IT. The posture forbids shipping, unlocking or reimplementing their proprietary code. It does not forbid adding a capability to the open tree using the open tree’s own building blocks, and the distinction is not a technicality: apps/flagship/openreplay ships an SHC soft-fork of chalice that adds an OIDC login router (a different protocol from the SAML2 that ee/ implements), built only from helpers that already live in the AGPL community tree, with no ee/ file read, copied or derived from. Nothing is unlocked; no licence check is bypassed or emulated; the built artifact still reports ENTERPRISE_BUILD=default-foss and the SAML router is simply absent. AGPL grants the modification and redistribution outright, and the public fork repo discharges §13. The tests for that package assert the fork image is actually in use, because pointing chalice back at upstream would render the whole SSO configuration perfectly and then 404 every route.

Where a paid capability matters to an estate, the answer is a license from the vendor, and the packaging aims to make a licensed install work; see the SSO coverage policy for how that plays out for sign-on.

A family of licenses (SSPL, RSALv2, the Elastic License 2.0, BSL/BUSL 1.1, and similar) permits self-hosting but restricts offering the software to third parties as a service. They appear in the catalog mostly through databases and infrastructure sidecars:

  • SSPL v1 (MongoDB and derivatives): its §13 conditions offering “the functionality of the Program … as a service” on releasing the source of the entire service stack around it. No court has construed it; the sound posture is structural avoidance, not a favorable reading.

  • RSALv2 / SSPLv1 (Redis 7.4): neither arm permits offering the software as a service; Redis 8 adds AGPLv3 as a third option. The catalog’s redis packaging documents the per-version license state in its own vars files, and several apps bundle Valkey (BSD-3-Clause) where a compatible swap fits.

  • Elastic License 2.0 (Elasticsearch since 7.11, dual with SSPL): “may not provide the software to third parties as a hosted or managed service”, and it separately forbids circumventing license-key functionality, which SHC treats as a rule with no testing exception.

  • BSL/BUSL 1.1 (Redpanda, among others): the default grant is non-production; production rights come only from the vendor’s Additional Use Grant, which differs per project and per release; Redpanda’s, for example, permits production use except operating it as a streaming or queueing service for others. Each BSL release converts to an open license at its change date. Never generalize BSL: read the grant on the exact version pinned.

  • Fair Core License 1.0, Apache-2.0 future licence (FCL-1.0-ALv2) (Keygen CE), read in LICENSE.md at keygen-api v1.7.2. Any purpose is permitted except a Competing Use: “making the Software available to others in a commercial product or service that: 1. substitutes for the Software; 2. substitutes for any other product or service we offer using the Software that exists as of the date we make the Software available; or 3. offers the same or substantially similar functionality as the Software”. It also forbids circumventing the licence-key functionality, and each release becomes Apache-2.0 on the second anniversary of its release. Self-hosting it for your own use costs nothing. apps/business/keygen now declares the id and states the restriction as license.no_saas, which the store shows.

    Why this thin record deserves more attention than its size suggests: SHC licenses its own paid tiers through self-hosted Keygen: “SHC dogfoods: Keygen runs as an SHC app (apps/business/keygen already in the catalog) on our own estate” (ee-licensing-design.md §“The synthesis”), so SHC is a user of this app, not merely its packager. And SHC’s own product is a licensing service, which is exactly the shape a no-compete clause is written about. The in-repo reading is that licensing a non-licensing product with Keygen is the intended use and the restriction targets reselling Keygen itself. The text read on 2026-11-01 supports that reading for as long as SHC runs Keygen only for itself. A licensing service sold to others would be clause 3, so have a lawyer read it before one ships.

ComponentPinned byLicense familyNote
elasticsearch:7.14.2apps/business/huly (bundled), vars.yaml:148ELv2 / SSPL dualHuly’s fulltext index. The only Elasticsearch pin in the catalog.
redpanda:v24.3.6apps/business/huly (bundled), vars.yaml:147BSL 1.1Huly’s work queue. The only Redpanda pin. Its Additional Use Grant on this exact tag is unverified.
mongodbapps/standalone/mongodb: Percona Server for MongoDBSSPL family (a MongoDB derivative, per the SSPL bullet above)Directly installable, not only a backing service; see the caveat below.
Keygen CEapps/business/keygenFCL-1.0-ALv2, read at v1.7.2Tenant-facing app. Its app.yaml states the restriction as license.no_saas.
Difyapps/ai/difymodified Apache-2.0Tenant-facing app with operator-binding conditions: its own section below.

Both of Huly’s are worth flagging twice over: the vars file pins them with a detailed rationale for the version (7.x wire semantics, the v24.3 Kafka surface) and no license note at all, and both are tag-pinned rather than digest-pinned. A pin comment that explains everything except the license is how a no-SaaS component becomes invisible.

Where the app itself carries one. A package whose own licence restricts hosting it for others declares the restriction as license.no_saas in its app.yaml, and the store shows it on the app page. fizzy (O’Saasy) and dify (the multi-tenant clause) carry one today.

What these disqualify. None of them stop an operator from self-hosting the software for their own estate; that is the SHC install case, and it is why these components can appear in the catalog at all. What they disqualify is turning the component itself into the product: a hosted “managed MongoDB,” a Redpanda-backed queueing service sold to third parties, a hosted Elasticsearch. The catalog’s standing rules follow from that: components under these licenses ship as internal backing services for the apps that need them, not as tenant-facing endpoints, and SHC does not market managed instances of them.

Two places that rule does not reach. It works by demoting the restricted component to a backing service, so it says nothing useful wherever there is nothing to demote:

  • apps/standalone/mongodb is a directly installable app. It carries no hidden: true, it is listed in the app catalog, and shc install mongodb is a supported thing to do. Calling it an internal backing service describes how it is usually consumed, not what it is. The operative rule for it is the narrower one: SHC does not offer it as a managed service, and an operator installing it for their own estate is fine.
  • An app whose OWN license restricts multi-tenant operation cannot be demoted at all, because the restricted thing is the endpoint. That is the next section.

The pattern. A tenant-facing application (the thing users log into, not a sidecar behind it) ships under a license that restricts how it may be operated. The backing-service posture above has no purchase here: you cannot put the app behind the app. There is nothing to demote, so the restriction has to be carried as an operator-facing fact instead of designed around.

Two apps have this shape today, and their records are at opposite extremes:

AppRestriction shapeRecord quality
apps/ai/difymay not operate a multi-tenant environment without written authorizationthe fullest license record in the catalog, in its own app.yaml
apps/business/keygenno Competing Use (FCL 1.0, read at v1.7.2)the id and a license.no_saas line in its own app.yaml, shown on the store

apps/ai/dify is the one to read, and its app.yaml carries the fullest license record of any package in the catalog; read it before relying on this summary. Dify is not open source: it ships under a “modified version of the Apache License 2.0” with additional conditions, and the conditions bind the party that operates a deployment, not the party that redistributes it. SHC shipping the package is fine: the Apache-2.0 base permits redistribution. What follows is what the operator takes on.

  • Multi-tenant operation. Verbatim: “Unless explicitly authorized by Dify in writing, you may not use the Dify source code to operate a multi-tenant environment.” Their tenant unit is a Dify workspace, not an SHC tenant. Self-hosting one deployment for your own organization is the paradigm permitted case. Operating deployments on behalf of other paying parties is the case the clause exists to monetize, and the app.yaml’s advice is to get written authorization rather than rely on a literal reading: Dify sells self-hosted Premium/Enterprise tiers, so it is a normal commercial conversation.
  • The literal defense is fragile. A one-instance-per-customer topology is single-tenant by Dify’s own definition, yet is exactly the arrangement such clauses are written to capture. The question was put to upstream directly (langgenius/dify#4685) and closed with no maintainer answer. And the defense holds only while each deployment has ONE workspace; creating a second is a one-click product feature, so an end user can void the argument without the operator ever knowing.
  • Unilateral relicensing. Contributors must agree that “the producer can adjust the open-source agreement to be more strict or relaxed as deemed necessary”. Unlike a no-CLA project where dispersed copyright makes relicensing structurally hard, today’s terms are not a guarantee about tomorrow’s.
  • Branding. Its own section below.

The posture. Dify installs for an operator’s own organization, which is the case its license plainly permits, and that is why it is in the catalog. The multi-tenant clause is a managed-cloud eligibility item (see the last section), not a reason the app cannot ship. Its app.yaml is the reference rather than this page: it is written for the operator, and it is kept current.

Keygen: the same shape, now on the package

Section titled “Keygen: the same shape, now on the package”

Keygen CE is also tenant-facing and also carries a restriction on operating it as a service for others (the FCL bullet above). Its record used to live in two internal design documents an operator would never read. Since 2026-11-01 apps/business/keygen/app.yaml carries the verified id and a license.no_saas line, so an operator sees the restriction on the store page and in the package they install, the way Dify’s has always been.

Branding restrictions that outlive every tier

Section titled “Branding restrictions that outlive every tier”

Most white-labeling limits are paywalls: an upstream sells logo replacement in a paid tier, and the SHC posture (recorded in the branding socket design §7) is that plugs set the operator’s logo where the app supports operator branding and never strip upstream branding by asset-hacking around a paywall.

Dify is a different shape, and it is the one to watch for. Its license states you “may not remove or modify the LOGO or copyright information in the Dify console or applications”, scoped to the frontend: the web/ directory, i.e. the dify-web image this package ships (apps/ai/dify/app.yaml, the LOGO AND COPYRIGHT condition). The restriction is not conditional on who operates it or on what they have paid. There is no tier, from Dify or from SHC, that unlocks it. Dify can never be white-labeled, by anyone.

The known gap, stated plainly because nothing else warns about it. TIERS.md sells “white-label branding” as a Pro tier feature. A paying Pro customer will therefore find one app in the catalog that refuses a feature they bought, and today they find it by discovering it. This is a documentation-and-product gap, not a bug in the branding socket: the correct behavior for a Dify branding plug is to not exist, and the owed work is a tier-facing exclusion note rather than a code change. Tracked as owed in the branding socket handoff.

Managed-cloud eligibility: a separate axis, and not a flagship one

Section titled “Managed-cloud eligibility: a separate axis, and not a flagship one”

Owner ruling 2026-08-07: docs/decisions/2026-08-07-flagship-payment-axis.md:

“if you are forced to pay to use the app it’s not a flagship.”

Everything on this page about no-SaaS terms answers one question, and it is not the question the flagship tier asks. Keep them apart:

QuestionWho it bindsWhere it is decided
Must a user pay to use the app, get its core functionality, or get its SSO?the operator installing itflagship requirement 4: a paid answer disqualifies
May SHC operate this on behalf of paying third parties?SHC as a providerthis page: managed-cloud eligibility

A component under SSPL, BSL/BUSL, ELv2, RSALv2 or FCL never costs an app the flagship label. The worked case is Huly: EPL-2.0, free to use, bundling an ELv2 Elasticsearch and a BSL Redpanda. Under a license-family test it would be disqualified; under the payment test it is not, because nobody is forced to pay to use Huly.

This axis is a recorded future constraint, not a live one. SHC’s managed cloud is Phase 2 roadmap: docs/internal/product/business-plan.md §14.3, “Phase 2 (Months 6–12): Add Managed Cloud”, with Managed tiers launching progressively from month 7. Nothing in the catalog is sold as a managed service today, so no clause in this family currently binds SHC. The axis is written down now so that the eligibility question is already answered per component when the managed cloud ships, instead of being rediscovered under delivery pressure, and so that no future reader mistakes it for a reason an app cannot be a flagship.

When SHC soft-forks copyleft software, the fork source is public. This is the license’s condition met in the most verifiable way available:

  • The Huly soft fork is a numbered patch series against a pinned upstream release. Huly is EPL-2.0 (verified): file-level copyleft whose §3.1 requires making the source of modified files available when distributing object code. A published patch series is that source, with the changes identified by construction.
  • The Frappe image distributes GPL-3.0 ERPNext unmodified at a digest-pinned base, plus one Apache-2.0 app from a public repo at a pinned commit the image manifest records. Everything in the image traces to published source.
  • The OpenReplay fork (AGPL-3.0) and the Pulp fork (GPL-2.0-or-later) are patch overlays in public repos, so the source of every public image is one clone away.

The rule cuts the other way too: where source cannot be published (an enterprise directory, a no-SaaS component), SHC does not fork it at all. Forking is reserved for code whose license invites it.

On 2026-11-01 the 71 storefront packages still declaring id: unverified were read against upstream, following the rule at the top of this page: the project’s own licence file at the tag the package pins, and for a GNU licence the file header or manifest that elects -only or -or-later. 39 now carry an id and cite this section in source:. The rest stay unverified, and the second table says why for each one that has an upstream at all.

PackageidTag readFiles readNote
agent-canvasMIT1.10.0LICENSEMIT outside enterprise/, which the image does not copy.
clickhouseApache-2.0v26.3.17.110-ltsLICENSE
crowdsecMITv1.7.8LICENSE
dependency-trackApache-2.05.0.4LICENSE.txt
ethereumGPL-3.0-or-later AND LGPL-3.0-or-laterv1.17.5COPYING, main.goGeth: GPL-3.0-or-later for the cmd/ programs, LGPL-3.0-or-later for the library. The Lighthouse consensus client is a separate project.
fleetMIT AND LicenseRef-Fleet-Enterprisefleet-v4.90.0LICENSEMIT outside ee/; ee/ is the Fleet Enterprise licence and the published image links it.
fusionpbxMPL-1.15.6.5index.phpNo root licence file at 5.6.5; index.php carries the MPL 1.1 notice. SHC’s image builds from the 5.6.5 tag.
giteaMITv1.27.1LICENSE
gitlabMITv18.11.11LICENSE
gitlab-runnerMITv19.2.1LICENSE
graphitiApache-2.0v0.22.0LICENSE
hockeypuckAGPL-3.0-only2.3.3LICENSE, settings.go
hyperswitchApache-2.0v1.122.0LICENSE
journivLicenseRef-Journiv-PolyForm-Noncommercial-with-Supplemental-Terms AND LicenseRef-Journiv-Web-Clientv0.1.0-beta.23LICENSE.mdPolyForm Noncommercial 1.0.0 with supplemental terms: commercial use of any kind needs a separate written licence. The prebuilt web client is proprietary.
keygenLicenseRef-FCL-1.0-ALv2v1.7.2LICENSE.mdFair Core License 1.0: no Competing Use; each release converts to Apache-2.0 two years after it ships.
kuboMITv0.43.0LICENSEContributions before 2019-05-06 are MIT-only and later ones MIT OR Apache-2.0, so the whole is available under MIT.
kuttMITv3.2.6LICENSE
librechatMITv0.8.7LICENSE
mailMITv1.30.6LICENSE
mariadbGPL-2.0-onlymariadb-12.3.2COPYING, mysqld.cc
matomoGPL-3.0-or-later5.12.0LICENSE, index.php
matrixAGPL-3.0-or-laterv1.158.0LICENSE-AGPL-3.0, pyproject.tomlSynapse’s pyproject.toml offers AGPL-3.0-or-later OR a separate Element commercial agreement; the id records the public arm.
mauticGPL-3.0-or-later7.2.1LICENSE.txtLICENSE.txt’s own preamble grants version 3 or any later version; composer.json says the bare GPL-3.0.
medusaMITv2.18.0LICENSE
mongodbSSPL-1.0psmdb-8.0.26-11LICENSE-Community.txtPercona Server for MongoDB: SSPL version 1.
mysqlGPL-2.0-onlyPercona-Server-8.4.10-10LICENSE, mysqld.ccPercona Server for MySQL: GPL version 2 with Oracle’s additional linking permissions.
nextcloudAGPL-3.0-onlyv34.0.5COPYING, index.phpindex.php carries SPDX AGPL-3.0-only; package.json says AGPL-3.0-or-later. The server includes -only files, so version 3 binds.
nginxBSD-2-Clauserelease-1.30.4LICENSE
ollamaMITv0.32.6LICENSE
penpotMPL-2.02.17.0LICENSE
planeAGPL-3.0-onlyv1.4.1LICENSE.txt, manage.py
pmmAGPL-3.0-or-laterv3.7.0LICENSE, main.goThe PMM server is AGPL-3.0-or-later; its client is Apache-2.0.
s3Apache-2.02.36.19LICENSE.txt
sonarqubeLGPL-3.0-or-later26.7.0.124771LICENSE.txt, WebServer.java
supabaseApache-2.0a6a04f2LICENSERead at a6a04f2, the source commit the pinned Studio image records; Postgres, Kong and the other services carry their own licences.
vaultwardenAGPL-3.0-only1.37.1LICENSE.txt, Cargo.toml
wazuhGPL-2.0-onlyv4.14.7LICENSE, analysisd.c
whoamiApache-2.0v1.12.0LICENSE
wordpressGPL-2.0-or-later7.1.3license.txt, kses.php

Thirteen have an upstream licence whose family and version are known but whose -only or -or-later election upstream never states, or whose pinned release can’t be read. A guessed suffix would be the rounding this page forbids, so they keep unverified until upstream says or someone asks.

PackageTag readFileWhat was found
blockscoutv9.0.2LICENSEGPLv3 text; mix.exs says “GPL 3.0”; no election stated.
docuseal3.1.7LICENSEAGPLv3 plus a section 7(b) attribution term (LICENSE_ADDITIONAL_TERMS); no election stated.
greenbonev23.52.8COPYINGThe images pin the mutable stable tag, so no release can be read; openvas-scanner v23.52.8 is GPL-2.0-only.
immichv3.0.3LICENSEAGPLv3 text; manifests say “GNU Affero General Public License version 3” and no source header elects only or later.
ivatar1.7.0LICENSEAGPLv3 text at 1.7.0, the newest upstream tag; the pinned image tracks a commit with no matching tag, and no header elects only or later.
jellyfinv10.11.11LICENSEGPLv2 text; no header or manifest elects only or later.
mailcow2026-07aLICENSEGPLv3 text and a README naming version 3; no header elects only or later.
monicav4.1.2LICENSE.mdAGPLv3 text; composer.json says “AGPL”; no election stated.
netbirdv0.76.2LICENSEBSD-3-Clause except management/, signal/ and relay/, which are AGPLv3 with no election stated.
paperlessv3.0.5LICENSEGPLv3 text; no header or manifest elects only or later.
peertubev8.2.4LICENSEAGPLv3 text; package.json says the bare AGPL-3.0, and no header elects only or later.
postizv2.23.0LICENSEAGPLv3 text; the root package.json says the bare AGPL-3.0 and apps/frontend says ISC; no election stated.
windmillv1.784.0LICENSEAGPLv3 backend, Apache-2.0 clients, and proprietary Community Edition code in the published image; no election stated.

The other nineteen have no upstream release to read. affine is the upstream AFFiNE package, whose server licence lives in the EE tree the house never fetches (the affine-rs provenance rule). The ten external-* packages are headless fronts that install no vendor software. The eight packages SHC wrote itself (gitlab-fizzy, gitlab-huly, huly-matrix-notifier, identity-broker, mailbox-reconciler, mailbox-reconciler-ffx, monica-nextcloud and s3-migrate) wait on SHC’s own licence file, which is still a placeholder.

Two findings from the pass are worth knowing. journiv is PolyForm Noncommercial: free for noncommercial use, and commercial use needs a licence from its author. It stays a normal catalogue app (Clay, 2026-11-01), its license.noncommercial says so on the store page, and it stays out of business presets. windmill’s published image carries proprietary Community Edition code beside the AGPL backend, which its requires_paid_license_reason already describes.