@jchat/runtime 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/index.d.mts

@@ -1,21 +1,27 @@
-import * as z from "zod";
+import { APPLICATION_DISTRIBUTION, APPLICATION_DISTRIBUTIONS, ApplicationDistribution, IS_DEVELOPER_SANDBOX, isDeveloperSandbox, resolveApplicationDistribution } from "./distribution.mjs";
+import { Elysia } from "elysia";
 //#region src/domain.d.ts
-type Plan = "standard" | "extended";
-type RoutingMode = "path" | "subdomain";
-type DomainScope = "current-host" | "parent-domain";
-type NormalizedDomain = {
+export type Provider = "envato" | "jchat";
+export type Plan = string;
+export type RoutingMode = "path" | "subdomain";
+export type DomainScope = "current-host" | "parent-domain";
+export type NormalizedDomain = {
   host: string;
   isLocalhost: boolean;
 };
 /** Normalize the host used for instance binding; ports and www are not significant. */
-declare function normalizeDomain(value: string): NormalizedDomain;
-declare function isPublicDomain(value: string): boolean;
-declare function isAllowedConfiguredDomain(value: string): boolean;
-declare function resolveActivationDomain(host: string, plan: Plan, routingMode: RoutingMode, domainScope?: DomainScope): string;
+export declare function normalizeDomain(value: string): NormalizedDomain;
+export declare function isPublicDomain(value: string): boolean;
+export declare function isAllowedConfiguredDomain(value: string): boolean;
+export declare function isLocalhostDomain(value: string): boolean;
+export declare function getRootDomain(value: string): string | null;
+/** Checks if a request domain matches or is an authorized subdomain of the licensed domain. */
+export declare function isMatchingDomain(requestHost: string, licensedDomain: string): boolean;
+export declare function resolveActivationDomain(host: string, isMultiSite: boolean, routingMode: RoutingMode, domainScope?: DomainScope): string;
 //#endregion
 //#region src/audit.d.ts
-type AuditEvent = "check_success" | "check_unreachable" | "check_rejected";
-declare function recordAudit(event: AuditEvent, details: {
+export type AuditEvent = "check_success" | "check_unreachable" | "check_rejected";
+export declare function recordAudit(event: AuditEvent, details: {
   domain?: string;
   installationId?: string;
   reference?: string;
@@ -34,18 +40,14 @@ type CheckResult = {
   error: string;
   reference: string;
 };
-type RegistryProvider = "envato" | "jchat";
-type RegistryRoutingMode = "path" | "subdomain";
 type ActivationInput = {
   purchaseCode: string;
   domain: string;
   siteSlug?: string;
   domainScope?: "current-host" | "parent-domain";
-  provider: RegistryProvider;
-  routingMode: RegistryRoutingMode;
+  provider: Provider;
+  routingMode: RoutingMode;
   installationId: string;
-  installationPublicKey: string;
-  machineFingerprint: string;
   registryEndpoint?: string;
   fetchImpl?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 };
@@ -58,58 +60,85 @@ type ActivationResult = {
   success: false;
   message: string;
 };
-declare function activateRegistry(input: ActivationInput): Promise<ActivationResult>;
+export declare function activateRegistry(input: ActivationInput): Promise<ActivationResult>;
 type CheckInput = {
   token: string;
   domain: string;
-  routingMode: RegistryRoutingMode;
+  routingMode: RoutingMode;
   installationId: string;
-  machineFingerprint: string;
   registryEndpoint?: string;
   runtimeOptions?: RuntimeOptions;
   auditPath?: string;
+  lastSuccessfulCheckAt?: string;
+  gracePeriodDays?: number;
   fetchImpl?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-  localTokenValidator?: (token: string, domain: string, installationId: string, machineFingerprint: string) => boolean;
+  localTokenValidator?: (token: string, domain: string, installationId: string) => boolean;
 };
-declare function checkRegistry(input: CheckInput): Promise<CheckResult>;
+//#endregion
+//#region src/constants.d.ts
+export declare const DEFAULT_LICENSE_SERVER_URL = "https://license.jchatcloud.com";
+export declare const DEFAULT_LICENSE_ISSUER = "https://license.jchatcloud.com";
+export declare const DEFAULT_LICENSE_AUDIENCE = "jchat-chat";
+export declare function getOfficialSigningPublicKey(): string;
+export declare const OFFICIAL_SIGNING_PUBLIC_KEY: string;
+//#endregion
+//#region src/feature-crypto.d.ts
+export interface FeatureExecutionContext {
+  isValid: boolean;
+  featureKey: string;
+  stage?: FeatureStage;
+  siteId?: string;
+  executionToken?: string;
+  error?: string;
+}
+/**
+ * Derives a cryptographically bound HMAC-SHA256 secret for a specific feature using the verified
+ * signature of the instance license token. Throws an Error if the signature is invalid or the token
+ * cannot be verified.
+ */
+export declare function deriveFeatureKey(token: string, featureKey: string, domain?: string, options?: RuntimeOptions): string;
+/**
+ * Checks and returns the allowed feature stages (stable, beta, experimental) for the current
+ * instance. The license token MUST have a valid RS256 cryptographic signature against the vendor
+ * public key; otherwise, only "stable" is returned.
+ */
+export declare function checkAllowedStages(domain?: string, options?: RuntimeOptions): FeatureStage[];
+/**
+ * Checks and returns the release channel (stable, lts) for the current instance. Reverts to
+ * "stable" if the token has no valid cryptographic signature.
+ */
+export declare function checkReleaseChannel(domain?: string, options?: RuntimeOptions): ReleaseChannel;
+/** Verifies that the instance is cryptographically licensed to execute a feature at a given stage. */
+export declare function verifyFeatureStageAccess(stage: FeatureStage, domain?: string, options?: RuntimeOptions): boolean;
+/**
+ * Derives a full FeatureExecutionContext. If the feature's required stage is not licensed or the
+ * token signature is invalid, isValid is false with an appropriate error message.
+ */
+export declare function deriveFeatureExecutionContext(featureKey: string, requiredStage?: FeatureStage, siteId?: string, domain?: string, options?: RuntimeOptions): FeatureExecutionContext;
 //#endregion
 //#region src/state.d.ts
 type LocalState = {
   version: 1;
   installationId: string;
-  privateKeyPem: string;
-  publicKeyPem: string;
-  machineFingerprint: string;
   instanceToken: string;
+  domain?: string;
   lastSuccessfulCheckAt?: string;
 };
-declare const DEFAULT_STATE_PATH: string;
-declare function createMachineFingerprint(): string;
-declare function createIdentity(machineFingerprint?: string): {
-  installationId: `${string}-${string}-${string}-${string}-${string}`;
-  machineFingerprint: string;
-  privateKeyPem: string;
-  publicKeyPem: string;
-};
-declare function readTokenSync(filePath?: string): string;
-declare function readState(filePath?: string): Promise<LocalState | null>;
-declare function writeState(state: LocalState, filePath?: string): Promise<void>;
-declare function updateInstanceToken(instanceToken: string, statePath?: string): Promise<void>;
-declare function acquireProcessLock(statePath?: string): Promise<() => Promise<void>>;
-//#endregion
-//#region src/runtime.d.ts
-type RuntimeStatus$1 = "valid" | "unreachable-fallback" | "invalid" | "unavailable";
-declare function registerInvalidationHandler(handler: () => void): void;
-declare function setRuntimeStatus(status: RuntimeStatus$1, reference?: string): void;
-declare function getRuntimeStatus(): {
-  status: RuntimeStatus$1;
-  reference: string;
+export declare function resolveDataDir(): string;
+export declare function getDefaultStatePath(): string;
+export declare const DEFAULT_STATE_PATH: string;
+export declare function createIdentity(): {
+  installationId: string;
 };
-declare function isApplicationDisabled(): boolean;
+export declare function readStateSync(filePath?: string): LocalState | null;
+export declare function readTokenSync(filePath?: string): string;
+export declare function readState(filePath?: string): Promise<LocalState | null>;
+export declare function writeState(state: LocalState, filePath?: string): Promise<void>;
+export declare function updateInstanceToken(instanceToken: string, statePath?: string): Promise<void>;
 //#endregion
 //#region src/install.d.ts
-type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-type LicenseVerificationResult = {
+export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type LicenseVerificationResult = {
   valid: true;
   buyer: string;
   token: string;
@@ -119,99 +148,223 @@ type LicenseVerificationResult = {
   valid: false;
   error: string;
 };
-declare function installAndActivate(purchaseCode: string, domain: string, siteSlug: string | undefined, domainScope: DomainScope | undefined, routingMode: RoutingMode, provider?: PurchaseProvider, fetchImpl?: FetchLike): Promise<LicenseVerificationResult>;
+export declare function installAndActivate(purchaseCode: string, domain: string, siteSlug: string | undefined, domainScope: DomainScope | undefined, routingMode: RoutingMode, provider?: Provider, fetchImpl?: FetchLike): Promise<LicenseVerificationResult>;
 //#endregion
 //#region src/paths.d.ts
 interface RuntimePathOptions {
   cwd?: string;
   env?: Record<string, string | undefined>;
 }
-declare function resolveRuntimePaths(options?: RuntimePathOptions): {
+export declare function resolveRuntimePaths(options?: RuntimePathOptions): {
   repoRoot: string | null;
   runtimeRoot: string;
   uploadsDir: string;
   addonBundlesDir: string;
   addonSourceDir: string;
   migrationsDir: string;
+  dataDir: string;
 };
+export declare function findRepoRoot(startDir: string): string | null;
 //#endregion
-//#region src/env.d.ts
-declare const ServerConfigSchema: z.ZodObject<{
-  JCHAT_PORT: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
-  JCHAT_COOKIE_SECRET: z.ZodString;
-  JCHAT_DATABASE_URL: z.ZodURL;
-  JCHAT_REDIS_DATABASE_URL: z.ZodURL;
-  JCHAT_STORAGE_TYPE: z.ZodEnum<{
-    readonly LOCAL: "LOCAL";
-    readonly MINIO: "MINIO";
-    readonly CLOUDFLARE_R2: "CLOUDFLARE_R2";
-    readonly AWS_S3: "AWS_S3";
-    readonly GCS: "GCS";
-  }>;
-  JCHAT_MINIO_ENDPOINT: z.ZodOptional<z.ZodString>;
-  JCHAT_MINIO_BUCKET_NAME: z.ZodOptional<z.ZodString>;
-  JCHAT_MINIO_ACCESS_KEY_ID: z.ZodOptional<z.ZodString>;
-  JCHAT_MINIO_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
-  JCHAT_MINIO_PUBLIC_URL: z.ZodOptional<z.ZodString>;
-  JCHAT_AWS_REGION: z.ZodOptional<z.ZodString>;
-  JCHAT_AWS_BUCKET_NAME: z.ZodOptional<z.ZodString>;
-  JCHAT_AWS_ACCESS_KEY_ID: z.ZodOptional<z.ZodString>;
-  JCHAT_AWS_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
-  JCHAT_CLOUDFLARE_ACCOUNT_ID: z.ZodOptional<z.ZodString>;
-  JCHAT_CLOUDFLARE_BUCKET_NAME: z.ZodOptional<z.ZodString>;
-  JCHAT_CLOUDFLARE_ACCESS_KEY_ID: z.ZodOptional<z.ZodString>;
-  JCHAT_CLOUDFLARE_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
-  JCHAT_CLOUDFLARE_PUBLIC_URL: z.ZodOptional<z.ZodString>;
-  JCHAT_GCS_BUCKET_NAME: z.ZodOptional<z.ZodString>;
-  JCHAT_GCS_PROJECT_ID: z.ZodOptional<z.ZodString>;
-  JCHAT_GCS_CLIENT_EMAIL: z.ZodOptional<z.ZodString>;
-  JCHAT_GCS_PRIVATE_KEY: z.ZodOptional<z.ZodString>;
-  JCHAT_GCS_KEY_FILE: z.ZodOptional<z.ZodString>;
-  JCHAT_BOT_NAME: z.ZodString;
-  JCHAT_BOT_EMAIL: z.ZodEmail;
-  JCHAT_DOMAIN: z.ZodOptional<z.ZodString>;
-  JCHAT_SITE_URL: z.ZodOptional<z.ZodURL>;
-  JCHAT_ROUTING_MODE: z.ZodDefault<z.ZodEnum<{
-    path: "path";
-    subdomain: "subdomain";
-  }>>;
-  JCHAT_ADDON_ENCRYPTION_KEY: z.ZodString;
-  NODE_ENV: z.ZodDefault<z.ZodEnum<{
-    development: "development";
-    production: "production";
-    test: "test";
-  }>>;
-  SYSTEM_BOOTSTRAP_COMPLETE: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type ServerConfig = z.infer<typeof ServerConfigSchema>;
+//#region src/runtime.d.ts
+type RuntimeStatus$1 = "valid" | "unreachable-fallback" | "invalid" | "unavailable";
+export declare function setRuntimeStatus(status: RuntimeStatus$1, reference?: string): void;
+export declare function getRuntimeStatus(): {
+  status: RuntimeStatus$1;
+  reference: string;
+};
+//#endregion
+//#region src/plugin.d.ts
+export type RuntimePluginOptions = {
+  domain?: string;
+  routingMode?: RoutingMode;
+  checkIntervalDays?: number;
+  signingKey?: string;
+  isBootstrapComplete?: boolean;
+  isPrimaryWorker?: boolean;
+  allowedPaths?: Set<string>;
+  onInvalidate?: () => void;
+  getSiteCount?: () => Promise<number> | number;
+  token?: string;
+};
+export declare function jchatRuntime(options?: RuntimePluginOptions): Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {
+    readonly runtimeStatus: {
+      status: RuntimeStatus$1;
+      reference: string;
+    };
+  };
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {
+    200: {
+      status: string;
+      message: string;
+      reference: string;
+    };
+  };
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>;
+export declare class FeatureForbiddenError extends Error {
+  readonly status = 403;
+  readonly responseStatus: string;
+  readonly reference: string;
+  constructor(message: string, reference?: string, responseStatus?: string);
+}
+export interface FeatureGuardOptions {
+  feature: string;
+  stage?: FeatureStage;
+  domain?: string;
+  requiredEntitlement?: string;
+  resolveSiteId?: (context: {
+    headers: Record<string, string | undefined>;
+    authContext?: {
+      site?: {
+        id: string;
+      };
+    };
+    [key: string]: unknown;
+  }) => Promise<string | undefined> | string | undefined;
+  isSiteEnabled?: (siteId: string, feature: string) => Promise<boolean> | boolean;
+}
+/**
+ * Elysia guard plugin that verifies a feature is active and authorized for the site/instance.
+ * Checks cryptographic license stage access, token validity, and site-level overrides.
+ */
+export declare function runtimeFeatureGuard(options: FeatureGuardOptions): Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {
+    readonly featureContext: FeatureExecutionContext;
+  };
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>;
+export declare function refreshLicenseLease(options?: RuntimePluginOptions): Promise<CheckResult | null>;
+export declare function startRuntimeSupervisor(options?: RuntimePluginOptions): Promise<void>;
+//#endregion
+//#region src/server-context.d.ts
+export interface BaseServerContext {
+  JCHAT_DOMAIN?: string;
+  JCHAT_COOKIE_SECRET: string;
+  NODE_ENV?: string;
+  SYSTEM_BOOTSTRAP_COMPLETE?: boolean;
+  [key: string]: unknown;
+}
+export interface ServerSchema<T> {
+  parse: (data: unknown) => T;
+}
+/**
+ * Validates the server environment against the application schema and seals the server context. In
+ * fresh installations or unconfigured bootstrap states where schema parsing fails, it safely falls
+ * back to an uninstalled state with a randomized cookie secret and SYSTEM_BOOTSTRAP_COMPLETE =
+ * false.
+ */
+export declare function loadServerConfig<T extends Record<string, unknown>>(schema: ServerSchema<T>, environment?: Record<string, unknown>, distribution?: ApplicationDistribution, publicKeyPem?: string): T & {
+  JCHAT_COOKIE_SECRET: string;
+  SYSTEM_BOOTSTRAP_COMPLETE: boolean;
+};
+/**
+ * Cryptographically verifies license state, validates production domain rules, salts
+ * JCHAT_COOKIE_SECRET with the HMAC license signature if verified, or randomizes it and flags
+ * SYSTEM_BOOTSTRAP_COMPLETE as false if invalid.
+ */
+export declare function sealServerContext<T extends Record<string, unknown>>(environmentOrConfig: T, distribution?: ApplicationDistribution, publicKeyPem?: string): T & {
+  JCHAT_COOKIE_SECRET: string;
+  SYSTEM_BOOTSTRAP_COMPLETE: boolean;
+};
 //#endregion
 //#region src/index.d.ts
-type PurchaseProvider = "envato" | "jchat";
-type RuntimeEnvironment = "production" | "development";
-type ConfigPayload = {
+export type RuntimeEnvironment = "production" | "development";
+export type FeatureStage = "stable" | "beta" | "experimental" | "deprecated";
+export type ReleaseChannel = "stable" | "lts";
+export type ConfigPayload = {
   iss: string;
   aud: string;
   licenseId: string;
   domain: string;
   buyer: string;
   installationId: string;
-  machineFingerprint: string;
   plan: Plan;
   entitlements: string[];
-  purchaseProvider: PurchaseProvider;
+  purchaseProvider: Provider;
   environment: RuntimeEnvironment;
   routingMode: RoutingMode;
   iat: number;
+  exp?: number;
+  isTrial?: boolean;
+  stages?: FeatureStage[];
+  channel?: ReleaseChannel;
+  limits?: {
+    maxSites: number;
+    maxRoomsPerSite?: number;
+  };
 };
-type RuntimeOptions = {
-  publicKeyPem: string;
+export type RuntimeOptions = {
+  publicKeyPem?: string;
   issuer?: string;
   audience?: string;
+  allowOfflineGrace?: boolean;
+  lastSuccessfulCheckAt?: string;
+  gracePeriodDays?: number;
 };
-type RuntimeStatus = "valid" | "unreachable-fallback" | "invalid" | "unavailable";
-declare function parsePayload(token: string): ConfigPayload | null;
-declare function verifySignature(token: string, currentDomain: string, options: RuntimeOptions): boolean;
-declare function verifyEntitlement(token: string, currentDomain: string, installationId: string, machineFingerprint: string, options: RuntimeOptions): boolean;
-declare function hasEntitlement(token: string, currentDomain: string, entitlement: string, options: RuntimeOptions): boolean;
+export type RuntimeStatus = "valid" | "unreachable-fallback" | "invalid" | "unavailable";
+export declare function parsePayload(token: string): ConfigPayload | null;
+export declare function resolveSigningPublicKey(providedPem?: string): string;
+export declare function verifySignature(token: string, currentDomain: string, options?: RuntimeOptions): boolean;
+export declare function verifyEntitlement(token: string, currentDomain: string, installationId: string, options?: RuntimeOptions): boolean;
+export declare function hasEntitlement(token: string, currentDomain: string, entitlement: string, options?: RuntimeOptions): boolean;
+export declare function isMultiSiteAllowed(token: string | undefined | null, domain?: string, options?: RuntimeOptions): boolean;
+export declare function hasCapability(token: string | null | undefined, capability: string, domain?: string, options?: RuntimeOptions): boolean;
+export declare function hasStageAccess(token: string | null | undefined, stage: FeatureStage, domain?: string, options?: RuntimeOptions): boolean;
+export declare function getMaxSites(token: string | null | undefined): number;
+export declare function getReleaseChannel(token: string | null | undefined, domain?: string, options?: RuntimeOptions): ReleaseChannel;
+export declare function canCreateMultiSite(token: string | null | undefined): boolean;
+export declare function checkHasEntitlement(entitlement: string, domain?: string): boolean;
+export declare function checkMaxSites(domain?: string, options?: RuntimeOptions): number;
+export declare function checkCanCreateMultiSite(domain?: string): boolean;
+export declare function getContextPlan(defaultPlan?: string, domain?: string, options?: RuntimeOptions): string;
 //#endregion
-export { ActivationInput, ActivationResult, AuditEvent, CheckInput, CheckResult, ConfigPayload, DEFAULT_STATE_PATH, DomainScope, FetchLike, LicenseVerificationResult, LocalState, NormalizedDomain, Plan, PurchaseProvider, RegistryProvider, RegistryRoutingMode, RoutingMode, RuntimeEnvironment, RuntimeOptions, RuntimeStatus, ServerConfig, ServerConfigSchema, acquireProcessLock, activateRegistry, checkRegistry, createIdentity, createMachineFingerprint, getRuntimeStatus, hasEntitlement, installAndActivate, isAllowedConfiguredDomain, isApplicationDisabled, isPublicDomain, normalizeDomain, parsePayload, readState, readTokenSync, recordAudit, registerInvalidationHandler, resolveActivationDomain, resolveRuntimePaths, setRuntimeStatus, updateInstanceToken, verifyEntitlement, verifySignature, writeState };
+export { APPLICATION_DISTRIBUTION, APPLICATION_DISTRIBUTIONS, type ActivationInput, type ActivationResult, ApplicationDistribution, type CheckInput, type CheckResult, IS_DEVELOPER_SANDBOX, type LocalState, isDeveloperSandbox, resolveApplicationDistribution };