feat(pricing): collapse to two tiers (#1309)

* feat(pricing): collapse to two tiers (Community + Admiral)

Collapse Sencho's pricing from three tiers (Community / Skipper / Admiral)
to two: a generous free Community tier and a single paid Admiral tier. The
Skipper tier is removed.

Now free in Community: auto-heal, auto-update, scheduled operations,
webhooks, notification routing, Fleet Actions and bulk operations, SSO
preset providers (Google / GitHub / Okta), unlimited users with admin and
viewer roles, and deploy safety (atomic deploys, auto-rollback, and
one-click rollback).

Admiral (paid) is focused on running and governing a fleet: blueprints,
Fleet Secrets, deploy enforcement, vulnerability report export, audit log,
host console, private registries, mesh networking, node cordon, managed
cloud backup, LDAP / Active Directory SSO, and the advanced RBAC roles
(deployer, node-admin, auditor) with per-resource scoped assignments.

Internally the license variant distinction is removed so tier is binary
(community / paid). License validation still verifies the Lemon Squeezy
store and product before granting paid status.

Docs and the contributor guide are updated to the two-tier model.

* docs(pricing): correct licensing page to two-tier pricing and tidy stale tier wording

The licensing docs page kept the old Admiral pricing plus a Founder
Lifetime column and an Enterprise paragraph after the two-tier collapse.
Update it to $12/month or $99/year, drop the lifetime and Enterprise
content, and link to the pricing page for current pricing.

Also fix stale "Skipper" wording in CLA.md, SUPPORT.md, one test title,
and three test comments. Historical CHANGELOG entries and the
retired-Skipper license-guard test are intentionally left as-is.

* docs: align licensing and SSO pages with the two-tier model

Correct the SSO overview so the Google, GitHub, and Okta presets read as
available on every tier, matching the provider table; only LDAP and Active
Directory require Sencho Admiral. Remove the lifetime-plan references from the
licensing, settings, and troubleshooting pages so they reflect subscription-only
Admiral pricing.

* fix(rbac): omit scoped permissions from /me on the Community tier

Scoped role assignments only take effect on the paid tier, but GET /api/permissions/me returned them unconditionally, so a downgraded instance with leftover assignments rendered per-resource affordances the API then rejected with 403. The endpoint now mirrors the permission middleware and includes scoped permissions only on the paid tier. Adds a regression test covering the downgrade case.

* docs: use custom-pricing wording on the contact page

The two-tier model has no Enterprise tier; reword the contact page's enterprise pricing/deals to custom pricing/deals so it does not imply a tier that no longer exists.

backend/src/websocket/hostConsole.ts

@@ -4,12 +4,10 @@ import WebSocket, { WebSocketServer } from 'ws';
 import { FileSystemService } from '../services/FileSystemService';
 import { NodeRegistry } from '../services/NodeRegistry';
 import { HostTerminalService } from '../services/HostTerminalService';
-import { PROXY_TIER_HEADER, PROXY_VARIANT_HEADER } from '../services/license-headers';
+import { PROXY_TIER_HEADER } from '../services/license-headers';
 import {
   isLicenseTier,
-  isLicenseVariant,
   normalizeTier,
-  normalizeVariant,
 } from '../services/license-normalize';
 import { LicenseService } from '../services/LicenseService';
 import { ROLE_PERMISSIONS, type PermissionAction } from '../middleware/permissions';
@@ -34,8 +32,8 @@ interface HostConsoleContext {
  *  2. RBAC: user session tokens require the `system:console` permission.
  *     console_session tokens are pre-gated at issuance (see
  *     `routes/console.ts`) and skip this check.
- *  3. License: host console requires paid + admiral. For console_session
- *     tokens the tier/variant is trusted from the gateway-supplied headers;
+ *  3. License: host console requires the paid tier. For console_session
+ *     tokens the tier is trusted from the gateway-supplied header;
  *     otherwise the local LicenseService is consulted.
  */
 export function handleHostConsoleWs(
@@ -62,15 +60,11 @@ export function handleHostConsoleWs(
   }
 
   const consoleTierHeader = req.headers[PROXY_TIER_HEADER] as string | undefined;
-  const consoleVariantHeader = req.headers[PROXY_VARIANT_HEADER] as string | undefined;
   const ls = LicenseService.getInstance();
   const consoleTier = (isConsoleSession && isLicenseTier(consoleTierHeader))
     ? normalizeTier(consoleTierHeader)
     : ls.getTier();
-  const consoleVariant = (isConsoleSession && consoleVariantHeader !== undefined && isLicenseVariant(consoleVariantHeader))
-    ? normalizeVariant(consoleVariantHeader)
-    : ls.getVariant();
-  if (consoleTier !== 'paid' || consoleVariant !== 'admiral') {
+  if (consoleTier !== 'paid') {
     return reject(socket, 403, 'Forbidden');
   }
 

backend/src/websocket/remoteForwarder.ts

@@ -1,6 +1,6 @@
 import type { IncomingMessage } from 'http';
 import type { Duplex } from 'stream';
-import { PROXY_TIER_HEADER, PROXY_VARIANT_HEADER } from '../services/license-headers';
+import { PROXY_TIER_HEADER } from '../services/license-headers';
 import { LicenseService } from '../services/LicenseService';
 import { wsProxyServer } from '../proxy/websocketProxy';
 import { getErrorMessage } from '../utils/errors';
@@ -48,7 +48,6 @@ export async function handleRemoteForwarder(
         headers: {
           'Authorization': `Bearer ${target.apiToken}`,
           [PROXY_TIER_HEADER]: consoleHeaders.tier,
-          [PROXY_VARIANT_HEADER]: consoleHeaders.variant || '',
         },
       });
       if (!tokenRes.ok) {
@@ -78,7 +77,6 @@ export async function handleRemoteForwarder(
   delete req.headers['cookie'];
   const fwdHeaders = LicenseService.getInstance().getProxyHeaders();
   req.headers[PROXY_TIER_HEADER] = fwdHeaders.tier;
-  req.headers[PROXY_VARIANT_HEADER] = fwdHeaders.variant || '';
   // Strip nodeId from the forwarded URL so the remote treats the request as
   // local. The remote has no record of the gateway's nodeId; leaving it would
   // trigger nodeContext's 404 branch.

backend/src/websocket/upgradeHandler.ts

@@ -17,8 +17,8 @@ import { rejectUpgrade as reject } from './reject';
 import { looksLikeApiToken } from '../utils/apiTokenFormat';
 import { validateApiToken, touchApiTokenLastUsed } from '../utils/apiTokenAuth';
 import { isDebugEnabled } from '../utils/debug';
-import { PROXY_TIER_HEADER, PROXY_VARIANT_HEADER } from '../services/license-headers';
-import { isLicenseTier, normalizeTier, isLicenseVariant, normalizeVariant } from '../services/license-normalize';
+import { PROXY_TIER_HEADER } from '../services/license-headers';
+import { isLicenseTier, normalizeTier } from '../services/license-normalize';
 
 function parseCookies(req: IncomingMessage): Record<string, string> {
   const header = req.headers.cookie || '';
@@ -143,28 +143,24 @@ export function attachUpgrade(
       // Restricted api_token scopes (read-only, deploy-only) are blocked
       // earlier by the scope gate above before this branch is reached.
       //
-      // Admiral entitlement is decided against the *central's* license, not
+      // Mesh entitlement is decided against the *central's* license, not
       // the receiver's, matching every HTTP mesh route in routes/mesh.ts that
-      // uses `requireAdmiral` / `effectiveTier`. On the node_proxy path the
-      // central forwards `x-sencho-tier` / `x-sencho-variant` and the WS
-      // dispatcher trusts them off the node_proxy credential (same rule as
-      // middleware/auth.ts:117-135 for HTTP). On the full-admin api_token
-      // path no central is asserting tier, so we fall back to the receiver's
-      // own license. Both produce paid+admiral or the upgrade is rejected.
+      // uses `requirePaid` / `effectiveTier`. On the node_proxy path the
+      // central forwards `x-sencho-tier` and the WS dispatcher trusts it off
+      // the node_proxy credential (same rule as middleware/auth.ts for HTTP).
+      // On the full-admin api_token path no central is asserting tier, so we
+      // fall back to the receiver's own license. Both produce paid or the
+      // upgrade is rejected.
       if (pathname === '/api/mesh/proxy-tunnel') {
         if (!isProxyToken && wsApiTokenScope !== 'full-admin') {
           return reject(socket, 403, 'Forbidden');
         }
         const license = LicenseService.getInstance();
         const tunnelTierHeader = req.headers[PROXY_TIER_HEADER] as string | undefined;
-        const tunnelVariantHeader = req.headers[PROXY_VARIANT_HEADER] as string | undefined;
         const tunnelTier = isProxyToken && isLicenseTier(tunnelTierHeader)
           ? normalizeTier(tunnelTierHeader)
           : license.getTier();
-        const tunnelVariant = isProxyToken && tunnelVariantHeader !== undefined && isLicenseVariant(tunnelVariantHeader)
-          ? normalizeVariant(tunnelVariantHeader)
-          : license.getVariant();
-        if (tunnelTier !== 'paid' || tunnelVariant !== 'admiral') {
+        if (tunnelTier !== 'paid') {
           return reject(socket, 403, 'Forbidden');
         }
         await handleMeshProxyTunnel(req, socket, head);