@helyx/cli 0.4.41 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.5.1
+
+### Patch Changes
+
+- Update the embedded self-host catalogue for the launch-readiness runtime and module patch releases.
+
+## 0.5.0
+
+### Minor Changes
+
+- 26b4c3e: Add versioned hidden module dependencies, automatic installation lifecycle,
+  delegated customer health, and transitive self-host build composition for the
+  Nexus foundation while preserving legacy manifest and catalogue behavior. Add
+  closed, owner-aware composition for the shared `/nexus` command namespace and
+  bounded Core reads for terminology, member history and confirmed member value
+  changes. Add resumable, idempotent role and server bulk-award jobs.
+  Add bounded Nexus privacy capture, a durable hashed erasure fence and atomic
+  member detachment that journals any remaining balance as a privacy burn before
+  removing account and bulk-recipient identifiers.
+  Generalise the durable Achievement contribution bus as member contributions
+  while retaining the existing service names as compatibility aliases.
+  Add the private Nexus Rewards Testing package, complete initial record schema
+  and an atomic timezone-aware Daily Claim path backed by the shared ledger.
+  Add reviewed, default-off Nexus eligibility metadata to existing contribution
+  catalogues and atomically apply configured fixed rewards with source, role,
+  rate-cap, replay, balance-cap and privacy safeguards.
+  Add definition-owned Achievement reward amounts and live repeatable-award
+  high-water processing so retries credit only newly committed occurrences.
+  Add the private Nexus Economy Testing package and its complete initial Exchange,
+  item, redemption, inventory, role-grant and durable fulfilment record schema.
+  Add a typed atomic Economy redemption path with exact replay, finite stock,
+  member limits, role eligibility, collectible inventory and durable fulfilment.
+  Add coalesced leased role fulfilment with reviewed Discord safety, observed
+  delivery reconciliation, bounded retries and Core-linked automatic refunds.
+
+## 0.4.42
+
+### Patch Changes
+
+- Add fail-open production status heartbeat configuration and reporting support.
+
 ## 0.4.41
 
 ### Patch Changes

package/dist/self-host/catalogue.d.ts

@@ -39,7 +39,88 @@ export declare const selfHostModuleSchema: z.ZodObject<{
         premium: "premium";
     }>>;
 }, z.core.$strict>;
-export declare const selfHostCatalogueSchema: z.ZodObject<{
+export declare const selfHostModuleV2Schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    package: z.ZodString;
+    version: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodEnum<{
+        Community: "Community";
+        Safety: "Safety";
+        "Support & Staff": "Support & Staff";
+        "Auto Tools": "Auto Tools";
+        Automation: "Automation";
+        Engagement: "Engagement";
+        Gaming: "Gaming";
+        Insights: "Insights";
+        Integrations: "Integrations";
+    }>;
+    availability: z.ZodEnum<{
+        planned: "planned";
+        unpublished: "unpublished";
+        published: "published";
+    }>;
+    releaseStatus: z.ZodEnum<{
+        planned: "planned";
+        testing: "testing";
+        beta: "beta";
+        live: "live";
+    }>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        free: "free";
+        premium: "premium";
+    }>>;
+    dependencies: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    moduleKind: z.ZodLiteral<"customer_feature">;
+    customerSelectable: z.ZodLiteral<true>;
+    countsAsInstalledModule: z.ZodLiteral<true>;
+    healthExposure: z.ZodLiteral<"direct">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    package: z.ZodString;
+    version: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodEnum<{
+        Community: "Community";
+        Safety: "Safety";
+        "Support & Staff": "Support & Staff";
+        "Auto Tools": "Auto Tools";
+        Automation: "Automation";
+        Engagement: "Engagement";
+        Gaming: "Gaming";
+        Insights: "Insights";
+        Integrations: "Integrations";
+    }>;
+    availability: z.ZodEnum<{
+        planned: "planned";
+        unpublished: "unpublished";
+        published: "published";
+    }>;
+    releaseStatus: z.ZodEnum<{
+        planned: "planned";
+        testing: "testing";
+        beta: "beta";
+        live: "live";
+    }>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        free: "free";
+        premium: "premium";
+    }>>;
+    dependencies: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    moduleKind: z.ZodLiteral<"internal_dependency">;
+    customerSelectable: z.ZodLiteral<false>;
+    countsAsInstalledModule: z.ZodLiteral<false>;
+    healthExposure: z.ZodLiteral<"delegated">;
+}, z.core.$strict>], "moduleKind">;
+export declare const selfHostCatalogueSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     catalogueVersion: z.ZodNumber;
     core: z.ZodObject<{
@@ -92,9 +173,112 @@ export declare const selfHostCatalogueSchema: z.ZodObject<{
             premium: "premium";
         }>>;
     }, z.core.$strict>>;
