@jchat/runtime 1.0.0-alpha.1 → 1.0.0-alpha.11

package/src/env.ts

@@ -1,261 +0,0 @@
-import { StorageType, isMainDomain } from "@jchat/shared"
-import { replaceKeys } from "string-ts"
-import * as z from "zod"
-
-export function makeTypedEnv<T>(schema: { parse: (data: unknown) => T }) {
-  return (args: Record<string, unknown>) => schema.parse(replaceKeys(args, "VITE_", ""))
-}
-
-export const ServerConfigSchema = z
-  .object({
-    JCHAT_PORT: z
-      .string()
-      .regex(/^\d+$/)
-      .transform(Number)
-      .refine((port) => port >= 1 && port <= 65535, {
-        message: "Port must be between 1 and 65535"
-      })
-      .refine((port) => port !== 80 && port !== 443, {
-        message: "Avoid ports 80/443 (reserved for HTTP/HTTPS)"
-      })
-      .default(3000),
-
-    JCHAT_COOKIE_SECRET: z.string().min(1),
-
-    //DATABASE CONFIG
-    JCHAT_DATABASE_URL: z
-      .url()
-      .startsWith("postgresql://")
-      .regex(/^postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/([^?]+)(\?.*)?$/, {
-        message: "Must be in format: postgresql://username:password@host:port/database?schema"
-      }),
-    JCHAT_REDIS_DATABASE_URL: z
-      .url()
-      .refine((url) => url.startsWith("rediss://") || url.startsWith("redis://"), {
-        message: "Must use redis:// or rediss:// protocol"
-      })
-      .refine(
-        (url) => {
-          const pattern = /^(rediss?):\/\/(?:([^:]+):([^@]+)@)?([^:]+):(\d+)$/
-          return pattern.test(url)
-        },
-        {
-          message: "Must be in format: rediss://default:<password>@<host>:<port>"
-        }
-      ),
-
-    JCHAT_STORAGE_TYPE: z.enum(StorageType),
-
-    JCHAT_MINIO_ENDPOINT: z.string().optional(),
-    JCHAT_MINIO_BUCKET_NAME: z.string().optional(),
-    JCHAT_MINIO_ACCESS_KEY_ID: z.string().optional(),
-    JCHAT_MINIO_SECRET_ACCESS_KEY: z.string().optional(),
-    JCHAT_MINIO_PUBLIC_URL: z.string().optional(),
-
-    JCHAT_AWS_REGION: z.string().optional(),
-    JCHAT_AWS_BUCKET_NAME: z.string().optional(),
-    JCHAT_AWS_ACCESS_KEY_ID: z.string().optional(),
-    JCHAT_AWS_SECRET_ACCESS_KEY: z.string().optional(),
-
-    JCHAT_CLOUDFLARE_ACCOUNT_ID: z.string().optional(),
-    JCHAT_CLOUDFLARE_BUCKET_NAME: z.string().optional(),
-    JCHAT_CLOUDFLARE_ACCESS_KEY_ID: z.string().optional(),
-    JCHAT_CLOUDFLARE_SECRET_ACCESS_KEY: z.string().optional(),
-    JCHAT_CLOUDFLARE_PUBLIC_URL: z.string().optional(),
-
-    JCHAT_GCS_BUCKET_NAME: z.string().optional(),
-    JCHAT_GCS_PROJECT_ID: z.string().optional(),
-    JCHAT_GCS_CLIENT_EMAIL: z.string().optional(),
-    JCHAT_GCS_PRIVATE_KEY: z.string().optional(),
-    JCHAT_GCS_KEY_FILE: z.string().optional(),
-
-    JCHAT_BOT_NAME: z.string().trim().min(3),
-    JCHAT_BOT_EMAIL: z.email(),
-
-    JCHAT_DOMAIN: z.string().optional(),
-    JCHAT_SITE_URL: z.url().optional(),
-    JCHAT_ROUTING_MODE: z.enum(["path", "subdomain"]).default("subdomain"),
-
-    JCHAT_ADDON_ENCRYPTION_KEY: z.string().min(16),
-
-    NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
-
-    SYSTEM_BOOTSTRAP_COMPLETE: z.boolean().optional()
-  })
-  .superRefine((env, ctx) => {
-    if (env.JCHAT_SITE_URL) {
-      let siteHostname: string | undefined
-      try {
-        siteHostname = new URL(env.JCHAT_SITE_URL).hostname
-      } catch {}
-
-      if (siteHostname && !isMainDomain(siteHostname)) {
-        ctx.addIssue({
-          path: ["JCHAT_SITE_URL"],
-          code: "custom",
-          message: "JCHAT_SITE_URL must use the client main/root domain"
-        })
-      }
-    }
-
-    if (
-      env.JCHAT_STORAGE_TYPE === "MINIO" &&
-      !(
-        env.JCHAT_MINIO_ENDPOINT &&
-        env.JCHAT_MINIO_BUCKET_NAME &&
-        env.JCHAT_MINIO_ACCESS_KEY_ID &&
-        env.JCHAT_MINIO_SECRET_ACCESS_KEY &&
-        env.JCHAT_MINIO_PUBLIC_URL
-      )
-    ) {
-      if (!env.JCHAT_MINIO_ENDPOINT)
-        ctx.addIssue({
-          path: ["JCHAT_MINIO_ENDPOINT"],
-          code: "custom",
-          message: "JCHAT_MINIO_ENDPOINT is required when JCHAT_STORAGE_TYPE is MINIO"
-        })
-      if (!env.JCHAT_MINIO_BUCKET_NAME)
-        ctx.addIssue({
-          path: ["JCHAT_MINIO_BUCKET_NAME"],
-          code: "custom",
-          message: "JCHAT_MINIO_BUCKET_NAME is required when JCHAT_STORAGE_TYPE is MINIO"
-        })
-      if (!env.JCHAT_MINIO_ACCESS_KEY_ID)
-        ctx.addIssue({
-          path: ["JCHAT_MINIO_ACCESS_KEY_ID"],
-          code: "custom",
-          message: "JCHAT_MINIO_ACCESS_KEY_ID is required when JCHAT_STORAGE_TYPE is MINIO"
-        })
-      if (!env.JCHAT_MINIO_SECRET_ACCESS_KEY)
-        ctx.addIssue({
-          path: ["JCHAT_MINIO_SECRET_ACCESS_KEY"],
-          code: "custom",
-          message: "JCHAT_MINIO_SECRET_ACCESS_KEY is required when JCHAT_STORAGE_TYPE is MINIO"
-        })
-      if (!env.JCHAT_MINIO_PUBLIC_URL)
-        ctx.addIssue({
-          path: ["JCHAT_MINIO_PUBLIC_URL"],
-          code: "custom",
-          message: "JCHAT_MINIO_PUBLIC_URL is required when JCHAT_STORAGE_TYPE is MINIO"
-        })
-    }
-
-    if (
-      env.JCHAT_STORAGE_TYPE === "AWS_S3" &&
-      !(
-        env.JCHAT_AWS_REGION &&
-        env.JCHAT_AWS_ACCESS_KEY_ID &&
-        env.JCHAT_AWS_SECRET_ACCESS_KEY &&
-        env.JCHAT_AWS_BUCKET_NAME
-      )
-    ) {
-      if (!env.JCHAT_AWS_REGION)
-        ctx.addIssue({
-          path: ["JCHAT_AWS_REGION"],
-          code: "custom",
-          message: "JCHAT_AWS_REGION is required when JCHAT_STORAGE_TYPE is AWS_S3"
-        })
-      if (!env.JCHAT_AWS_ACCESS_KEY_ID)
-        ctx.addIssue({
-          path: ["JCHAT_AWS_ACCESS_KEY_ID"],
-          code: "custom",
-          message: "JCHAT_AWS_ACCESS_KEY_ID is required when JCHAT_STORAGE_TYPE is AWS_S3"
-        })
-      if (!env.JCHAT_AWS_SECRET_ACCESS_KEY)
-        ctx.addIssue({
-          path: ["JCHAT_AWS_SECRET_ACCESS_KEY"],
-          code: "custom",
-          message: "JCHAT_AWS_SECRET_ACCESS_KEY is required when JCHAT_STORAGE_TYPE is AWS_S3"
-        })
-      if (!env.JCHAT_AWS_BUCKET_NAME)
-        ctx.addIssue({
-          path: ["JCHAT_AWS_BUCKET_NAME"],
-          code: "custom",
-          message: "JCHAT_AWS_BUCKET_NAME is required when JCHAT_STORAGE_TYPE is AWS_S3"
-        })
-    }
-
-    if (
-      env.JCHAT_STORAGE_TYPE === "CLOUDFLARE_R2" &&
-      !(
-        env.JCHAT_CLOUDFLARE_ACCOUNT_ID &&
-        env.JCHAT_CLOUDFLARE_ACCESS_KEY_ID &&
-        env.JCHAT_CLOUDFLARE_SECRET_ACCESS_KEY &&
-        env.JCHAT_CLOUDFLARE_BUCKET_NAME &&
-        env.JCHAT_CLOUDFLARE_PUBLIC_URL
-      )
-    ) {
-      if (!env.JCHAT_CLOUDFLARE_ACCOUNT_ID)
-        ctx.addIssue({
-          path: ["JCHAT_CLOUDFLARE_ACCOUNT_ID"],
-          code: "custom",
-          message:
-            "JCHAT_CLOUDFLARE_ACCOUNT_ID is required when JCHAT_STORAGE_TYPE is CLOUDFLARE_R2"
-        })
-      if (!env.JCHAT_CLOUDFLARE_ACCESS_KEY_ID)
-        ctx.addIssue({
-          path: ["JCHAT_CLOUDFLARE_ACCESS_KEY_ID"],
-          code: "custom",
-          message:
-            "JCHAT_CLOUDFLARE_ACCESS_KEY_ID is required when JCHAT_STORAGE_TYPE is CLOUDFLARE_R2"
-        })
-      if (!env.JCHAT_CLOUDFLARE_SECRET_ACCESS_KEY)
-        ctx.addIssue({
-          path: ["JCHAT_CLOUDFLARE_SECRET_ACCESS_KEY"],
-          code: "custom",
-          message:
-            "JCHAT_CLOUDFLARE_SECRET_ACCESS_KEY is required when JCHAT_STORAGE_TYPE is CLOUDFLARE_R2"
-        })
-      if (!env.JCHAT_CLOUDFLARE_BUCKET_NAME)
-        ctx.addIssue({
-          path: ["JCHAT_CLOUDFLARE_BUCKET_NAME"],
-          code: "custom",
-          message:
-            "JCHAT_CLOUDFLARE_BUCKET_NAME is required when JCHAT_STORAGE_TYPE is CLOUDFLARE_R2"
-        })
-      if (!env.JCHAT_CLOUDFLARE_PUBLIC_URL)
-        ctx.addIssue({
-          path: ["JCHAT_CLOUDFLARE_PUBLIC_URL"],
-          code: "custom",
-          message:
-            "JCHAT_CLOUDFLARE_PUBLIC_URL is required when JCHAT_STORAGE_TYPE is CLOUDFLARE_R2"
-        })
-    }
-
-    if (
-      env.JCHAT_STORAGE_TYPE === "GCS" &&
-      !(
-        env.JCHAT_GCS_PROJECT_ID &&
-        env.JCHAT_GCS_BUCKET_NAME &&
-        env.JCHAT_GCS_CLIENT_EMAIL &&
-        env.JCHAT_GCS_PRIVATE_KEY
-      )
-    ) {
-      if (!env.JCHAT_GCS_PROJECT_ID)
-        ctx.addIssue({
-          path: ["JCHAT_GCS_PROJECT_ID"],
-          code: "custom",
-          message: "JCHAT_GCS_PROJECT_ID is required when JCHAT_STORAGE_TYPE is GCS"
-        })
-      if (!env.JCHAT_GCS_BUCKET_NAME)
-        ctx.addIssue({
-          path: ["JCHAT_GCS_BUCKET_NAME"],
-          code: "custom",
-          message: "JCHAT_GCS_BUCKET_NAME is required when JCHAT_STORAGE_TYPE is GCS"
-        })
-      if (!env.JCHAT_GCS_CLIENT_EMAIL)
-        ctx.addIssue({
-          path: ["JCHAT_GCS_CLIENT_EMAIL"],
-          code: "custom",
-          message: "JCHAT_GCS_CLIENT_EMAIL is required when JCHAT_STORAGE_TYPE is GCS"
-        })
-      if (!env.JCHAT_GCS_PRIVATE_KEY)
-        ctx.addIssue({
-          path: ["JCHAT_GCS_PRIVATE_KEY"],
-          code: "custom",
-          message: "JCHAT_GCS_PRIVATE_KEY is required when JCHAT_STORAGE_TYPE is GCS"
-        })
-    }
-  })
-
-export type ServerConfig = z.infer<typeof ServerConfigSchema>

