@jchat/addon-sdk 0.0.1 → 1.0.0-alpha.1

package/src/vite.ts

@@ -0,0 +1,289 @@
+import type { Plugin } from "vite"
+import { execFileSync } from "node:child_process"
+import crypto from "node:crypto"
+import fs from "node:fs"
+import path from "node:path"
+import type { AddonManifest } from "./contracts"
+
+/**
+ * Vite plugin to configure Jchat addon manifest generation, bundle backend scripts, copy
+ * migrations, declarative seed data, and zip production build artifacts.
+ */
+export function jchatAddon(options: JchatAddonPluginOptions): Plugin {
+  const { manifest: manifestData } = options
+  let shouldZip = options.zip
+  let developmentBuild = false
+
+  return {
+    name: "jchat-addon",
+    apply: "build",
+    config(_, env) {
+      return {
+        define: {
+          "process.env.NODE_ENV": JSON.stringify(env.mode || "production")
+        }
+      }
+    },
+    configResolved(config) {
+      developmentBuild = config.mode === "development"
+      if (shouldZip === undefined) {
+        shouldZip = config.mode === "production"
+      }
+    },
+    async writeBundle() {
+      const rootDir = process.cwd()
+      const pkgPath = path.resolve(rootDir, "package.json")
+      if (!fs.existsSync(pkgPath)) return
+
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"))
+      const buildDir = path.resolve(rootDir, "build")
+      if (!fs.existsSync(buildDir)) return
+
+      const files = fs.readdirSync(buildDir)
+      const bundleFile = files.find((f) => f.includes("ui") && f.endsWith(".js"))
+
+      if (!bundleFile) return
+
+      if (options.css !== false) {
+        embedCssIntoBundle(buildDir, manifestData.id)
+      }
+
+      let manifest: AddonManifest = {
+        ...manifestData,
+        version: pkg.version,
+        frontend: {
+          ...manifestData.frontend,
+          bundle: `./${bundleFile}`,
+          mountPoints: manifestData.frontend?.mountPoints ?? []
+        }
+      }
+
+      const serverSrcPath = path.resolve(rootDir, "src/api.ts")
+      const hasServer = fs.existsSync(serverSrcPath)
+      if (hasServer) {
+        execFileSync(
+          "bun",
+          createAddonServerBuildArguments(
+            serverSrcPath,
+            path.resolve(buildDir, "api.js"),
+            developmentBuild
+          ),
+          { stdio: "inherit" }
+        )
+        manifest = {
+          ...manifest,
+          server: {
+            ...manifest.server,
+            bundle: "./api.js"
+          }
+        }
+      }
+
+      const databaseFiles = [
+        ...(manifest.server?.migrations ?? []),
+        ...(manifest.server?.seeds ?? [])
+      ]
+      for (const directory of ["migrations", "seeds"]) {
+        fs.rmSync(path.resolve(buildDir, directory), {
+          recursive: true,
+          force: true
+        })
+      }
+      for (const relativePath of databaseFiles) {
+        if (
+          path.isAbsolute(relativePath) ||
+          relativePath.includes("\\") ||
+          relativePath.split("/").includes("..")
+        ) {
+          throw new Error(`Unsafe addon database file path: ${relativePath}`)
+        }
+        const source = path.resolve(rootDir, relativePath)
+        if (!fs.existsSync(source) || !fs.statSync(source).isFile()) {
+          throw new Error(`Missing addon database file: ${relativePath}`)
+        }
+        const destination = path.resolve(buildDir, relativePath)
+        fs.mkdirSync(path.dirname(destination), { recursive: true })
+        fs.copyFileSync(source, destination)
+      }
+
+      if (manifest.server?.migrations?.length || manifest.server?.seeds?.length) {
+        const signingPrivateKey = requireAddonSigningKey(
+          options.signingPrivateKey ?? process.env.JCHAT_ADDON_SIGNING_PRIVATE_KEY,
+          developmentBuild
+        )
+        if (signingPrivateKey) {
+          const archivePaths = [
+            "manifest.json",
+            bundleFile,
+            ...(manifest.server?.migrations ?? []),
+            ...(manifest.server?.seeds ?? [])
+          ]
+          if (hasServer) archivePaths.push("api.js")
+          manifest = signAddonManifest(
+            manifest,
+            archivePaths.map((file) => ({
+              path: file,
+              contents:
+                file === "manifest.json"
+                  ? Buffer.from("")
+                  : fs.readFileSync(path.resolve(buildDir, file))
+            })),
+            signingPrivateKey
+          )
+        }
+      }
+
+      // Save manifest.json
+      const manifestJson = JSON.stringify(manifest, null, 2)
+      fs.writeFileSync(path.resolve(buildDir, "manifest.json"), manifestJson)
+
+      if (shouldZip) {
+        const zipName = `${manifest.id}-${pkg.version}.zip`
+        const filesToZip = ["manifest.json", bundleFile]
+
+        if (fs.existsSync(path.resolve(buildDir, "api.js"))) {
+          filesToZip.push("api.js")
+        }
+
+        const migrationsDest = path.resolve(buildDir, "migrations")
+        if (fs.existsSync(migrationsDest)) {
+          filesToZip.push("migrations")
+        }
+        const seedsDest = path.resolve(buildDir, "seeds")
+        if (fs.existsSync(seedsDest)) {
+          filesToZip.push("seeds")
+        }
+
+        execFileSync("tar", ["-a", "-cf", zipName, ...filesToZip], {
+          cwd: buildDir,
+          stdio: "inherit"
+        })
+        console.log(`Build Complete: ${manifest.id} v${pkg.version} → ${zipName}`)
+      }
+    }
+  }
+}
+
+export interface JchatAddonPluginOptions {
+  manifest: AddonManifest
+  zip?: boolean
+  signingPrivateKey?: string
+  /**
+   * Embed Tailwind CSS output into the JS bundle and scope it to the addon's DOM container.
+   * Defaults to `true`. Set to `false` only if the addon has no CSS.
+   */
+  css?: boolean
+}
+
+export function createAddonServerBuildArguments(
+  entryPath: string,
+  outputPath: string,
+  developmentBuild: boolean
+): string[] {
+  return [
+    "build",
+    entryPath,
+    "--target=bun",
+    "--format=esm",
+    `--outfile=${outputPath}`,
+    developmentBuild ? "--sourcemap=external" : "--minify"
+  ]
+}
+
+export function signAddonManifest(
+  manifest: AddonManifest,
+  files: readonly { path: string; contents: Buffer }[],
+  privateKey: string
+): AddonManifest {
+  if (!manifest.publisher?.id) throw new Error("Signed addons require manifest.publisher.id")
+  const unsigned: AddonManifest = {
+    ...manifest,
+    signature: { algorithm: "rsa-sha256", digest: "", value: "" }
+  }
+  const hash = crypto.createHash("sha256")
+  for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
+    hash.update(file.path)
+    hash.update("\0")
+    hash.update(file.path === "manifest.json" ? stableStringify(unsigned) : file.contents)
+    hash.update("\0")
+  }
+  const digest = hash.digest("hex")
+  return {
+    ...unsigned,
+    signature: {
+      algorithm: "rsa-sha256",
+      digest,
+      value: crypto.sign("sha256", Buffer.from(digest), privateKey).toString("base64url")
+    }
+  }
+}
+
+export function requireAddonSigningKey(
+  signingPrivateKey: string | undefined,
+  developmentBuild: boolean
+): string | undefined {
+  if (signingPrivateKey) return signingPrivateKey
+  if (developmentBuild) return undefined
+  throw new Error("Database-bearing addon builds require JCHAT_ADDON_SIGNING_PRIVATE_KEY")
+}
+
+function embedCssIntoBundle(buildDir: string, addonId: string): void {
+  const files = fs.readdirSync(buildDir)
+  const cssFile = files.find((f) => f.endsWith(".css"))
+  const jsFile = files.find((f) => f.includes("ui") && f.endsWith(".js"))
+
+  if (!cssFile || !jsFile) return
+
+  const cssPath = path.join(buildDir, cssFile)
+  const jsPath = path.join(buildDir, jsFile)
+  let css = fs.readFileSync(cssPath, "utf-8")
+  const js = fs.readFileSync(jsPath, "utf-8")
+
+  if (css.length < 10) {
+    css = ""
+  } else {
+    // Strip out the host theme root and dark definitions to allow the addon to inherit them
+    css = css.replace(/:root\s*\{[^}]+\}/g, "")
+    css = css.replace(/\.dark\s*\{[^}]+\}/g, "")
+    css = css.replace(/\[data-theme=[^\]]+\]\s*\{[^}]+\}/g, "")
+    css = css.replace(/\.dark\s*\[data-theme=[^\]]+\]\s*\{[^}]+\}/g, "")
+
+    // Inject a base reset so addons don't default to currentColor (white in dark mode)
+    const resetCss = `*, ::before, ::after { border-color: var(--border); }`
+    css = `@scope (#addon-${addonId}) {\n${resetCss}\n${css}\n}`
+  }
+
+  // Inject the CSS into the head. Since addon styles are scoped,
+  // we don't need to force them to the top of the head.
+  const injection = `
+(function() {
+  if (typeof document !== 'undefined' && ${JSON.stringify(css)}.length > 0) {
+    const style = document.createElement('style');
+    style.type = 'text/css';
+    style.textContent = ${JSON.stringify(css)};
+    document.head.appendChild(style);
+  }
+})();
+`
+  fs.writeFileSync(jsPath, injection + js)
+  try {
+    fs.unlinkSync(cssPath)
+  } catch {
+    // ignore ENOENT if another plugin or build process already removed it
+  }
+}
+
+function stableStringify(value: unknown): string {
+  const sortValue = (child: unknown): unknown => {
+    if (Array.isArray(child)) return child.map(sortValue)
+    if (child && typeof child === "object") {
+      return Object.fromEntries(
+        Object.entries(child)
+          .sort(([left], [right]) => left.localeCompare(right))
+          .map(([key, nested]) => [key, sortValue(nested)])
+      )
+    }
+    return child
+  }
+  return JSON.stringify(sortValue(value))
+}