feat: make each plugin an npm workspace built by a termix-plugin CLI

packages/plugin-sdk/cli/commands/build.mjs

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as esbuild from "esbuild";
+import { BACKEND_EXTERNALS, FRONTEND_EXTERNALS } from "../lib/externals.mjs";
+import { legacyCoreImports } from "../lib/legacy-core-imports.mjs";
+import { readManifest, resolveEntry, copyDir } from "../lib/plugin-dir.mjs";
+
+const BACKEND_ENTRIES = [
+  "src/backend/index.ts",
+  "src/backend/index.mjs",
+  "src/backend/index.js",
+];
+const FRONTEND_ENTRIES = [
+  "src/frontend/index.tsx",
+  "src/frontend/index.ts",
+  "src/frontend/index.mjs",
+  "src/frontend/index.js",
+];
+
+export async function build({ cwd }) {
+  const manifest = readManifest(cwd);
+  const pluginId = manifest.id ?? path.basename(cwd);
+  const outDir = path.join(cwd, "dist");
+
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const backendEntry = resolveEntry(cwd, BACKEND_ENTRIES);
+  if (!backendEntry) {
+    throw new Error(
+      `${pluginId}: no backend entry (looked for ${BACKEND_ENTRIES.join(", ")})`,
+    );
+  }
+
+  await esbuild.build({
+    entryPoints: [backendEntry],
+    outfile: path.join(outDir, "backend.js"),
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node22",
+    sourcemap: true,
+    logLevel: "warning",
+    external: BACKEND_EXTERNALS,
+    plugins: [legacyCoreImports({ pluginId, platform: "node" })],
+  });
+
+  const frontendEntry = resolveEntry(cwd, FRONTEND_ENTRIES);
+  if (frontendEntry) {
+    await esbuild.build({
+      entryPoints: [frontendEntry],
+      outfile: path.join(outDir, "frontend.js"),
+      bundle: true,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      jsx: "automatic",
+      sourcemap: true,
+      logLevel: "warning",
+      external: FRONTEND_EXTERNALS,
+      plugins: [legacyCoreImports({ pluginId, platform: "browser" })],
+    });
+  }
+
+  copyDir(path.join(cwd, "locales"), path.join(outDir, "locales"));
+  copyDir(path.join(cwd, "migrations"), path.join(outDir, "migrations"));
+
+  console.log(`built ${pluginId}`);
+}

packages/plugin-sdk/cli/commands/pack.mjs

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+import { create } from "tar";
+import { readManifest } from "../lib/plugin-dir.mjs";
+
+/** Everything a server needs to run the plugin, and nothing else. D3 signs it. */
+const CONTENTS = [
+  "manifest.json",
+  "dist",
+  "locales",
+  "migrations",
+  "README.md",
+  "CHANGELOG.md",
+];
+
+export async function pack({ cwd }) {
+  const manifest = readManifest(cwd);
+  const pluginId = manifest.id ?? path.basename(cwd);
+  const version = manifest.version ?? "0.0.0";
+
+  if (!fs.existsSync(path.join(cwd, "dist", "backend.js"))) {
+    throw new Error(`${pluginId}: nothing built. Run termix-plugin build.`);
+  }
+
+  const files = CONTENTS.filter((entry) =>
+    fs.existsSync(path.join(cwd, entry)),
+  );
+  const outfile = path.join(cwd, `${pluginId}-${version}.tgz`);
+
+  await create({ gzip: true, cwd, file: outfile }, files);
+
+  console.log(`packed ${path.basename(outfile)}`);
+}

packages/plugin-sdk/cli/commands/test.mjs

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { createRequire } from "node:module";
+
+/**
+ * Runs vitest through its own entry rather than the npx shim, so no shell is
+ * involved and paths with spaces work the same on every platform.
+ */
+export async function test({ cwd, args }) {
+  const require = createRequire(import.meta.url);
+
+  let vitestBin;
+  try {
+    // vitest.mjs is the package bin, not an exported subpath, so resolve the
+    // manifest and walk to it.
+    const manifest = require.resolve("vitest/package.json", { paths: [cwd] });
+    vitestBin = path.join(path.dirname(manifest), "vitest.mjs");
+  } catch {
+    throw new Error(
+      "vitest is not installed. Run npm install at the repo root.",
+    );
+  }
+
+  const result = spawnSync(
+    process.execPath,
+    [vitestBin, "run", "--config", "vitest.config.ts", ...args],
+    { cwd, stdio: "inherit" },
+  );
+
+  if (result.status !== 0) {
+    throw new Error(`vitest exited with ${result.status}`);
+  }
+}

packages/plugin-sdk/cli/commands/validate.mjs

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readManifest } from "../lib/plugin-dir.mjs";
+
+/**
+ * The manifest rules live in src/manifest.ts, which the server uses too, so
+ * there is one implementation rather than a copy here that drifts.
+ */
+async function loadParseManifest() {
+  const entry = new URL("../../dist/manifest.js", import.meta.url);
+  if (!fs.existsSync(fileURLToPath(entry))) {
+    throw new Error("The plugin SDK is not built yet. Run: npm run build:sdk");
+  }
+  const mod = await import(entry.href);
+  return mod.parseManifest;
+}
+
+export async function validate({ cwd }) {
+  const raw = readManifest(cwd);
+  const parseManifest = await loadParseManifest();
+  const { errors } = parseManifest(raw);
+
+  const problems = [...errors];
+
+  // The manifest names files. They have to be there.
+  const referenced = [
+    raw.backend ?? "dist/backend.js",
+    raw.frontend ?? "dist/frontend.js",
+    raw.locales ?? "locales",
+  ];
+  for (const rel of referenced) {
+    if (!fs.existsSync(path.join(cwd, rel))) {
+      problems.push(`manifest references ${rel}, which does not exist`);
+    }
+  }
+
+  if (problems.length > 0) {
+    for (const problem of problems) console.error(`  ${problem}`);
+    throw new Error(`${raw.id ?? path.basename(cwd)}: manifest is not valid.`);
+  }
+
+  console.log(`ok  ${raw.id ?? path.basename(cwd)}`);
+}