package/src/index.test.ts

@@ -1,117 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import crypto from "node:crypto"
-import { hasEntitlement, parsePayload, verifyEntitlement, verifySignature } from "./index"
-
-const keyPair = crypto.generateKeyPairSync("rsa", { modulusLength: 2048 })
-const publicKeyPem = keyPair.publicKey.export({ type: "spki", format: "pem" }).toString()
-
-function createToken(
-  overrides: Record<string, unknown> = {},
-  headerOverrides: Record<string, unknown> = {}
-) {
-  const header = Buffer.from(
-    JSON.stringify({ alg: "RS256", typ: "JWT", ...headerOverrides })
-  ).toString("base64url")
-  const payload = Buffer.from(
-    JSON.stringify({
-      iss: "https://license.jchat.local",
-      aud: "jchat-chat",
-      licenseId: "license-1",
-      domain: "www.example.com:8080",
-      buyer: "Customer",
-      installationId: "install-1",
-      machineFingerprint: "machine-1",
-      plan: "extended",
-      entitlements: ["site.create.multi"],
-      purchaseProvider: "envato",
-      environment: "production",
-      routingMode: "path",
-      iat: 1,
-      ...overrides
-    })
-  ).toString("base64url")
-  const signingInput = `${header}.${payload}`
-  const signature = crypto
-    .sign("sha256", Buffer.from(signingInput), keyPair.privateKey)
-    .toString("base64url")
-  return `${signingInput}.${signature}`
-}
-
-const options = { publicKeyPem }
-
-describe("license runtime", () => {
-  test("parses and verifies a normalized perpetual public-domain license", () => {
-    const token = createToken()
-    const payload = parsePayload(token)
-    expect(payload?.licenseId).toBe("license-1")
-    expect(payload).not.toHaveProperty("exp")
-    expect(verifySignature(token, "example.com", options)).toBe(true)
-    expect(verifyEntitlement(token, "example.com:3000", "install-1", "machine-1", options)).toBe(
-      true
-    )
-    expect(hasEntitlement(token, "www.example.com", "site.create.multi", options)).toBe(true)
-  })
-
-  test("rejects forged signatures and binding mismatches", () => {
-    const token = createToken()
-    expect(verifySignature(`${token}x`, "example.com", options)).toBe(false)
-    expect(verifySignature(token, "other.example.com", options)).toBe(false)
-    expect(verifyEntitlement(token, "example.com", "other-install", "machine-1", options)).toBe(
-      false
-    )
-    expect(verifyEntitlement(token, "example.com", "install-1", "other-machine", options)).toBe(
-      false
-    )
-  })
-
-  test("rejects issuer, audience, and algorithm mismatches", () => {
-    expect(
-      verifySignature(createToken({ iss: "https://other.example" }), "example.com", options)
-    ).toBe(false)
-    expect(verifySignature(createToken({ aud: "other-app" }), "example.com", options)).toBe(false)
-    expect(verifySignature(createToken({}, { alg: "HS256" }), "example.com", options)).toBe(false)
-  })
-
-  test("rejects malformed and incomplete claims", () => {
-    for (const overrides of [
-      { licenseId: undefined },
-      { domain: 42 },
-      { buyer: "" },
-      { installationId: undefined },
-      { machineFingerprint: undefined },
-      { plan: "multi" },
-      { entitlements: "site.create.multi" },
-      { purchaseProvider: "unknown" },
-      { environment: "staging" },
-      { routingMode: "host" },
-      { iat: "now" }
-    ]) {
-      expect(parsePayload(createToken(overrides))).toBeNull()
-    }
-    expect(parsePayload("header.invalid.signature")).toBeNull()
-  })
-
-  test("enforces standard and extended entitlement consistency", () => {
-    const standard = createToken({ plan: "standard", entitlements: [] })
-    expect(verifyEntitlement(standard, "example.com", "install-1", "machine-1", options)).toBe(true)
-    expect(hasEntitlement(standard, "example.com", "site.create.multi", options)).toBe(false)
-
-    expect(parsePayload(createToken({ plan: "standard" }))).toBeNull()
-    expect(parsePayload(createToken({ plan: "extended", entitlements: [] }))).toBeNull()
-  })
-
-  test("allows only vendor-issued development claims on localhost", () => {
-    const development = createToken({
-      domain: "localhost",
-      plan: "standard",
-      entitlements: [],
-      environment: "development"
-    })
-    expect(
-      verifyEntitlement(development, "www.localhost:3000", "install-1", "machine-1", options)
-    ).toBe(true)
-
-    expect(parsePayload(createToken({ domain: "localhost" }))).toBeNull()
-    expect(parsePayload(createToken({ environment: "development" }))).toBeNull()
-  })
-})