-}, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    catalogueVersion: z.ZodNumber;
+    core: z.ZodObject<{
+        package: z.ZodString;
+        version: z.ZodString;
+        availability: z.ZodEnum<{
+            unpublished: "unpublished";
+            published: "published";
+        }>;
+    }, z.core.$strict>;
+    generator: z.ZodObject<{
+        package: z.ZodString;
+        version: z.ZodString;
+        availability: z.ZodEnum<{
+            unpublished: "unpublished";
+            published: "published";
+        }>;
+        command: z.ZodString;
+    }, z.core.$strict>;
+    modules: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        package: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        description: z.ZodString;
+        category: z.ZodEnum<{
+            Community: "Community";
+            Safety: "Safety";
+            "Support & Staff": "Support & Staff";
+            "Auto Tools": "Auto Tools";
+            Automation: "Automation";
+            Engagement: "Engagement";
+            Gaming: "Gaming";
+            Insights: "Insights";
+            Integrations: "Integrations";
+        }>;
+        availability: z.ZodEnum<{
+            planned: "planned";
+            unpublished: "unpublished";
+            published: "published";
+        }>;
+        releaseStatus: z.ZodEnum<{
+            planned: "planned";
+            testing: "testing";
+            beta: "beta";
+            live: "live";
+        }>;
+        tier: z.ZodOptional<z.ZodEnum<{
+            free: "free";
+            premium: "premium";
+        }>>;
+        dependencies: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        moduleKind: z.ZodLiteral<"customer_feature">;
+        customerSelectable: z.ZodLiteral<true>;
+        countsAsInstalledModule: z.ZodLiteral<true>;
+        healthExposure: z.ZodLiteral<"direct">;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        package: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        description: z.ZodString;
+        category: z.ZodEnum<{
+            Community: "Community";
+            Safety: "Safety";
+            "Support & Staff": "Support & Staff";
+            "Auto Tools": "Auto Tools";
+            Automation: "Automation";
+            Engagement: "Engagement";
+            Gaming: "Gaming";
+            Insights: "Insights";
+            Integrations: "Integrations";
+        }>;
+        availability: z.ZodEnum<{
+            planned: "planned";
+            unpublished: "unpublished";
+            published: "published";
+        }>;
+        releaseStatus: z.ZodEnum<{
+            planned: "planned";
+            testing: "testing";
+            beta: "beta";
+            live: "live";
+        }>;
+        tier: z.ZodOptional<z.ZodEnum<{
+            free: "free";
+            premium: "premium";
+        }>>;
+        dependencies: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        moduleKind: z.ZodLiteral<"internal_dependency">;
+        customerSelectable: z.ZodLiteral<false>;
+        countsAsInstalledModule: z.ZodLiteral<false>;
+        healthExposure: z.ZodLiteral<"delegated">;
+    }, z.core.$strict>], "moduleKind">>;
+}, z.core.$strict>], "schemaVersion">;
 export type SelfHostModule = z.infer<typeof selfHostModuleSchema>;
