@junejs/server 0.1.2 → 0.2.0

package/src/app.ts

@@ -18,21 +18,25 @@ import type { ComponentType } from "react";
 import { routeFromModule } from "@junejs/core/route";
 import {
   resolveAgent,
+  deployOrigin,
   resolveClientRouter,
   resolveSpeculationRules,
   type JuneConfig,
 } from "@junejs/core/config";
 import type { DocumentConfig } from "@junejs/core/document";
 import { runWithTrace, type RequestTrace } from "@junejs/core/instrumentation";
+import { blobFileStore, memoryFileStore } from "@junejs/core/agent-files";
+import type { JuneBlob } from "@junejs/core/resources";
 
 import { findMiddlewareFile, isResourceFile, listRoutes, matchRouteTree, resolveNotFound, routeFiles, type SegmentMatch } from "./router";
+import { routeProblems, scanRoutes } from "./route-scan";
 import { createPipeline, type ExtraHandler, type LayoutComponent, type MiddlewareHandler, type Pipeline, type Resolved, type ResourceHandler } from "./pipeline";
 import { discoverAgent } from "./agent-discover";
-import { createAgentRuntime, mountAgent } from "./agent-native";
-import { buildSystemPrompt } from "@junejs/core/agent-config";
+import { createAgentRuntime, mountAgent, toAgentDef, type InProcessRuntime } from "./agent-native";
 import { anthropic } from "@junejs/core/agent-models";
 import { resolveBoundary } from "./segment";
 import { memoizeResources } from "./resources";
+import { localBlob } from "./blob";
 import {
   findClientEntry,
   bundleClientSplit,
@@ -43,6 +47,15 @@ import { generateIslandRegistry } from "./island-registry";
 import { findGlobalCss, globalCssUsesTailwind, processCssCached, STYLES_URL } from "./css";
 import { buildModuleCss, registerCssModules, MODULE_STYLES_URL, type ModuleMaps } from "./css-modules";
 import { contentTypeFor, RESERVED_PREFIX, safeRelativePath } from "./static-files";
+import {
+  GENERATED_ICONS,
+  googleFontFetcher,
+  publicFileCheck,
+  renderIcons,
+  resolveIcons,
+  type GeneratedIconFile,
+  type GeneratedIcons,
+} from "./favicon";
 
 export type CreateAppOptions = {
   appDir: string;
@@ -56,6 +69,10 @@ export type JuneApp = {
   warmup(): Promise<void>;
   routePaths(): Promise<string[]>;
   earlyHints(): string[];
+  // Shut down what the app started (#317): the agent runtime built for an agent/
+  // directory — its pending announcement retries, its in-flight turns, its SQLite
+  // handle. Resolves once they finish. A no-op when no runtime was built.
+  close(): Promise<void>;
 };
 
 // Import a layout file's default export as a layout component (memoized), plus
@@ -133,6 +150,19 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
   } catch {
     /* no public/ dir → nothing to serve */
   }
+  // Default PNG icons: linked by the document, rendered once on first request
+  // (a failed render is retried next time rather than memoized).
+  const iconPlan = resolveIcons(config.site ?? {}, publicFileCheck(publicDir));
+  let iconsPromise: Promise<GeneratedIcons> | undefined;
+  const getIcons = () =>
+    (iconsPromise ??= renderIcons({
+      site: config.site ?? {},
+      fetchFont: googleFontFetcher(join(dirname(appDir), "node_modules", ".cache", "june", "fonts")),
+      warn: (msg) => console.warn(msg),
+    }).catch((err) => {
+      iconsPromise = undefined;
+      throw err;
+    }));
   const agent = resolveAgent(config.agent);
   const speculation = config.speculation;
   // app/_client.* present → the dev document loads /client.js and we serve it
@@ -144,6 +174,7 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
   const cssEntry = findGlobalCss(appDir);
   const docConfig: DocumentConfig = {
     site: config.site ?? {},
+    deployOrigin: deployOrigin(config),
     speculationRules: resolveSpeculationRules(speculation ?? undefined),
     speculationDelivery: speculation ? speculation.delivery ?? "inline" : "inline",
     viewTransitions: config.viewTransitions ?? true,
@@ -152,6 +183,7 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
     clientRouter: resolveClientRouter(config.clientRouter),
     clientScript: clientEntry ? CLIENT_SCRIPT_URL : null,
     styles: cssEntry ? STYLES_URL : null,
+    icons: iconPlan.icons,
   };
 
   // CSS Modules: glob + transform app/**/*.module.css ONCE (memoized) → the maps
@@ -202,6 +234,8 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
   // pipeline is built lazily on first fetch, memoized after.
   let pipelinePromise: Promise<Pipeline> | undefined;
   const getPipeline = (): Promise<Pipeline> => (pipelinePromise ??= buildPipeline());
+  // The agent runtime buildPipeline creates, kept so close() can shut it down (#317).
+  let agentRuntime: InProcessRuntime | undefined;
   async function buildPipeline(): Promise<Pipeline> {
     // Wire CSS Modules BEFORE any route import: the runtime interceptor must be
     // active so `import "x.module.css"` in a route resolves to the scoped map,
@@ -237,10 +271,18 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
       // instructions live on the def (single source); the runtime injects them
       // into the model per turn via withSystem — no need to bake into anthropic().
       const model = anthropic({ model: def.model });
-      const rt = await createAgentRuntime(
-        { [def.name]: { model, tools: def.tools, instructions: buildSystemPrompt(def) } },
-        { backend },
-      );
+      // toAgentDef: tools, prompt AND the per-surface policies (#149) from the one
+      // definition — channelInstructions was previously dropped on this path (#173).
+      // Agent files (docs/rfc-agent-files.md) live in the app's blob resource; an app that
+      // declares none gets the local default directory. The memory backend keeps them in
+      // memory, like everything else it holds.
+      let blobOpened: Promise<JuneBlob> | undefined;
+      const files =
+        backend === "memory"
+          ? memoryFileStore()
+          : blobFileStore(() => (blobOpened ??= resources().then(async (r) => r.blob ?? (await localBlob().open()))));
+      const rt = await createAgentRuntime({ [def.name]: toAgentDef(def, model) }, { backend, files });
+      agentRuntime = rt;
       const mounted = mountAgent(def, rt, { chatPath: agent.runtime.chat.path, channels: agent.runtime.channels });
       agentSurface = (req) => mounted.surface(req);
       await mounted.startAll();
@@ -403,9 +445,30 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
           }
         }
       }