package/src/index.ts

@@ -1,206 +0,0 @@
-import crypto from "node:crypto"
-import { isPublicDomain, normalizeDomain, type Plan, type RoutingMode } from "./domain"
-
-export * from "./audit"
-export * from "./check"
-export * from "./domain"
-export * from "./state"
-export * from "./runtime"
-export * from "./install"
-export * from "./paths"
-export * from "./env"
-
-export type PurchaseProvider = "envato" | "jchat"
-export type RuntimeEnvironment = "production" | "development"
-
-export type ConfigPayload = {
-  iss: string
-  aud: string
-  licenseId: string
-  domain: string
-  buyer: string
-  installationId: string
-  machineFingerprint: string
-  plan: Plan
-  entitlements: string[]
-  purchaseProvider: PurchaseProvider
-  environment: RuntimeEnvironment
-  routingMode: RoutingMode
-  iat: number
-}
-
-export type RuntimeOptions = {
-  publicKeyPem: string
-  issuer?: string
-  audience?: string
-}
-
-export type RuntimeStatus = "valid" | "unreachable-fallback" | "invalid" | "unavailable"
-
-type JwtHeader = {
-  alg: "RS256"
-  typ: "JWT"
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0
-}
-
-function decodeJsonSegment(value: string): unknown {
-  if (!value) return null
-  try {
-    return JSON.parse(Buffer.from(value, "base64url").toString("utf8")) as unknown
-  } catch {
-    return null
-  }
-}
-
-function parseHeader(token: string): JwtHeader | null {
-  const parts = token.split(".")
-  if (parts.length !== 3) return null
-  const header = decodeJsonSegment(parts[0])
-  if (!isRecord(header) || header.alg !== "RS256" || header.typ !== "JWT") return null
-  return { alg: "RS256", typ: "JWT" }
-}
-
-function validatePayload(value: unknown): ConfigPayload | null {
-  if (!isRecord(value)) return null
-
-  const {
-    iss,
-    aud,
-    licenseId,
-    domain,
-    buyer,
-    installationId,
-    machineFingerprint,
-    plan,
-    entitlements,
-    purchaseProvider,
-    environment,
-    routingMode,
-    iat
-  } = value
-
-  if (
-    !isNonEmptyString(iss) ||
-    !isNonEmptyString(aud) ||
-    !isNonEmptyString(licenseId) ||
-    !isNonEmptyString(domain) ||
-    !isNonEmptyString(buyer) ||
-    !isNonEmptyString(installationId) ||
-    !isNonEmptyString(machineFingerprint) ||
-    (plan !== "standard" && plan !== "extended") ||
-    !Array.isArray(entitlements) ||
-    !entitlements.every(isNonEmptyString) ||
-    (purchaseProvider !== "envato" && purchaseProvider !== "jchat") ||
-    (environment !== "production" && environment !== "development") ||
-    (routingMode !== "path" && routingMode !== "subdomain") ||
-    typeof iat !== "number" ||
-    !Number.isSafeInteger(iat) ||
-    iat < 0
-  ) {
-    return null
-  }
-
-  let normalizedDomain
-  try {
-    normalizedDomain = normalizeDomain(domain)
-  } catch {
-    return null
-  }
-
-  if (
-    (environment === "development" && !normalizedDomain.isLocalhost) ||
-    (environment === "production" && !isPublicDomain(domain))
-  ) {
-    return null
-  }
-
-  const hasMultiSiteEntitlement = entitlements.includes("site.create.multi")
-  if (
-    (plan === "extended" && !hasMultiSiteEntitlement) ||
-    (plan === "standard" && hasMultiSiteEntitlement)
-  ) {
-    return null
-  }
-
-  return {
-    iss,
-    aud,
-    licenseId,
-    domain,
-    buyer,
-    installationId,
-    machineFingerprint,
-    plan,
-    entitlements,
-    purchaseProvider,
-    environment,
-    routingMode,
-    iat
-  }
-}
-
-export function parsePayload(token: string): ConfigPayload | null {
-  const parts = token.split(".")
-  if (parts.length !== 3 || !parts.every(Boolean) || !parseHeader(token)) return null
-  return validatePayload(decodeJsonSegment(parts[1]))
-}
-
-export function verifySignature(
-  token: string,
-  currentDomain: string,
-  options: RuntimeOptions
-): boolean {
-  if (!token || token === "YOUR_LICENSE_KEY_PLACEHOLDER") return false
-
-  try {
-    const parts = token.split(".")
-    if (parts.length !== 3 || !parseHeader(token)) return false
-
-    const payload = parsePayload(token)
-    if (!payload) return false
-    if (payload.iss !== (options.issuer ?? "https://license.jchat.local")) return false
-    if (payload.aud !== (options.audience ?? "jchat-chat")) return false
-    if (normalizeDomain(payload.domain).host !== normalizeDomain(currentDomain).host) {
-      return false
-    }
-
-    const dataToVerify = Buffer.from(`${parts[0]}.${parts[1]}`)
-    const signature = Buffer.from(parts[2].replace(/-/g, "+").replace(/_/g, "/"), "base64")
-    return crypto.verify("sha256", dataToVerify, options.publicKeyPem, signature)
-  } catch {
-    return false
-  }
-}
-
-export function verifyEntitlement(
-  token: string,
-  currentDomain: string,
-  installationId: string,
-  machineFingerprint: string,
-  options: RuntimeOptions
-): boolean {
-  if (!verifySignature(token, currentDomain, options)) return false
-
-  const payload = parsePayload(token)
-  if (!payload) return false
-  return (
-    payload.installationId === installationId && payload.machineFingerprint === machineFingerprint
-  )
-}
-
-export function hasEntitlement(
-  token: string,
-  currentDomain: string,
-  entitlement: string,
-  options: RuntimeOptions
-): boolean {
-  if (!verifySignature(token, currentDomain, options)) return false
-  return parsePayload(token)?.entitlements?.includes(entitlement) ?? false
-}

