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

package/src/paths.ts

@@ -1,74 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-interface RuntimePathOptions {
-  cwd?: string
-  env?: Record<string, string | undefined>
-}
-
-export function resolveRuntimePaths(options: RuntimePathOptions = {}) {
-  const runtimeRoot = path.resolve(options.cwd ?? process.cwd())
-  const env = options.env ?? process.env
-  const repoRoot = findRepoRoot(runtimeRoot)
-
-  return {
-    repoRoot,
-    runtimeRoot,
-    uploadsDir: resolveConfiguredPath(
-      env.JCHAT_UPLOADS_DIR,
-      runtimeRoot,
-      repoRoot,
-      "uploads",
-      "uploads"
-    ),
-    addonBundlesDir: resolveConfiguredPath(
-      env.JCHAT_ADDONS_DIR,
-      runtimeRoot,
-      repoRoot,
-      "addons",
-      "addons"
-    ),
-    addonSourceDir: repoRoot
-      ? path.join(repoRoot, "addons-dev")
-      : path.join(runtimeRoot, "addons-dev"),
-    migrationsDir: resolveConfiguredPath(
-      env.JCHAT_MIGRATIONS_DIR,
-      runtimeRoot,
-      repoRoot,
-      path.join("packages", "db", "migrations"),
-      "migrations"
-    )
-  }
-}
-
-function hasRepoMarkers(dir: string) {
-  return (
-    fs.existsSync(path.join(dir, "package.json")) &&
-    fs.existsSync(path.join(dir, "apps")) &&
-    fs.existsSync(path.join(dir, "packages"))
-  )
-}
-
-function findRepoRoot(startDir: string) {
-  let current = path.resolve(startDir)
-
-  while (true) {
-    if (hasRepoMarkers(current)) return current
-
-    const parent = path.dirname(current)
-    if (parent === current) return null
-    current = parent
-  }
-}
-
-function resolveConfiguredPath(
-  configuredPath: string | undefined,
-  runtimeRoot: string,
-  repoRoot: string | null,
-  repoRelativePath: string,
-  runtimeRelativePath: string
-) {
-  if (configuredPath) return path.resolve(configuredPath)
-  if (repoRoot) return path.join(repoRoot, repoRelativePath)
-  return path.join(runtimeRoot, runtimeRelativePath)
-}

package/src/runtime.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  getRuntimeStatus,
-  isApplicationDisabled,
-  registerInvalidationHandler,
-  setRuntimeStatus
-} from "./runtime"
-
-describe("license runtime status", () => {
-  test("disables the application and invokes the invalidation handler", () => {
-    let shutdowns = 0
-    registerInvalidationHandler(() => {
-      shutdowns += 1
-    })
-    setRuntimeStatus("invalid", "support-1")
-    expect(isApplicationDisabled()).toBe(true)
-    expect(getRuntimeStatus()).toEqual({ status: "invalid", reference: "support-1" })
-    expect(shutdowns).toBe(1)
-    setRuntimeStatus("valid", "support-2")
-  })
-})

package/src/runtime.ts

@@ -1,31 +0,0 @@
-import crypto from "node:crypto"
-
-export type RuntimeStatus = "valid" | "unreachable-fallback" | "invalid" | "unavailable"
-
-let runtimeStatus: RuntimeStatus = "unavailable"
-let supportReference = "startup"
-let shutdownHandler: (() => void) | undefined
-
-export function registerInvalidationHandler(handler: () => void): void {
-  shutdownHandler = handler
-}
-
-export function setRuntimeStatus(
-  status: RuntimeStatus,
-  reference: string = crypto.randomUUID()
-): void {
-  runtimeStatus = status
-  supportReference = reference
-  if (status === "invalid") shutdownHandler?.()
-}
-
-export function getRuntimeStatus(): {
-  status: RuntimeStatus
-  reference: string
-} {
-  return { status: runtimeStatus, reference: supportReference }
-}
-
-export function isApplicationDisabled(): boolean {
-  return runtimeStatus === "invalid"
-}

package/src/state.test.ts

@@ -1,54 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import fs from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { acquireProcessLock, createIdentity, readState, readTokenSync, writeState } from "./state"
-
-const temporaryDirectories: string[] = []
-
-async function createTemporaryDirectory(prefix: string): Promise<string> {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), prefix))
-  temporaryDirectories.push(directory)
-  return directory
-}
-
-describe("license state", () => {
-  afterEach(async () => {
-    await Promise.all(
-      temporaryDirectories
-        .splice(0)
-        .map((directory) => fs.rm(directory, { recursive: true, force: true }))
-    )
-  })
-
-  test("persists and reads a complete state atomically", async () => {
-    const directory = await createTemporaryDirectory("jchat-runtime-")
-    const filePath = path.join(directory, "license.json")
-    const identity = createIdentity("machine-a")
-    const state = { version: 1 as const, ...identity, instanceToken: "signed-license" }
-    await writeState(state, filePath)
-    expect(await readState(filePath)).toEqual(state)
-    expect(readTokenSync(filePath)).toBe("signed-license")
-  })
-
-  test("rejects incomplete local state", async () => {
-    const directory = await createTemporaryDirectory("jchat-runtime-invalid-")
-    const filePath = path.join(directory, "license.json")
-    await Bun.write(
-      filePath,
-      JSON.stringify({ version: 1, installationId: "installation-1", instanceToken: "token" })
-    )
-
-    expect(await readState(filePath)).toBeNull()
-  })
-
-  test("prevents two processes from acquiring the same local lock", async () => {
-    const directory = await createTemporaryDirectory("jchat-runtime-lock-")
-    const filePath = path.join(directory, "license.json")
-    const release = await acquireProcessLock(filePath)
-    await expect(acquireProcessLock(filePath)).rejects.toBeTruthy()
-    await release()
-    const secondRelease = await acquireProcessLock(filePath)
-    await secondRelease()
-  })
-})

