@envsync-cloud/deploy-core 0.8.7

package/README.md

@@ -0,0 +1,19 @@
+# EnvSync Deploy Core
+
+Shared deployment primitives for edition-aware packaging.
+
+This package is the extraction target for logic currently living in
+`packages/deploy-cli` so both:
+
+- `@envsync-cloud/deploy` for OSS
+- `@envsync-cloud/deploy-cli` for Enterprise
+
+can share release rendering, topology defaults, and runtime-config generation.
+
+Current exports:
+
+- config file loading for YAML or JSON
+- edition-aware topology validation
+- runtime env generation
+- frontend artifact planning for OSS vs Enterprise
+- release artifact planning for npm, NPM Packages, and container images

package/dist/index.d.ts

@@ -0,0 +1,286 @@
+import { z } from 'zod';
+
+type DeployEdition = "oss" | "enterprise";
+declare class DeployPlanError extends Error {
+    constructor(message: string);
+}
+declare const deployConfigSchema: z.ZodObject<{
+    edition: z.ZodOptional<z.ZodEnum<["oss", "enterprise"]>>;
+    source: z.ZodDefault<z.ZodObject<{
+        repo_url: z.ZodDefault<z.ZodString>;
+        ref: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        repo_url: string;
+        ref: string;
+    }, {
+        repo_url?: string | undefined;
+        ref?: string | undefined;
+    }>>;
+    release: z.ZodDefault<z.ZodObject<{
+        version: z.ZodDefault<z.ZodString>;
+        channel: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        channel: string;
+    }, {
+        version?: string | undefined;
+        channel?: string | undefined;
+    }>>;
+    domain: z.ZodDefault<z.ZodObject<{
+        root_domain: z.ZodDefault<z.ZodString>;
+        acme_email: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        root_domain: string;
+        acme_email: string;
+    }, {
+        root_domain?: string | undefined;
+        acme_email?: string | undefined;
+    }>>;
+    services: z.ZodDefault<z.ZodObject<{
+        stack_name: z.ZodDefault<z.ZodString>;
+        api_port: z.ZodDefault<z.ZodNumber>;
+        management_api_port: z.ZodDefault<z.ZodNumber>;
+        public_http_port: z.ZodDefault<z.ZodNumber>;
+        public_https_port: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        stack_name: string;
+        api_port: number;
+        management_api_port: number;
+        public_http_port: number;
+        public_https_port: number;
+    }, {
+        stack_name?: string | undefined;
+        api_port?: number | undefined;
+        management_api_port?: number | undefined;
+        public_http_port?: number | undefined;
+        public_https_port?: number | undefined;
+    }>>;
+    images: z.ZodDefault<z.ZodObject<{
+        api: z.ZodDefault<z.ZodString>;
+        management_api: z.ZodDefault<z.ZodString>;
+        web: z.ZodDefault<z.ZodString>;
+        enterprise_web: z.ZodDefault<z.ZodString>;
+        landing: z.ZodDefault<z.ZodString>;
+        keycloak: z.ZodDefault<z.ZodString>;
+        clickstack: z.ZodDefault<z.ZodString>;
+        otel_agent: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        api: string;
+        management_api: string;
+        web: string;
+        enterprise_web: string;
+        landing: string;
+        keycloak: string;
+        clickstack: string;
+        otel_agent: string;
+    }, {
+        api?: string | undefined;
+        management_api?: string | undefined;
+        web?: string | undefined;
+        enterprise_web?: string | undefined;
+        landing?: string | undefined;
+        keycloak?: string | undefined;
+        clickstack?: string | undefined;
+        otel_agent?: string | undefined;
+    }>>;
+    features: z.ZodDefault<z.ZodObject<{
+        management_api: z.ZodOptional<z.ZodBoolean>;
+        management_web: z.ZodOptional<z.ZodBoolean>;
+        landing: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        management_api?: boolean | undefined;
+        landing?: boolean | undefined;
+        management_web?: boolean | undefined;
+    }, {
+        management_api?: boolean | undefined;
+        landing?: boolean | undefined;
+        management_web?: boolean | undefined;
+    }>>;
+    observability: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        public_obs: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+        public_obs?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        public_obs?: boolean | undefined;
+    }>>;
+    license: z.ZodDefault<z.ZodObject<{
+        required: z.ZodOptional<z.ZodBoolean>;
+        server_url: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        install_fingerprint: z.ZodOptional<z.ZodString>;
+        lease_ttl_seconds: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        lease_ttl_seconds: number;
+        required?: boolean | undefined;
+        server_url?: string | undefined;
+        key?: string | undefined;
+        install_fingerprint?: string | undefined;
+    }, {
+        required?: boolean | undefined;
+        server_url?: string | undefined;
+        key?: string | undefined;
+        install_fingerprint?: string | undefined;
+        lease_ttl_seconds?: number | undefined;
+    }>>;
+    frontend: z.ZodDefault<z.ZodObject<{
+        dashboard_variant: z.ZodOptional<z.ZodEnum<["oss", "enterprise"]>>;
+        include_manage_subtree: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        dashboard_variant?: "oss" | "enterprise" | undefined;
+        include_manage_subtree?: boolean | undefined;
+    }, {
+        dashboard_variant?: "oss" | "enterprise" | undefined;
+        include_manage_subtree?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    source: {
+        repo_url: string;
+        ref: string;
+    };
+    release: {
+        version: string;
+        channel: string;
+    };
+    domain: {
+        root_domain: string;
+        acme_email: string;
+    };
+    services: {
+        stack_name: string;
+        api_port: number;
+        management_api_port: number;
+        public_http_port: number;
+        public_https_port: number;
+    };
+    images: {
+        api: string;
+        management_api: string;
+        web: string;
+        enterprise_web: string;
+        landing: string;
+        keycloak: string;
+        clickstack: string;
+        otel_agent: string;
+    };
+    features: {
+        management_api?: boolean | undefined;
+        landing?: boolean | undefined;
+        management_web?: boolean | undefined;
+    };
+    observability: {
+        enabled?: boolean | undefined;
+        public_obs?: boolean | undefined;
+    };
+    license: {
+        lease_ttl_seconds: number;
+        required?: boolean | undefined;
+        server_url?: string | undefined;
+        key?: string | undefined;
+        install_fingerprint?: string | undefined;
+    };
+    frontend: {
+        dashboard_variant?: "oss" | "enterprise" | undefined;
+        include_manage_subtree?: boolean | undefined;
+    };
+    edition?: "oss" | "enterprise" | undefined;
+}, {
+    edition?: "oss" | "enterprise" | undefined;
+    source?: {
+        repo_url?: string | undefined;
+        ref?: string | undefined;
+    } | undefined;
+    release?: {
+        version?: string | undefined;
+        channel?: string | undefined;
+    } | undefined;
+    domain?: {
+        root_domain?: string | undefined;
+        acme_email?: string | undefined;
+    } | undefined;
+    services?: {
+        stack_name?: string | undefined;
+        api_port?: number | undefined;
+        management_api_port?: number | undefined;
+        public_http_port?: number | undefined;
+        public_https_port?: number | undefined;
+    } | undefined;
+    images?: {
+        api?: string | undefined;
+        management_api?: string | undefined;
+        web?: string | undefined;
+        enterprise_web?: string | undefined;
+        landing?: string | undefined;
+        keycloak?: string | undefined;
+        clickstack?: string | undefined;
+        otel_agent?: string | undefined;
+    } | undefined;
+    features?: {
+        management_api?: boolean | undefined;
+        landing?: boolean | undefined;
+        management_web?: boolean | undefined;
+    } | undefined;
+    observability?: {
+        enabled?: boolean | undefined;
+        public_obs?: boolean | undefined;
+    } | undefined;
+    license?: {
+        required?: boolean | undefined;
+        server_url?: string | undefined;
+        key?: string | undefined;
+        install_fingerprint?: string | undefined;
+        lease_ttl_seconds?: number | undefined;
+    } | undefined;
+    frontend?: {
+        dashboard_variant?: "oss" | "enterprise" | undefined;
+        include_manage_subtree?: boolean | undefined;
+    } | undefined;
+}>;
+type DeployConfig = z.infer<typeof deployConfigSchema>;
+interface FrontendArtifactPlan {
+    id: "dashboard" | "management" | "landing";
+    package_name: string;
+    build_command: string;
+    mount_path: string;
+    included: boolean;
+    merged_into_dashboard?: boolean;
+    image: string | null;
+}
+interface ServicePlan {
+    id: string;
+    enabled: boolean;
+    tier: "core" | "enterprise" | "optional";
+    reason: string;
+    image: string | null;
+}
+interface ReleaseArtifactPlan {
+    npm_packages: Array<{
+        name: string;
+        registry: "npm" | "github-packages";
+        edition: DeployEdition;
+        publish: boolean;
+    }>;
+    container_images: Array<{
+        name: string;
+        image: string;
+        build_target: string;
+        edition: "shared" | DeployEdition;
+    }>;
+}
+interface DeploymentPlan {
+    edition: DeployEdition;
+    config: DeployConfig;
+    services: ServicePlan[];
+    frontend: FrontendArtifactPlan[];
+    runtime_env: Record<string, string>;
+    release_artifacts: ReleaseArtifactPlan;
+    warnings: string[];
+}
+declare function readDeployConfigFile(filePath: string): any;
+declare function createDeploymentPlan(rawConfig: unknown, forcedEdition?: DeployEdition): DeploymentPlan;
+declare function loadDeploymentPlanFromFile(filePath: string, forcedEdition?: DeployEdition): DeploymentPlan;
+declare function formatDeploymentPlan(plan: DeploymentPlan, format?: "json" | "yaml"): string;
+
+export { type DeployConfig, type DeployEdition, DeployPlanError, type DeploymentPlan, type FrontendArtifactPlan, type ReleaseArtifactPlan, type ServicePlan, createDeploymentPlan, formatDeploymentPlan, loadDeploymentPlanFromFile, readDeployConfigFile };