package/src/install.ts

@@ -1,62 +0,0 @@
-import type { DomainScope, RoutingMode } from "./domain"
-import type { PurchaseProvider } from "./index"
-import { activateRegistry } from "./check"
-import { createIdentity, type LocalState } from "./state"
-
-export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
-
-export type LicenseVerificationResult =
-  | {
-      valid: true
-      buyer: string
-      token: string
-      domain: string
-      state: Omit<LocalState, "instanceToken" | "version">
-    }
-  | { valid: false; error: string }
-
-export async function installAndActivate(
-  purchaseCode: string,
-  domain: string,
-  siteSlug: string | undefined,
-  domainScope: DomainScope | undefined,
-  routingMode: RoutingMode,
-  provider: PurchaseProvider = "envato",
-  fetchImpl: FetchLike = fetch
-): Promise<LicenseVerificationResult> {
-  const installationIdentity = createIdentity()
-  try {
-    const licenseData = await activateRegistry({
-      purchaseCode,
-      domain,
-      siteSlug,
-      domainScope,
-      routingMode,
-      provider,
-      installationId: installationIdentity.installationId,
-      installationPublicKey: installationIdentity.publicKeyPem,
-      machineFingerprint: installationIdentity.machineFingerprint,
-      fetchImpl
-    })
-
-    if (!licenseData.success) {
-      return {
-        valid: false,
-        error: licenseData.message
-      }
-    }
-
-    return {
-      valid: true,
-      buyer: licenseData.buyer,
-      token: licenseData.token,
-      domain: licenseData.domain,
-      state: installationIdentity
-    }
-  } catch {
-    return {
-      valid: false,
-      error: "Failed to verify license. Check your internet connection."
-    }
-  }
-}