+      // June's default PNG icons (the app has none of its own): rendered on first
+      // request with the same code `june build` writes them with.
+      if (iconPlan.generate && (request.method === "GET" || request.method === "HEAD")) {
+        const name = new URL(request.url).pathname.slice(1);
+        if ((GENERATED_ICONS as readonly string[]).includes(name)) {
+          return getIcons().then(
+            (icons) =>
+              new Response(request.method === "HEAD" ? null : icons[name as GeneratedIconFile], {
+                headers: { "content-type": contentTypeFor(name), "cache-control": "public, max-age=0, must-revalidate" },
+              }),
+            () => toPipeline(),
+          );
+        }
+      }
       return toPipeline();
     },
     async warmup() {
+      // What `june build` refuses (same-path files, a segment after an optional
+      // or catch-all), dev reports up front — it still serves what it can.
+      const problems = routeProblems(
+        [await scanRoutes(appDir), hasJuneRoutes ? await scanRoutes(juneRoutesDir) : []],
+        dirname(appDir),
+      );
+      if (problems) console.error(problems);
       const files = await routeFiles(appDir, { pageConvention: true });
       if (hasJuneRoutes) files.push(...(await routeFiles(juneRoutesDir, { pageConvention: true })));
       for (const file of files) {
@@ -416,5 +479,11 @@ export function createApp({ appDir: appDirInput, config = {} }: CreateAppOptions
     },
     routePaths,
     earlyHints: () => config.earlyHints ?? [],
+    async close() {
+      // A pipeline still being built may be about to create the runtime: let it finish
+      // (its failure is the fetch's to report, not close()'s).
+      await pipelinePromise?.catch(() => {});
+      await agentRuntime?.close();
+    },
   };
 }