package/dist/index.js

@@ -0,0 +1,278 @@
+// src/index.ts
+import fs from "fs";
+import path from "path";
+import YAML from "yaml";
+import { z } from "zod";
+var DeployPlanError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeployPlanError";
+  }
+};
+var deployConfigSchema = z.object({
+  edition: z.enum(["oss", "enterprise"]).optional(),
+  source: z.object({
+    repo_url: z.string().default("https://github.com/EnvSync-Cloud/envsync.git"),
+    ref: z.string().default("main")
+  }).default({}),
+  release: z.object({
+    version: z.string().default("0.8.7"),
+    channel: z.string().default("stable")
+  }).default({}),
+  domain: z.object({
+    root_domain: z.string().default("example.com"),
+    acme_email: z.string().default("ops@example.com")
+  }).default({}),
+  services: z.object({
+    stack_name: z.string().default("envsync"),
+    api_port: z.number().int().positive().default(4e3),
+    management_api_port: z.number().int().positive().default(4001),
+    public_http_port: z.number().int().positive().default(80),
+    public_https_port: z.number().int().positive().default(443)
+  }).default({}),
+  images: z.object({
+    api: z.string().default("ghcr.io/envsync-cloud/envsync-api:stable"),
+    management_api: z.string().default("ghcr.io/envsync-cloud/envsync-management-api:stable"),
+    web: z.string().default("ghcr.io/envsync-cloud/envsync-web-oss-static:stable"),
+    enterprise_web: z.string().default("ghcr.io/envsync-cloud/envsync-web-static:stable"),
+    landing: z.string().default("ghcr.io/envsync-cloud/envsync-landing-static:stable"),
+    keycloak: z.string().default("envsync-keycloak:stable"),
+    clickstack: z.string().default("ghcr.io/envsync-cloud/clickstack:stable"),
+    otel_agent: z.string().default("otel/opentelemetry-collector-contrib:latest")
+  }).default({}),
+  features: z.object({
+    management_api: z.boolean().optional(),
+    management_web: z.boolean().optional(),
+    landing: z.boolean().optional()
+  }).default({}),
+  observability: z.object({
+    enabled: z.boolean().optional(),
+    public_obs: z.boolean().optional()
+  }).default({}),
+  license: z.object({
+    required: z.boolean().optional(),
+    server_url: z.string().optional(),
+    key: z.string().optional(),
+    install_fingerprint: z.string().optional(),
+    lease_ttl_seconds: z.number().int().positive().default(300)
+  }).default({}),
+  frontend: z.object({
+    dashboard_variant: z.enum(["oss", "enterprise"]).optional(),
+    include_manage_subtree: z.boolean().optional()
+  }).default({})
+});
+function readDeployConfigFile(filePath) {
+  const absolutePath = path.resolve(process.cwd(), filePath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new DeployPlanError(`Deploy config file not found: ${absolutePath}`);
+  }
+  const raw = fs.readFileSync(absolutePath, "utf8");
+  if (absolutePath.endsWith(".json")) {
+    return JSON.parse(raw);
+  }
+  return YAML.parse(raw);
+}
+function validateEditionRules(config, edition) {
+  const errors = [];
+  if (edition === "oss") {
+    if (config.edition === "enterprise") {
+      errors.push("OSS deploy tooling cannot consume a config explicitly marked as enterprise.");
+    }
+    if (config.features.management_api === true) {
+      errors.push("OSS edition cannot enable management_api.");
+    }
+    if (config.features.landing === true) {
+      errors.push("OSS edition cannot enable landing.");
+    }
+    if (config.license.required === true) {
+      errors.push("OSS edition cannot require enterprise licensing.");
+    }
+    if (config.license.server_url || config.license.key || config.license.install_fingerprint) {
+      errors.push("OSS edition cannot include enterprise license server settings.");
+    }
+    if (config.frontend.dashboard_variant === "enterprise") {
+      errors.push("OSS edition cannot use the enterprise dashboard variant.");
+    }
+  }
+  if (edition === "enterprise") {
+    if (config.edition === "oss") {
+      errors.push("Enterprise deploy tooling cannot consume a config explicitly marked as oss.");
+    }
+    if (config.features.management_api === false) {
+      errors.push("Enterprise edition must enable management_api.");
+    }
+    if (config.features.landing === false) {
+      errors.push("Enterprise edition must enable landing.");
+    }
+    if (config.license.required === false) {
+      errors.push("Enterprise edition must require licensing.");
+    }
+    if (!config.license.server_url) {
+      errors.push("Enterprise edition requires license.server_url.");
+    }
+    if (config.frontend.dashboard_variant === "oss") {
+      errors.push("Enterprise edition cannot use the OSS dashboard variant.");
+    }
+  }
+  if (errors.length > 0) {
+    throw new DeployPlanError(errors.join(" "));
+  }
+}
+function buildServicePlans(config, edition) {
+  const observabilityEnabled = config.observability.enabled ?? edition === "enterprise";
+  const managementEnabled = edition === "enterprise";
+  const landingEnabled = edition === "enterprise";
+  return [
+    { id: "api", enabled: true, tier: "core", reason: "Required in all editions.", image: config.images.api },
+    { id: "web", enabled: true, tier: "core", reason: "Primary dashboard artifact.", image: edition === "enterprise" ? config.images.enterprise_web : config.images.web },
+    { id: "postgres", enabled: true, tier: "core", reason: "Core persistence.", image: null },
+    { id: "redis", enabled: true, tier: "core", reason: "Core cache and sessions.", image: null },
+    { id: "rustfs", enabled: true, tier: "core", reason: "Object storage for artifacts.", image: null },
+    { id: "openfga", enabled: true, tier: "core", reason: "Authorization service.", image: null },
+    { id: "minikms", enabled: true, tier: "core", reason: "Secret encryption service.", image: null },
+    { id: "keycloak", enabled: true, tier: "core", reason: "Authentication provider.", image: config.images.keycloak },
+    { id: "management-api", enabled: managementEnabled, tier: "enterprise", reason: managementEnabled ? "Enterprise control plane API." : "Not deployed in OSS.", image: managementEnabled ? config.images.management_api : null },
+    { id: "landing", enabled: landingEnabled, tier: "enterprise", reason: landingEnabled ? "Enterprise/public onboarding surface." : "Omitted in OSS.", image: landingEnabled ? config.images.landing : null },
+    { id: "clickstack", enabled: observabilityEnabled, tier: observabilityEnabled ? "optional" : "optional", reason: observabilityEnabled ? "Observability enabled for this topology." : "Observability disabled.", image: observabilityEnabled ? config.images.clickstack : null },
+    { id: "otel-agent", enabled: observabilityEnabled, tier: "optional", reason: observabilityEnabled ? "OTEL pipeline enabled for this topology." : "OTEL disabled.", image: observabilityEnabled ? config.images.otel_agent : null }
+  ];
+}
+function buildFrontendArtifacts(config, edition) {
+  const enterprise = edition === "enterprise";
+  return [
+    {
+      id: "dashboard",
+      package_name: "envsync-web",
+      build_command: enterprise ? "bun run --filter envsync-web build:enterprise" : "bun run --filter envsync-web build:oss",
+      mount_path: "/",
+      included: true,
+      image: enterprise ? config.images.enterprise_web : config.images.web
+    },
+    {
+      id: "landing",
+      package_name: "envsync-landing",
+      build_command: "bun run --filter envsync-landing build",
+      mount_path: "/",
+      included: enterprise,
+      image: enterprise ? config.images.landing : null
+    }
+  ];
+}
+function buildRuntimeEnv(config, edition) {
+  const enterprise = edition === "enterprise";
+  const observabilityEnabled = config.observability.enabled ?? enterprise;
+  return {
+    ENVSYNC_EDITION: edition,
+    ENVSYNC_OBSERVABILITY_ENABLED: String(observabilityEnabled),
+    ENVSYNC_MANAGEMENT_ENABLED: String(enterprise),
+    ENVSYNC_LANDING_ENABLED: String(enterprise),
+    ENVSYNC_SINGLE_ORG_MODE: String(edition === "oss"),
+    ENVSYNC_LICENSE_ENFORCEMENT: String(enterprise),
+    ENVSYNC_LICENSE_MODE: enterprise ? "certificate" : "none",
+    ENVSYNC_LICENSE_BUNDLE_PATH: enterprise ? "/etc/envsync/license/enterprise-license-bundle.json" : "",
+    ENVSYNC_LICENSE_CERT_PATH: enterprise ? "/etc/envsync/license/enterprise-cert.pem" : "",
+    ENVSYNC_LICENSE_KEY_PATH: enterprise ? "/etc/envsync/license/enterprise-key.pem" : "",
+    ENVSYNC_LICENSE_ROOT_CA_CERT_PATH: enterprise ? "/etc/envsync/license/root-ca.pem" : "",
+    MANAGEMENT_API_URL: enterprise ? `https://manage-api.${config.domain.root_domain}` : "",
+    ENVSYNC_LICENSE_SERVER_URL: enterprise ? config.license.server_url ?? "" : "",
+    ENVSYNC_LICENSE_KEY: enterprise ? config.license.key ?? "" : "",
+    ENVSYNC_INSTALL_FINGERPRINT: enterprise ? config.license.install_fingerprint ?? "" : "",
+    ENVSYNC_LICENSE_LEASE_TTL_SECONDS: String(config.license.lease_ttl_seconds),
+    ENVSYNC_STACK_NAME: config.services.stack_name,
+    ENVSYNC_RELEASE_VERSION: config.release.version
+  };
+}
+function buildReleaseArtifacts(config, edition) {
+  const npmPackages = [
+    {
+      name: "@envsync-cloud/deploy",
+      registry: "npm",
+      edition: "oss",
+      publish: edition === "oss"
+    },
+    {
+      name: "@envsync-cloud/deploy-cli",
+      registry: "github-packages",
+      edition: "enterprise",
+      publish: edition === "enterprise"
+    }
+  ];
+  const container_images = [
+    {
+      name: "envsync-api",
+      image: config.images.api,
+      build_target: "packages/envsync-api",
+      edition: "shared"
+    }
+  ];
+  if (edition === "enterprise") {
+    container_images.push(
+      {
+        name: "envsync-management-api",
+        image: config.images.management_api,
+        build_target: "packages/envsync-management-api",
+        edition: "enterprise"
+      },
+      {
+        name: "envsync-web-static",
+        image: config.images.enterprise_web,
+        build_target: "apps/envsync-web#build:enterprise",
+        edition: "enterprise"
+      },
+      {
+        name: "envsync-landing-static",
+        image: config.images.landing,
+        build_target: "apps/envsync-landing#build",
+        edition: "enterprise"
+      }
+    );
+  } else {
+    container_images.push({
+      name: "envsync-web-oss-static",
+      image: config.images.web,
+      build_target: "apps/envsync-web#build:oss",
+      edition: "oss"
+    });
+  }
+  return {
+    npm_packages: npmPackages,
+    container_images
+  };
+}
+function createDeploymentPlan(rawConfig, forcedEdition) {
+  const config = deployConfigSchema.parse(rawConfig);
+  const edition = forcedEdition ?? config.edition ?? "oss";
+  validateEditionRules(config, edition);
+  const warnings = [];
+  if (edition === "oss" && (config.observability.enabled ?? false) === false) {
+    warnings.push("Observability is disabled for OSS. ClickStack and OTEL services will be omitted.");
+  }
+  if (edition === "enterprise" && !config.license.key) {
+    warnings.push("Enterprise topology is valid, but license.key is empty. Activation will fail until a real key is supplied.");
+  }
+  return {
+    edition,
+    config,
+    services: buildServicePlans(config, edition),
+    frontend: buildFrontendArtifacts(config, edition),
+    runtime_env: buildRuntimeEnv(config, edition),
+    release_artifacts: buildReleaseArtifacts(config, edition),
+    warnings
+  };
+}
+function loadDeploymentPlanFromFile(filePath, forcedEdition) {
+  return createDeploymentPlan(readDeployConfigFile(filePath), forcedEdition);
+}
+function formatDeploymentPlan(plan, format = "yaml") {
+  if (format === "json") {
+    return JSON.stringify(plan, null, 2);
+  }
+  return YAML.stringify(plan);
+}
+export {
+  DeployPlanError,
+  createDeploymentPlan,
+  formatDeploymentPlan,
+  loadDeploymentPlanFromFile,
+  readDeployConfigFile
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@envsync-cloud/deploy-core",
+  "version": "0.8.7",
+  "type": "module",
+  "module": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --out-dir dist",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "yaml": "^2.8.1",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2"
+  }
+}