package/src/paths.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import path from "node:path"
-import { resolveRuntimePaths } from "./paths"
-
-describe("resolveRuntimePaths", () => {
-  it("prefers explicit env paths", () => {
-    const paths = resolveRuntimePaths({
-      cwd: "D:/runtime",
-      env: {
-        JCHAT_UPLOADS_DIR: "/data/uploads",
-        JCHAT_ADDONS_DIR: "/data/addons",
-        JCHAT_MIGRATIONS_DIR: "/data/migrations"
-      }
-    })
-
-    expect(paths.uploadsDir).toBe(path.resolve("/data/uploads"))
-    expect(paths.addonBundlesDir).toBe(path.resolve("/data/addons"))
-    expect(paths.addonSourceDir).toBe(path.join(path.resolve("D:/runtime"), "addons-dev"))
-    expect(paths.migrationsDir).toBe(path.resolve("/data/migrations"))
-  })
-
-  it("uses repo-root fallbacks when running inside the source tree", () => {
-    const repoRoot = path.resolve(import.meta.dir, "..", "..", "..")
-    const paths = resolveRuntimePaths({
-      cwd: path.join(repoRoot, "apps", "web"),
-      env: {}
-    })
-
-    expect(paths.repoRoot).toBe(repoRoot)
-    expect(paths.uploadsDir).toBe(path.join(repoRoot, "uploads"))
-    expect(paths.addonBundlesDir).toBe(path.join(repoRoot, "addons"))
-    expect(paths.addonSourceDir).toBe(path.join(repoRoot, "addons-dev"))
-    expect(paths.migrationsDir).toBe(path.join(repoRoot, "packages", "db", "migrations"))
-  })
-
-  it("falls back to runtime-relative directories outside the repo", () => {
-    const runtimeRoot = path.resolve("D:/isolated-runtime")
-    const paths = resolveRuntimePaths({
-      cwd: runtimeRoot,
-      env: {}
-    })
-
-    expect(paths.repoRoot).toBeNull()
-    expect(paths.uploadsDir).toBe(path.join(runtimeRoot, "uploads"))
-    expect(paths.addonBundlesDir).toBe(path.join(runtimeRoot, "addons"))
-    expect(paths.addonSourceDir).toBe(path.join(runtimeRoot, "addons-dev"))
-    expect(paths.migrationsDir).toBe(path.join(runtimeRoot, "migrations"))
-  })
-})