@cosmicdrift/kumiko-dev-server 0.326.1 → 0.328.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-dev-server",
-  "version": "0.326.1",
+  "version": "0.328.0",
   "description": "Dev-tooling for Kumiko apps: local dev-server bootstrap (runDevApp), scaffolding, codegen. Its compose-stacks/env-schema subpaths are consumed at prod boot too — see @cosmicdrift/kumiko-server-runtime for the prod runner itself.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -60,10 +60,10 @@
     "kumiko-upgrade": "./bin/kumiko-upgrade.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.326.1",
-    "@cosmicdrift/kumiko-framework": "0.326.1",
-    "@cosmicdrift/kumiko-headless": "0.326.1",
-    "@cosmicdrift/kumiko-server-runtime": "0.326.1",
+    "@cosmicdrift/kumiko-bundled-features": "0.328.0",
+    "@cosmicdrift/kumiko-framework": "0.328.0",
+    "@cosmicdrift/kumiko-headless": "0.328.0",
+    "@cosmicdrift/kumiko-server-runtime": "0.328.0",
     "ts-morph": "^28.0.0"
   },
   "publishConfig": {

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

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -927,6 +927,55 @@ describe("createKumikoServer — public/ static files", () => {
   });
 });
 
+describe("createKumikoServer — renderer-web fonts under /assets/kumiko/fonts", () => {
+  const FONTS_SOURCE_DIR = join(import.meta.dir, "../../../renderer-web/src/fonts");
+
+  async function withFixtureCwd(run: () => Promise<void>): Promise<void> {
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), "kumiko-fonts-")));
+    const cwdBefore = process.cwd();
+    process.chdir(tmpDir);
+    try {
+      handle = await createKumikoServer({
+        features: [probeFeature],
+        port: 0,
+        installSignalHandlers: false,
+      });
+      await run();
+    } finally {
+      process.chdir(cwdBefore);
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  }
+
+  test("GET on a shipped font → 200, font/woff2, the file's bytes", async () => {
+    await withFixtureCwd(async () => {
+      const res = await handle?.fetch(
+        new Request("http://localhost/assets/kumiko/fonts/ibm-plex-sans-latin-400.woff2"),
+      );
+      expect(res?.status).toBe(200);
+      expect(res?.headers.get("content-type")).toBe("font/woff2");
+      const expected = readFileSync(join(FONTS_SOURCE_DIR, "ibm-plex-sans-latin-400.woff2"));
+      expect(Buffer.from(await (res as Response).arrayBuffer()).equals(expected)).toBe(true);
+    });
+  });
+
+  test("unknown names and traversal attempts → 404, never file content", async () => {
+    await withFixtureCwd(async () => {
+      for (const path of [
+        "/assets/kumiko/fonts/nope.woff2",
+        "/assets/kumiko/fonts/OFL.txt",
+        "/assets/kumiko/fonts/../styles.css",
+        "/assets/kumiko/fonts/..%2fstyles.css",
+        "/assets/kumiko/fonts/%2e%2e%2f%2e%2e%2fpackage.json",
+        "/assets/kumiko/fonts/ibm-plex-sans-latin-400.woff2/x",
+      ]) {
+        const res = await handle?.fetch(new Request(`http://localhost${path}`));
+        expect(res?.status, path).toBe(404);
+      }
+    });
+  });
+});
+
 describe("createKumikoServer — real Bun.serve socket resolves the client IP (fw#3260 addendum)", () => {
   // Every other test in this file drives h.fetch()/handle.fetch() directly,
   // bypassing Bun.serve's real TCP socket entirely — none of them can catch

package/src/__tests__/setup-test-stack-job-run-logger.integration.test.ts

@@ -0,0 +1,72 @@
+// setupTestStackFromFeatures wires prod's job run-logger by default: a job
+// declared with tenantVisibleFailure records its final failure per tenant, and
+// drainJobs() only rejects after that row is written.
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createJobsFeature, JobQueries } from "@cosmicdrift/kumiko-bundled-features/jobs";
+import { defineFeature, defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { createTestUser, type TestStack, testTenantId } from "@cosmicdrift/kumiko-framework/stack";
+import * as z from "zod";
+import { setupTestStackFromFeatures } from "../setup-test-stack-from-features";
+
+const FAILURE_KEY = "app:errors.generationFailed";
+const PROVIDER_MESSAGE = "provider 429: prompt with customer data rejected";
+
+const tenantA = testTenantId(1);
+const tenantB = testTenantId(2);
+const userA = createTestUser({ id: 1, tenantId: tenantA, roles: ["Admin"] });
+const userB = createTestUser({ id: 2, tenantId: tenantB, roles: ["Admin"] });
+
+const appFeature = defineFeature("app", (r) => {
+  r.writeHandler(
+    defineWriteHandler({
+      name: "generate",
+      description: "Test-only: starts a job that always fails.",
+      schema: z.object({ campaignId: z.string() }),
+      access: { roles: ["Admin"] },
+      handler: async (event) => ({ isSuccess: true as const, data: { ...event.payload } }),
+    }),
+  );
+  r.job(
+    "generateTexts",
+    {
+      trigger: { on: "app:write:generate" },
+      retries: 0,
+      tenantVisibleFailure: { messageKey: FAILURE_KEY, subjectFields: ["campaignId"] },
+    },
+    async () => {
+      throw new Error(PROVIDER_MESSAGE);
+    },
+  );
+});
+
+type FailureRow = { readonly jobName: string; readonly messageKey: string };
+
+let stack: TestStack;
+
+beforeAll(async () => {
+  stack = await setupTestStackFromFeatures([appFeature, createJobsFeature()], {
+    jobs: { consumerLane: "worker" },
+  });
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+describe("setupTestStackFromFeatures({ jobs }) run-logger default", () => {
+  test("a failed tenant-visible job is readable by its tenant only, once drainJobs() rejects", async () => {
+    await stack.http.writeOk("app:write:generate", { campaignId: "campaign-1" }, userA);
+
+    await expect(stack.drainJobs()).rejects.toThrow(/app:job:generate-texts/);
+
+    const own = await stack.http.queryOk<{ rows: FailureRow[] }>(JobQueries.failures, {}, userA);
+    expect(own.rows).toHaveLength(1);
+    expect(own.rows[0]?.jobName).toBe("app:job:generate-texts");
+    expect(own.rows[0]?.messageKey).toBe(FAILURE_KEY);
+    expect(JSON.stringify(own)).not.toContain(PROVIDER_MESSAGE);
+
+    const other = await stack.http.queryOk<{ rows: FailureRow[] }>(JobQueries.failures, {}, userB);
+    expect(other.rows).toHaveLength(0);
+  });
+});

package/src/changes.json

@@ -1,4 +1,10 @@
 [
+  {
+    "version": "0.328.0",
+    "type": "improvement",
+    "title": "Dev server serves the renderer-web fonts",
+    "detail": "GET `/assets/kumiko/fonts/<file>.woff2` streams the packaged IBM Plex files with `font/woff2` and a one day cache header. Names outside the allowlist answer 404."
+  },
   {
     "version": "0.323.0",
     "type": "improvement",

package/src/create-kumiko-server.ts

@@ -55,6 +55,11 @@ import {
   makeDispatchSystemWrite,
   type SystemWireDeps,
 } from "@cosmicdrift/kumiko-server-runtime/extra-routes-deps";
+import {
+  RENDERER_WEB_FONT_FILE_PATTERN,
+  RENDERER_WEB_FONTS_URL_PREFIX,
+  resolveRendererWebFontsDir,
+} from "@cosmicdrift/kumiko-server-runtime/renderer-web-fonts";
 import {
   canResolveTailwindStylesheet,
   resolveTailwindCli,
@@ -72,8 +77,8 @@ import {
 // Bun.serve + real sockets.
 const hasBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
 
-// Bun.serve returns a parametrised Server<WebSocketData>; we don't
-// touch WebSockets here, so the narrow `unknown` binding is plenty.
+// Bun.serve returns a parametrised Server<WebSocketData>; nothing here reads
+// the socket data, so the narrow `unknown` binding is plenty.
 // `Bun` isn't declared in Node types, so we fall back to `unknown`
 // and only resolve the type when Bun is actually around.
 type BunServer = typeof Bun extends undefined ? unknown : ReturnType<typeof Bun.serve>;
@@ -458,6 +463,7 @@ const PUBLIC_FILE_MIME_TYPES = new Map<string, string>([
   ["txt", "text/plain; charset=utf-8"],
   ["xml", "application/xml; charset=utf-8"],
   ["webmanifest", "application/manifest+json"],
+  ["woff2", "font/woff2"],
 ]);
 
 function publicFileMimeType(filePath: string): string {
@@ -1081,6 +1087,9 @@ export async function createKumikoServer(
   // App-root convention (same as expandWatchPatterns/resolveStylesheet above):
   // process.cwd() is the app workspace, so public/ is its static asset dir.
   const publicDir = resolve(process.cwd(), "public");
+  // The app's cwd first, this package's own location as fallback (the cwd may
+  // not have renderer-web installed, e.g. a fixture dir).
+  const rendererWebFontsDir = resolveRendererWebFontsDir([process.cwd(), import.meta.dir]);
 
   const handleFetch = async (req: Request, socketAddress?: string): Promise<Response> => {
     const url = new URL(req.url);
@@ -1122,6 +1131,26 @@ export async function createKumikoServer(
       }
     }
 
+    if (url.pathname.startsWith(RENDERER_WEB_FONTS_URL_PREFIX) && req.method === "GET") {
+      const fontFile = url.pathname.slice(RENDERER_WEB_FONTS_URL_PREFIX.length);
+      // The allowlist pattern excludes "/", "." segments and encoded traversal.
+      if (rendererWebFontsDir === undefined || !RENDERER_WEB_FONT_FILE_PATTERN.test(fontFile)) {
+        return new Response("not found", { status: 404 });
+      }
+      try {
+        const bytes = await readFile(join(rendererWebFontsDir, fontFile));
+        // @cast-boundary Buffer satisfies BodyInit at runtime, bun-types just doesn't say so.
+        return new Response(bytes as unknown as BodyInit, {
+          headers: { "Content-Type": "font/woff2", "Cache-Control": "public, max-age=86400" },
+        });
+      } catch (err) {
+        if ((err as { code?: string }).code === "ENOENT") {
+          return new Response("not found", { status: 404 });
+        }
+        throw err;
+      }
+    }
+
     if (url.pathname === "/styles.css" && req.method === "GET") {
       if (stylesheetPath === undefined) return new Response("no stylesheet", { status: 404 });
       const css = await readFile(stylesheetPath, "utf-8");
@@ -1239,7 +1268,10 @@ export async function createKumikoServer(
   // (idleTimeout: 0). Spec-Test in run-prod-app-spec.test.ts pinst das.
   const server = hasBun
     ? (globalThis as { Bun: { serve: (opts: unknown) => BunServer } }).Bun.serve(
-        buildBunServeOptions(port, handleFetch, resolveDerivedMaxRequestBodySize(stack.registry)),
+        buildBunServeOptions(port, handleFetch, resolveDerivedMaxRequestBodySize(stack.registry), {
+          upgradeFetch: async (req, env) =>
+            stripNoRouteMatchHeader(await stack.app.fetch(req, env)),
+        }),
       )
     : undefined;
 

package/src/setup-test-stack-from-features.ts

@@ -12,6 +12,7 @@ import {
   type TestStack,
   type TestStackOptions,
 } from "@cosmicdrift/kumiko-framework/stack";
+import { jobRunLoggerCallbacks } from "@cosmicdrift/kumiko-server-runtime/boot/job-run-logger";
 import {
   type ComposeFeaturesOptions,
   composeFeatures,
@@ -59,8 +60,20 @@ export async function setupTestStackFromFeatures(
   const features = composeFeatures(appFeatures, { includeBundled, authOptions });
   const extraContext = mergeExtraContext(stackOptions.extraContext, presets);
 
+  // Same run-logger wiring as prod, so jobs that declare tenantVisibleFailure
+  // write their failure rows in tests too.
+  const defaultRunLogger: NonNullable<NonNullable<TestStackOptions["jobs"]>["runLogger"]> = ({
+    registry,
+    db,
+  }) => jobRunLoggerCallbacks(registry, db);
+  const jobs =
+    stackOptions.jobs === undefined
+      ? undefined
+      : { runLogger: defaultRunLogger, ...stackOptions.jobs };
+
   return setupTestStack({
     ...stackOptions,
+    ...(jobs !== undefined && { jobs }),
     features,
     ...(extraContext !== undefined && { extraContext }),
   });