+export type SelfHostModuleV2 = z.infer<typeof selfHostModuleV2Schema>;
 export type SelfHostCatalogue = z.infer<typeof selfHostCatalogueSchema>;
+export declare function isSelfHostModuleCustomerSelectable(module: SelfHostModule | SelfHostModuleV2): boolean;
 export declare function parseSelfHostCatalogue(input: unknown): SelfHostCatalogue;
 export declare function loadSelfHostCatalogue(path: string | URL, reader?: (path: string | URL, encoding: "utf8") => Promise<string>): Promise<SelfHostCatalogue>;
 export declare function bundledSelfHostCatalogueUrl(): URL;

package/dist/self-host/catalogue.js

@@ -24,6 +24,14 @@ const modulePackage = z
 const moduleId = z
     .string()
     .regex(/^helyx\.[a-z0-9][a-z0-9-]*$/u, "must be a Helyx module ID");
+const moduleDependency = z
+    .object({
+    id: moduleId,
+    version: z
+        .string()
+        .refine((value) => semver.validRange(value) !== null, "must be semver"),
+})
+    .strict();
 const availability = z.enum(["planned", "unpublished", "published"]);
 export const selfHostReleaseStatusSchema = z.enum([
     "planned",
@@ -92,7 +100,25 @@ export const selfHostModuleSchema = z
         });
     }
 });
-export const selfHostCatalogueSchema = z
+const selfHostCustomerModuleV2Schema = selfHostModuleSchema.safeExtend({
+    dependencies: z.array(moduleDependency),
+    moduleKind: z.literal("customer_feature"),
+    customerSelectable: z.literal(true),
+    countsAsInstalledModule: z.literal(true),
+    healthExposure: z.literal("direct"),
+});
+const selfHostInternalModuleV2Schema = selfHostModuleSchema.safeExtend({
+    dependencies: z.array(moduleDependency),
+    moduleKind: z.literal("internal_dependency"),
+    customerSelectable: z.literal(false),
+    countsAsInstalledModule: z.literal(false),
+    healthExposure: z.literal("delegated"),
+});
+export const selfHostModuleV2Schema = z.discriminatedUnion("moduleKind", [
+    selfHostCustomerModuleV2Schema,
+    selfHostInternalModuleV2Schema,
+]);
+const selfHostCatalogueV1Schema = z
     .object({
     schemaVersion: z.literal(1),
     catalogueVersion: z.number().int().positive(),
@@ -100,7 +126,21 @@ export const selfHostCatalogueSchema = z
     generator: generatorSchema,
     modules: z.array(selfHostModuleSchema),
 })
