@cosmicdrift/kumiko-dev-server 0.16.0 → 0.19.0

package/bin/kumiko-schema.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+// Shipped, app-facing schema-migration CLI: `kumiko-schema generate|apply|baseline|status`.
+//
+// Self-contained — delegates to the framework's runSchemaCli core, so apps run
+// migrations without the full dev `kumiko` CLI (which eager-loads ts-morph-heavy
+// dev commands not shipped to apps). Run from the app workspace root:
+//
+//   bunx kumiko-schema generate init
+//   bunx kumiko-schema apply
+//   bunx kumiko-schema baseline   # adopt an existing DB (tables already exist)
+//   bunx kumiko-schema status
+
+import { runSchemaCli } from "@cosmicdrift/kumiko-framework/schema-cli";
+
+// biome-ignore lint/suspicious/noConsole: CLI output is the feature.
+const out = { log: (l: string) => console.log(l), err: (l: string) => console.error(l) };
+const appCwd = process.env["INIT_CWD"] ?? process.cwd();
+const code = await runSchemaCli(process.argv.slice(2), appCwd, out);
+process.exit(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.16.0",
+  "version": "0.19.0",
   "description": "Development server bootstrap for Kumiko apps. Bundles the client, mints dev-JWTs, injects the resolved AppSchema, and seeds an admin. Not for production.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -42,6 +42,7 @@
   "bin": {
     "kumiko-build": "./bin/kumiko-build.ts",
     "kumiko-dev": "./bin/kumiko-dev.ts",
+    "kumiko-schema": "./bin/kumiko-schema.ts",
     "kumiko-schema-check": "./bin/kumiko-schema-check.ts"
   },
   "dependencies": {

package/src/__tests__/classify-change.test.ts

@@ -50,7 +50,7 @@ describe("classifyChange", () => {
   });
 
   test("Integration-Test → ignore (würde sonst Schema-Restart auslösen)", () => {
-    expect(classifyChange("/abs/samples/foo/src/feature.integration.ts")).toBe("ignore");
+    expect(classifyChange("/abs/samples/foo/src/feature.integration.test.ts")).toBe("ignore");
   });
 
   test("E2E-Test → ignore", () => {

package/src/__tests__/{create-kumiko-server.integration.ts → create-kumiko-server.integration.test.ts}

@@ -137,12 +137,13 @@ describe("createKumikoServer", () => {
     expect(res.headers.get("content-type") ?? "").not.toMatch(/text\/event-stream/);
   });
 
-  test("Server-Instanz ist undefined unter Node (vitest)", async () => {
-    // Sanity check: unter Bun wäre .server gesetzt, unter Node
-    // (wo dieser Test läuft) muss er undefined sein, sonst hätten
-    // wir eine falsche Bun-Detection.
+  test("Server-Instanz unter Bun gesetzt, unter Node undefined", async () => {
     const h = await boot();
-    expect(h.server).toBeUndefined();
+    if (typeof Bun !== "undefined") {
+      expect(h.server).toBeDefined();
+    } else {
+      expect(h.server).toBeUndefined();
+    }
   });
 });
 

package/src/__tests__/resolve-tailwind-cli.test.ts

@@ -3,7 +3,7 @@
 // kein Bun → undefined, Package nicht installiert → undefined.
 
 import { describe, expect, test } from "bun:test";
-import { resolveTailwindCli } from "../resolve-tailwind-cli";
+import { canResolveTailwindStylesheet, resolveTailwindCli } from "../resolve-tailwind-cli";
 
 describe("resolveTailwindCli", () => {
   test("ohne Bun-Resolver → undefined (silent skip)", () => {
@@ -47,3 +47,35 @@ describe("resolveTailwindCli", () => {
     expect(calls).toEqual([{ id: "@tailwindcss/cli/package.json", from: "/some/working/dir" }]);
   });
 });
+
+describe("canResolveTailwindStylesheet", () => {
+  test("tailwindcss resolvable from entry dir → true", () => {
+    const out = canResolveTailwindStylesheet("/repo/packages/app/src/styles.css", {
+      bun: {
+        resolveSync: (id, from) => {
+          if (id === "tailwindcss" && from === "/repo/packages/app/src") {
+            return "/repo/node_modules/tailwindcss/index.css";
+          }
+          throw new Error("not found");
+        },
+      },
+      cwd: "/repo/packages/app",
+    });
+    expect(out).toBe(true);
+  });
+
+  test("tailwindcss not resolvable from entry dir → false", () => {
+    const out = canResolveTailwindStylesheet(
+      "/cache/@cosmicdrift/kumiko-renderer-web/src/styles.css",
+      {
+        bun: {
+          resolveSync: () => {
+            throw new Error("not found");
+          },
+        },
+        cwd: "/tmp/minimal-fixture",
+      },
+    );
+    expect(out).toBe(false);
+  });
+});

package/src/__tests__/{run-prod-app.integration.ts → run-prod-app.integration.test.ts}

@@ -491,40 +491,21 @@ describe("runProdApp", () => {
     expect(res.status).toBe(200);
   });
 
-  test("Hard Boot-Gate: pending Migration im Journal → SchemaDriftError, kein Boot", async () => {
-    // Schreibt ein synthetisches Migration-Dir mit einer Migration die
-    // nie applied wurde. runProdApp soll mit SchemaDriftError abbrechen
-    // bevor irgendetwas anderes initialisiert wird.
-    const { mkdir } = await import("node:fs/promises");
+  test("Hard Boot-Gate: pending kumiko-Migration → SchemaDriftError, kein Boot", async () => {
+    // Synthetisches kumiko/migrations-Dir mit einer checked-in Migration die
+    // nie applied wurde (kein _kumiko_migrations-Eintrag). runProdApp soll mit
+    // SchemaDriftError abbrechen bevor irgendetwas anderes initialisiert wird.
     const driftDir = await mkdtemp(join(tmpdir(), "kumiko-drift-boot-"));
     tempDirs.push(driftDir);
-    await mkdir(join(driftDir, "meta"), { recursive: true });
     await writeFile(
-      join(driftDir, "meta", "_journal.json"),
-      JSON.stringify({
-        version: "7",
-        dialect: "postgresql",
-        entries: [
-          {
-            idx: 0,
-            version: "7",
-            when: 1700000000000,
-            tag: "0000_pending_migration",
-            breakpoints: true,
-          },
-        ],
-      }),
+      join(driftDir, "0001_pending.sql"),
+      `CREATE TABLE "never_created_table" ("id" uuid PRIMARY KEY);`,
     );
     await writeFile(
-      join(driftDir, "meta", "0000_snapshot.json"),
+      join(driftDir, ".snapshot.json"),
       JSON.stringify({
-        tables: {
-          "public.never_created_table": {
-            schema: "",
-            name: "never_created_table",
-            columns: { id: { name: "id", type: "uuid", primaryKey: true, notNull: true } },
-          },
-        },
+        version: 1,
+        tables: [{ tableName: "never_created_table", columns: [] }],
       }),
     );
 

package/src/build-prod-bundle.ts

@@ -44,6 +44,7 @@ import { existsSync, readdirSync } from "node:fs";
 import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { canResolveTailwindStylesheet, resolveTailwindCli } from "./resolve-tailwind-cli";
 
 // Bun-Runtime-Check als module-level Konstante: alle Build-Schritte
 // (Tailwind via Bun.spawn, Client-Bundle via Bun.build, Stylesheet-
@@ -138,7 +139,7 @@ export async function buildProdBundle(options: BuildProdBundleOptions = {}): Pro
   //    der client.tsx ein "import './foo.css'" macht — den Fall lassen
   //    wir hier raus, Tailwind ist die einzige CSS-Quelle).
   if (stylesheet) {
-    const css = await runTailwindOnce(stylesheet);
+    const css = await runTailwindOnce(stylesheet, cwd);
     const hash = shortHash(css);
     const filename = `styles-${hash}.css`;
     await writeFile(join(assetsDir, filename), css);
@@ -302,9 +303,14 @@ function resolveStylesheetEntry(
 
   if (!hasBun) return undefined;
   try {
-    return (
+    const resolved = (
       globalThis as { Bun: { resolveSync: (id: string, from: string) => string } }
     ).Bun.resolveSync("@cosmicdrift/kumiko-renderer-web/styles.css", cwd);
+    const bun = (globalThis as { Bun: { resolveSync: (id: string, from: string) => string } }).Bun;
+    if (!canResolveTailwindStylesheet(resolved, { bun, cwd })) {
+      return undefined;
+    }
+    return resolved;
   } catch {
     return undefined;
   }
@@ -323,18 +329,30 @@ export function discoverHtmlTemplate(cwd: string): string | undefined {
 // Build steps
 // ---------------------------------------------------------------------------
 
-async function runTailwindOnce(entry: string): Promise<string> {
+async function runTailwindOnce(entry: string, cwd: string): Promise<string> {
   if (!hasBun) {
     throw new Error(
       "[kumiko build] Tailwind one-shot requires Bun (Bun.spawn) — run via `bun run …` or `yarn kumiko build`.",
     );
   }
+  const bunResolver = (globalThis as { Bun: { resolveSync: (id: string, from: string) => string } })
+    .Bun;
+  const cliPath = resolveTailwindCli({ bun: bunResolver, cwd });
+  if (cliPath === undefined) {
+    throw new Error(
+      "[kumiko build] @tailwindcss/cli nicht auflösbar — `bun install` im App-Root ausführen.",
+    );
+  }
+  if (!canResolveTailwindStylesheet(entry, { bun: bunResolver, cwd })) {
+    throw new Error(
+      `[kumiko build] tailwindcss nicht auflösbar für ${entry} — peer dependency fehlt am Stylesheet-Ort.`,
+    );
+  }
   const tmpDir = await mkdtemp(join(tmpdir(), "kumiko-build-tw-"));
   const outPath = join(tmpDir, "styles.css");
-  // --minify: Tailwind-CLI default ist NICHT minified. Symmetric zum
-  // Bun.build minify-Flag — sonst ist das CSS in dist/ ~30 % größer als
-  // nötig (Whitespace, Kommentare, Newlines).
-  const proc = Bun.spawn(["bunx", "@tailwindcss/cli", "-i", entry, "-o", outPath, "--minify"], {
+  const bunPath = process.argv[0] ?? "bun";
+  const proc = Bun.spawn([bunPath, "run", cliPath, "-i", entry, "-o", outPath, "--minify"], {
+    cwd,
     stdout: "inherit",
     stderr: "inherit",
   });

package/src/create-kumiko-server.ts

@@ -30,7 +30,7 @@ import {
   TestUsers,
 } from "@cosmicdrift/kumiko-framework/stack";
 import { injectSchema } from "./inject-schema";
-import { resolveTailwindCli } from "./resolve-tailwind-cli";
+import { canResolveTailwindStylesheet, resolveTailwindCli } from "./resolve-tailwind-cli";
 import { buildBunServeOptions } from "./run-prod-app";
 import { tryHonoFirst } from "./try-hono-first";
 
@@ -362,7 +362,13 @@ export function classifyChange(filename: string): "restart" | "hot-reload" | "ig
   if (!filename.endsWith(".ts") && !filename.endsWith(".tsx")) return "ignore";
   if (filename.includes("__tests__")) return "ignore";
   if (filename.endsWith(".test.ts") || filename.endsWith(".test.tsx")) return "ignore";
-  if (filename.endsWith(".integration.ts") || filename.endsWith(".e2e.ts")) return "ignore";
+  if (
+    filename.endsWith(".integration.ts") ||
+    filename.endsWith(".integration.test.ts") ||
+    filename.endsWith(".e2e.ts")
+  ) {
+    return "ignore";
+  }
   // Plattformpfad-agnostisch: prüfen auf POSIX und Windows-Trenner.
   // Wir matchen sowohl `<sep><dir><sep>` als auch trailing-`<sep><dir>`
   // (für Watcher-Filenames die als relativer Pfad ankommen).
@@ -465,9 +471,14 @@ export function resolveStylesheet(options: CreateKumikoServerOptions): string |
     return undefined;
   }
   try {
-    return (
+    const resolved = (
       globalThis as { Bun: { resolveSync: (id: string, from: string) => string } }
     ).Bun.resolveSync("@cosmicdrift/kumiko-renderer-web/styles.css", process.cwd());
+    const bun = (globalThis as { Bun: { resolveSync: (id: string, from: string) => string } }).Bun;
+    if (!canResolveTailwindStylesheet(resolved, { bun, cwd: process.cwd() })) {
+      return undefined;
+    }
+    return resolved;
   } catch (err) {
     logError(
       "[kumiko-server] couldn't auto-resolve @cosmicdrift/kumiko-renderer-web/styles.css — " +

package/src/resolve-tailwind-cli.ts

@@ -7,7 +7,7 @@
 // testbar (Bun-Branch + Resolve-Fail-Branch) ohne den Server zu
 // booten.
 
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 
 type BunResolver = { resolveSync: (id: string, from: string) => string };
 
@@ -26,3 +26,20 @@ export function resolveTailwindCli(deps: ResolveTailwindCliDeps): string | undef
     return undefined;
   }
 }
+
+/** Tailwind v4 resolves `@import "tailwindcss"` relative to the entry
+ *  CSS file. Skip renderer-web fallback (or fail build) when peer deps
+ *  aren't resolvable from that directory — e.g. Bun cache copies of
+ *  `@cosmicdrift/kumiko-renderer-web` outside a hoisted node_modules tree. */
+export function canResolveTailwindStylesheet(
+  entryCss: string,
+  deps: ResolveTailwindCliDeps,
+): boolean {
+  if (deps.bun === undefined) return false;
+  try {
+    deps.bun.resolveSync("tailwindcss", dirname(entryCss));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/run-prod-app.ts

@@ -69,7 +69,10 @@ import {
   createSeedMigrationContext,
   runPendingSeedMigrations,
 } from "@cosmicdrift/kumiko-framework/es-ops";
-import { assertSchemaCurrent, SchemaDriftError } from "@cosmicdrift/kumiko-framework/migrations";
+import {
+  assertKumikoSchemaCurrent,
+  SchemaDriftError,
+} from "@cosmicdrift/kumiko-framework/migrations";
 import {
   createDispatcher,
   createEntityCache,
@@ -369,7 +372,7 @@ export type RunProdAppOptions = {
    *  werden. CSP-Header pro Host können zusätzlich Asset-Pfade
    *  einschränken. */
   readonly hostDispatch?: HostDispatchFn;
-  /** Pfad zu drizzle/migrations für den Boot-Gate. Default "./drizzle/
+  /** Pfad zu kumiko/migrations für den Boot-Gate. Default "./kumiko/
    *  migrations" relativ zum process-cwd (wo die App gestartet wird —
    *  bei Container-Deploys typischerweise der App-Workspace-Root, weil
    *  WORKDIR im Dockerfile dorthin zeigt). Boot wirft SchemaDriftError
@@ -592,20 +595,20 @@ export async function runProdApp(options: RunProdAppOptions): Promise<ProdAppHan
     }
   }
 
-  // 5. Schema-Drift-Gate. Drizzle-kit migrate (yarn kumiko migrate apply)
-  //    läuft als CI-Step VOR dem Container-Rollout. Boot prüft hier nur:
-  //      (a) Alle Migrations aus drizzle/migrations/meta/_journal.json
-  //          sind in __drizzle_migrations applied
-  //      (b) Alle erwarteten Tabellen existieren physisch
+  // 5. Schema-Drift-Gate (drizzle-frei, kumiko/migrations). `kumiko schema
+  //    apply` läuft als Deploy-Step VOR dem Container-Rollout. Boot prüft nur:
+  //      (a) Alle Migrations aus kumiko/migrations/*.sql sind in
+  //          _kumiko_migrations applied (+ checksum unverändert)
+  //      (b) Alle Tabellen aus kumiko/migrations/.snapshot.json existieren
   //    Drift = Boot-Error mit klarer Meldung (kein Auto-Heal — mehrere
-  //    Container-Replicas würden sonst race-conditionen beim ALTER TABLE
-  //    fahren). Opt-out via `migrations: false` für custom Schema-Setups.
+  //    Container-Replicas würden sonst race-conditionen fahren). Opt-out via
+  //    `migrations: false` für custom Schema-Setups.
   if (options.migrations !== false) {
-    const migrationsDir = options.migrations?.dir ?? "./drizzle/migrations";
+    const migrationsDir = options.migrations?.dir ?? "./kumiko/migrations";
     // biome-ignore lint/suspicious/noConsole: boot-time progress hint
     console.log(`[runProdApp] checking schema drift (${migrationsDir})…`);
     try {
-      await assertSchemaCurrent(db, migrationsDir);
+      await assertKumikoSchemaCurrent(db, migrationsDir);
     } catch (err) {
       if (err instanceof SchemaDriftError) {
         // biome-ignore lint/suspicious/noConsole: terminal error message