package/src/state.ts

@@ -1,129 +0,0 @@
-import crypto from "node:crypto"
-import fsSync from "node:fs"
-import fs from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-
-export type LocalState = {
-  version: 1
-  installationId: string
-  privateKeyPem: string
-  publicKeyPem: string
-  machineFingerprint: string
-  instanceToken: string
-  lastSuccessfulCheckAt?: string
-}
-
-export const DEFAULT_STATE_PATH = path.resolve(process.cwd(), "data/instance.json")
-
-export function createMachineFingerprint(): string {
-  return crypto
-    .createHash("sha256")
-    .update([os.hostname(), os.platform(), os.arch()].join("|"))
-    .digest("hex")
-}
-
-export function createIdentity(machineFingerprint = createMachineFingerprint()) {
-  const keyPair = crypto.generateKeyPairSync("ed25519")
-  return {
-    installationId: crypto.randomUUID(),
-    machineFingerprint,
-    privateKeyPem: keyPair.privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
-    publicKeyPem: keyPair.publicKey.export({ type: "spki", format: "pem" }).toString()
-  }
-}
-
-export function readTokenSync(filePath = DEFAULT_STATE_PATH): string {
-  try {
-    if (!fsSync.existsSync(filePath)) return ""
-    const content = fsSync.readFileSync(filePath, "utf8")
-    const parsed = JSON.parse(content) as LocalState
-    return parsed?.instanceToken ?? ""
-  } catch {
-    return ""
-  }
-}
-
-export async function readState(filePath = DEFAULT_STATE_PATH): Promise<LocalState | null> {
-  try {
-    const parsed: unknown = JSON.parse(await Bun.file(filePath).text())
-    if (!parsed || typeof parsed !== "object") return null
-    const state = parsed as Partial<LocalState>
-    if (
-      state.version !== 1 ||
-      typeof state.installationId !== "string" ||
-      !state.installationId ||
-      typeof state.privateKeyPem !== "string" ||
-      !state.privateKeyPem ||
-      typeof state.publicKeyPem !== "string" ||
-      !state.publicKeyPem ||
-      typeof state.machineFingerprint !== "string" ||
-      !state.machineFingerprint ||
-      typeof state.instanceToken !== "string" ||
-      !state.instanceToken ||
-      (state.lastSuccessfulCheckAt !== undefined &&
-        (typeof state.lastSuccessfulCheckAt !== "string" || !state.lastSuccessfulCheckAt))
-    ) {
-      return null
-    }
-    return state as LocalState
-  } catch {
-    return null
-  }
-}
-
-export async function writeState(state: LocalState, filePath = DEFAULT_STATE_PATH): Promise<void> {
-  const directory = path.dirname(filePath)
-  await fs.mkdir(directory, { recursive: true })
-  const temporaryPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`
-  await Bun.write(temporaryPath, `${JSON.stringify(state, null, 2)}\n`)
-  await fs.rename(temporaryPath, filePath)
-}
-
-export async function updateInstanceToken(
-  instanceToken: string,
-  statePath = DEFAULT_STATE_PATH
-): Promise<void> {
-  const localState = await readState(statePath)
-  if (!localState) throw new Error("Local license state is missing")
-  await writeState(
-    { ...localState, instanceToken, lastSuccessfulCheckAt: new Date().toISOString() },
-    statePath
-  )
-}
-
-export async function acquireProcessLock(
-  statePath = DEFAULT_STATE_PATH
-): Promise<() => Promise<void>> {
-  const lockPath = `${statePath}.lock`
-  await fs.mkdir(path.dirname(lockPath), { recursive: true })
-  let handle
-  try {
-    handle = await fs.open(lockPath, "wx")
-  } catch (error) {
-    if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") throw error
-    const ownerPid = Number.parseInt(
-      await Bun.file(lockPath)
-        .text()
-        .catch(() => ""),
-      10
-    )
-    let ownerAlive = false
-    if (Number.isInteger(ownerPid) && ownerPid > 0) {
-      try {
-        process.kill(ownerPid, 0)
-        ownerAlive = true
-      } catch {
-        ownerAlive = false
-      }
-    }
-    if (ownerAlive) throw new Error("Another JChat process already owns the license lock")
-    await fs.rm(lockPath, { force: true })
-    handle = await fs.open(lockPath, "wx")
-  }
-  await handle.writeFile(`${process.pid}\n`)
-  return async () => {
-    await handle.close()
-    await fs.rm(lockPath, { force: true })
-  }
-}