-    .strict()
+    .strict();
+const selfHostCatalogueV2Schema = z
+    .object({
+    schemaVersion: z.literal(2),
+    catalogueVersion: z.number().int().positive(),
+    core: componentSchema,
+    generator: generatorSchema,
+    modules: z.array(selfHostModuleV2Schema),
+})
+    .strict();
+export const selfHostCatalogueSchema = z
+    .discriminatedUnion("schemaVersion", [
+    selfHostCatalogueV1Schema,
+    selfHostCatalogueV2Schema,
+])
     .superRefine((catalogue, context) => {
     const ids = new Set();
     const packages = new Set([
@@ -125,7 +165,32 @@ export const selfHostCatalogueSchema = z
         ids.add(module.id);
         packages.add(module.package);
     }
+    if (catalogue.schemaVersion === 2) {
+        for (const [index, module] of catalogue.modules.entries()) {
+            const dependencyIds = new Set();
+            for (const dependency of module.dependencies) {
+                if (dependencyIds.has(dependency.id)) {
+                    context.addIssue({
+                        code: "custom",
+                        path: ["modules", index, "dependencies"],
+                        message: `duplicate dependency: ${dependency.id}`,
+                    });
+                }
+                if (dependency.id === module.id) {
+                    context.addIssue({
+                        code: "custom",
+                        path: ["modules", index, "dependencies"],
+                        message: "a module cannot depend on itself",
+                    });
+                }
+                dependencyIds.add(dependency.id);
+            }
+        }
+    }
 });
+export function isSelfHostModuleCustomerSelectable(module) {
+    return !("customerSelectable" in module) || module.customerSelectable;
+}
 export function parseSelfHostCatalogue(input) {
     return selfHostCatalogueSchema.parse(input);
 }

package/dist/self-host/manifest.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import type { SelfHostCatalogue } from "./catalogue.js";
-export declare const selfHostBuildManifestSchema: z.ZodObject<{
+import { type SelfHostCatalogue } from "./catalogue.js";
+export declare const selfHostBuildManifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     catalogueVersion: z.ZodNumber;
     core: z.ZodObject<{
@@ -16,7 +16,31 @@ export declare const selfHostBuildManifestSchema: z.ZodObject<{
         package: z.ZodString;
         version: z.ZodString;
     }, z.core.$strict>>;
-}, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    catalogueVersion: z.ZodNumber;
+    core: z.ZodObject<{
+        package: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    generator: z.ZodObject<{
+        package: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    modules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        package: z.ZodString;
+        version: z.ZodString;
+        moduleKind: z.ZodEnum<{
+            customer_feature: "customer_feature";
+            internal_dependency: "internal_dependency";
+        }>;
+        dependencies: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "schemaVersion">;
 export type SelfHostBuildManifest = z.infer<typeof selfHostBuildManifestSchema>;
 export declare function createSelfHostBuildManifest(catalogue: SelfHostCatalogue, selectedModuleIds: readonly string[]): SelfHostBuildManifest;
 export declare function parseSelfHostBuildManifest(input: unknown, catalogue: SelfHostCatalogue): SelfHostBuildManifest;

package/dist/self-host/manifest.js

@@ -1,5 +1,7 @@
 import semver from "semver";
+import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
+import { isSelfHostModuleCustomerSelectable, } from "./catalogue.js";
 const exactVersion = z
     .string()
     .refine((value) => semver.valid(value) === value, "must be exact semver");
@@ -18,7 +20,7 @@ const buildModuleSchema = z
     version: exactVersion,
 })
     .strict();
-export const selfHostBuildManifestSchema = z
+const selfHostBuildManifestV1Schema = z
     .object({
     schemaVersion: z.literal(1),
     catalogueVersion: z.number().int().positive(),
@@ -26,7 +28,34 @@ export const selfHostBuildManifestSchema = z
     generator: buildComponentSchema,
     modules: z.array(buildModuleSchema),
 })
-    .strict()
+    .strict();
+const buildModuleV2Schema = buildModuleSchema
+    .extend({
+    moduleKind: z.enum(["customer_feature", "internal_dependency"]),
+    dependencies: z.array(z
+        .object({
+        id: moduleId,
+        version: z
+            .string()
+            .refine((value) => semver.validRange(value) !== null, "must be semver"),
+    })
+        .strict()),
+})
+    .strict();
+const selfHostBuildManifestV2Schema = z
+    .object({
+    schemaVersion: z.literal(2),
+    catalogueVersion: z.number().int().positive(),
+    core: buildComponentSchema,
+    generator: buildComponentSchema,
+    modules: z.array(buildModuleV2Schema),
+})
+    .strict();
+export const selfHostBuildManifestSchema = z
+    .discriminatedUnion("schemaVersion", [
+    selfHostBuildManifestV1Schema,
+    selfHostBuildManifestV2Schema,
+])
     .superRefine((manifest, context) => {
     const ids = new Set();
     const packages = new Set();
@@ -55,6 +84,9 @@ export function createSelfHostBuildManifest(catalogue, selectedModuleIds) {
     if (new Set(selectedModuleIds).size !== selectedModuleIds.length) {
         throw new Error("Self-host selection contains duplicate module IDs");
     }
+    if (catalogue.schemaVersion === 2) {
+        return createSelfHostBuildManifestV2(catalogue, selectedModuleIds);
+    }
     const byId = new Map(catalogue.modules.map((module) => [module.id, module]));
     const modules = [...selectedModuleIds]
         .sort((left, right) => left.localeCompare(right, "en"))
@@ -87,8 +119,76 @@ export function createSelfHostBuildManifest(catalogue, selectedModuleIds) {
         modules,
     };
 }
+function createSelfHostBuildManifestV2(catalogue, selectedModuleIds) {
+    const byId = new Map(catalogue.modules.map((module) => [module.id, module]));
+    const explicitlySelected = new Set(selectedModuleIds);
+    const modules = [];
+    const visiting = new Set();
+    const included = new Set();
+    for (const id of selectedModuleIds) {
+        const module = byId.get(id);
+        if (!module)
+            throw new Error(`Unknown self-host module: ${id}`);
+        if (!isSelfHostModuleCustomerSelectable(module))
+            throw new Error(`Self-host module cannot be selected directly: ${id}`);
+    }
+    const include = (id) => {
+        if (included.has(id))
+            return;
+        if (visiting.has(id))
+            throw new Error(`Self-host module dependency cycle detected at ${id}`);
+        const module = byId.get(id);
+        if (!module)
+            throw new Error(`Unknown self-host module: ${id}`);
+        assertLiveModule(module, id);
+        visiting.add(id);
+        for (const dependency of module.dependencies) {
+            const required = byId.get(dependency.id);
+            if (!required)
+                throw new Error(`Self-host module ${id} is missing dependency ${dependency.id}`);
+            if (required.version === null ||
+                !semver.satisfies(required.version, dependency.version)) {
+                throw new Error(`Self-host module ${id} requires ${dependency.id} ${dependency.version}`);
+            }
+            if (isSelfHostModuleCustomerSelectable(required) &&
+                !explicitlySelected.has(required.id)) {
+                throw new Error(`Select required module first: ${required.name}`);
+            }
+            include(required.id);
+        }
+        visiting.delete(id);
+        included.add(id);
+        modules.push({
+            id: module.id,
+            package: module.package,
+            version: module.version,
+            moduleKind: module.moduleKind,
+            dependencies: module.dependencies.map((dependency) => ({
+                ...dependency,
+            })),
+        });
+    };
+    for (const id of [...selectedModuleIds].sort((left, right) => left.localeCompare(right, "en")))
+        include(id);
+    return {
+        schemaVersion: 2,
+        catalogueVersion: catalogue.catalogueVersion,
+        core: {
+            package: catalogue.core.package,
+            version: catalogue.core.version,
+        },
+        generator: {
+            package: catalogue.generator.package,
+            version: catalogue.generator.version,
+        },
+        modules,
+    };
+}
 export function parseSelfHostBuildManifest(input, catalogue) {
     const manifest = selfHostBuildManifestSchema.parse(input);
+    if (manifest.schemaVersion !== catalogue.schemaVersion) {
+        throw new Error(`Build manifest schema does not match catalogue schema ${String(catalogue.schemaVersion)}`);
+    }
     if (manifest.catalogueVersion !== catalogue.catalogueVersion) {
         throw new Error(`Unsupported self-host catalogue version: ${manifest.catalogueVersion}`);
     }
@@ -96,6 +196,19 @@ export function parseSelfHostBuildManifest(input, catalogue) {
     assertPublishedComponent(catalogue.generator, "Helyx generator");
     assertComponentMatches(manifest.core, catalogue.core, "runtime");
     assertComponentMatches(manifest.generator, catalogue.generator, "generator");
+    if (manifest.schemaVersion === 2 && catalogue.schemaVersion === 2) {
+        const selectedModuleIds = manifest.modules
+            .filter(({ moduleKind }) => moduleKind === "customer_feature")
+            .map(({ id }) => id);
+        const expected = createSelfHostBuildManifest(catalogue, selectedModuleIds);
+        if (!isDeepStrictEqual(manifest, expected)) {
+            throw new Error("Build manifest modules do not match the trusted catalogue dependency graph");
+        }
+        return expected;
+    }
+    if (manifest.schemaVersion !== 1 || catalogue.schemaVersion !== 1) {
+        throw new Error("Build manifest and catalogue schemas are incompatible");
+    }
     const byId = new Map(catalogue.modules.map((module) => [module.id, module]));
     for (const selected of manifest.modules) {
         const module = byId.get(selected.id);
@@ -116,6 +229,13 @@ export function parseSelfHostBuildManifest(input, catalogue) {
         modules: [...manifest.modules].sort((left, right) => left.id.localeCompare(right.id, "en")),
     };
 }
+function assertLiveModule(module, id) {
+    if (module.availability !== "published" ||
+        module.releaseStatus !== "live" ||
+        module.version === null) {
+        throw new Error(`Self-host module is not live: ${id}`);
+    }
+}
 function assertPublishedComponent(component, label) {
     if (component.availability !== "published") {
         throw new Error(`${label} is not published`);

package/dist/self-host/project-generator.d.ts

@@ -1,5 +1,5 @@
 import type { BotEnvironmentInput } from "@helyx/config";
-import type { SelfHostCatalogue } from "./catalogue.js";
+import { type SelfHostCatalogue } from "./catalogue.js";
 import { type SelfHostBuildManifest } from "./manifest.js";
 export type SelfHostCommandRunner = (arguments_: readonly string[], workingDirectory: string, signal: AbortSignal) => Promise<void>;
 export interface GenerateSelfHostProjectOptions {

package/dist/self-host/project-generator.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
 import { mkdir, readFile, readdir, rm, stat, writeFile, } from "node:fs/promises";
 import { dirname, parse, resolve } from "node:path";
+import { isSelfHostModuleCustomerSelectable, } from "./catalogue.js";
 import { parseSelfHostBuildManifest, } from "./manifest.js";
 const generatedFileNames = [
     ".env.example",
@@ -102,8 +103,11 @@ function renderReadme(template, manifest, catalogue) {
         ? manifest.modules
             .map((module) => {
             const definition = modulesById.get(module.id);
+            if (definition && !isSelfHostModuleCustomerSelectable(definition))
+                return null;
             return `- ${definition?.name ?? module.id} (\`${module.package}@${module.version}\`)`;
         })
+            .filter((line) => line !== null)
             .join("\n")
         : "- No feature modules selected. This is a core-only installation.";
     return normalizeCrLf(template.replace("{{SELECTED_MODULES}}", selected));
@@ -376,6 +380,27 @@ export const selfHostEnvironmentContract = {
         value: "365",
         optional: true,
     },
+    HELYX_STATUS_ENABLED: { value: "false", optional: false },
+    HELYX_STATUS_URL: {
+        value: "https://status.helyx.gg",
+        optional: true,
+    },
+    HELYX_STATUS_HEARTBEAT_SECRET: {
+        value: "replace-with-a-base64-encoded-32-byte-key",
+        optional: true,
+    },
+    HELYX_STATUS_HEARTBEAT_INTERVAL_SECONDS: {
+        value: "60",
+        optional: true,
+    },
+    CF_ACCESS_CLIENT_ID: {
+        value: "replace-with-access-client-id",
+        optional: true,
+    },
+    CF_ACCESS_CLIENT_SECRET: {
+        value: "replace-with-access-client-secret",
+        optional: true,
+    },
     LOG_LEVEL: { value: "info", optional: false },
     NODE_ENV: { value: "production", optional: false },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helyx/cli",
-  "version": "0.4.41",
+  "version": "0.5.1",
   "description": "Command-line tools for running and generating self-hosted Helyx deployments.",
   "keywords": [
     "helyx",