@junejs/server 0.1.0-dev.4 → 0.1.0-dev.5

package/dist/agent-native.js

@@ -0,0 +1,179 @@
+import { openLocalSqliteSync } from "./sqlite-driver.js";
+import { channelFetch } from "@junejs/core/agent-config";
+import { AgentSession, withSystem } from "@junejs/core/agent-runtime";
+//#region src/agent-native.ts
+function initSchema(db) {
+	db.exec(`CREATE TABLE IF NOT EXISTS agent_sessions (session_id TEXT PRIMARY KEY, status TEXT)`);
+	db.exec(`CREATE TABLE IF NOT EXISTS agent_messages (seq INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, body TEXT)`);
+	db.exec(`CREATE TABLE IF NOT EXISTS agent_steps (session_id TEXT, id TEXT, output TEXT, PRIMARY KEY (session_id, id))`);
+}
+var SqliteSessionStore = class {
+	db;
+	sid;
+	constructor(db, sid) {
+		this.db = db;
+		this.sid = sid;
+	}
+	appendMessage(m) {
+		this.db.query("INSERT INTO agent_messages (session_id, body) VALUES (?, ?)").run(this.sid, JSON.stringify(m));
+	}
+	messages() {
+		return this.db.query("SELECT body FROM agent_messages WHERE session_id = ? ORDER BY seq").all(this.sid).map((r) => JSON.parse(r.body));
+	}
+	hasUserTurn(turnId) {
+		return this.messages().some((m) => m.role === "user" && m.turnId === turnId);
+	}
+	getStep(id) {
+		const r = this.db.query("SELECT output FROM agent_steps WHERE session_id = ? AND id = ?").get(this.sid, id);
+		return r ? JSON.parse(r.output) : void 0;
+	}
+	putStep(id, output) {
+		this.db.query("INSERT INTO agent_steps (session_id, id, output) VALUES (?, ?, ?)").run(this.sid, id, JSON.stringify(output));
+	}
+	getStatus() {
+		return this.db.query("SELECT status FROM agent_sessions WHERE session_id = ?").get(this.sid)?.status ?? "new";
+	}
+	setStatus(s) {
+		this.db.query("INSERT INTO agent_sessions (session_id, status) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET status = ?").run(this.sid, s, s);
+	}
+	tx(fn) {
+		this.db.exec("BEGIN");
+		try {
+			const out = fn();
+			this.db.exec("COMMIT");
+			return out;
+		} catch (e) {
+			this.db.exec("ROLLBACK");
+			throw e;
+		}
+	}
+	unwrap() {
+		return this.db;
+	}
+};
+var InProcBroadcaster = class {
+	subs = /* @__PURE__ */ new Set();
+	publish(turnId) {
+		this.subs.forEach((cb) => {
+			try {
+				cb(turnId);
+			} catch {}
+		});
+	}
+	subscribe(cb) {
+		this.subs.add(cb);
+		return () => this.subs.delete(cb);
+	}
+};
+var NativeRuntime = class {
+	actors = /* @__PURE__ */ new Map();
+	agents;
+	db;
+	constructor(agents, db) {
+		this.agents = agents;
+		this.db = db;
+		initSchema(db);
+	}
+	session(agent, id) {
+		const key = `${agent}:${id}`;
+		let a = this.actors.get(key);
+		if (!a) {
+			const def = this.agents[agent];
+			if (!def) throw new Error(`unknown agent: ${agent}`);
+			const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
+			a = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), new InProcBroadcaster(), model, def.tools, this);
+			this.actors.set(key, a);
+		}
+		return a;
+	}
+};
+async function createNativeRuntime(agents, path = ":memory:") {
+	return new NativeRuntime(agents, await openLocalSqliteSync(path));
+}
+var MemorySessionStore = class {
+	msgs = [];
+	steps = /* @__PURE__ */ new Map();
+	status = "new";
+	appendMessage(m) {
+		this.msgs.push(m);
+	}
+	messages() {
+		return this.msgs.slice();
+	}
+	hasUserTurn(turnId) {
+		return this.msgs.some((m) => m.role === "user" && m.turnId === turnId);
+	}
+	getStep(id) {
+		return this.steps.has(id) ? this.steps.get(id) : void 0;
+	}
+	putStep(id, output) {
+		this.steps.set(id, output);
+	}
+	getStatus() {
+		return this.status;
+	}
+	setStatus(s) {
+		this.status = s;
+	}
+	tx(fn) {
+		return fn();
+	}
+	unwrap() {}
+};
+var MemoryRuntime = class {
+	actors = /* @__PURE__ */ new Map();
+	stores = /* @__PURE__ */ new Map();
+	agents;
+	constructor(agents) {
+		this.agents = agents;
+	}
+	session(agent, id) {
+		const key = `${agent}:${id}`;
+		let a = this.actors.get(key);
+		if (!a) {
+			const def = this.agents[agent];
+			if (!def) throw new Error(`unknown agent: ${agent}`);
+			const store = new MemorySessionStore();
+			this.stores.set(key, store);
+			a = new AgentSession(agent, id, store, new InProcBroadcaster(), def.model, def.tools, this);
+			this.actors.set(key, a);
+		}
+		return a;
+	}
+};
+async function createAgentRuntime(agents, opts = {}) {
+	const backend = opts.backend ?? "native";
+	if (backend === "memory") return new MemoryRuntime(agents);
+	if (backend === "native") return createNativeRuntime(agents, opts.path);
+	throw new Error("backend 'durable' is the Cloudflare Durable Object target — construct AgentDurableObject in your worker, not via createAgentRuntime");
+}
+function mountAgent(agent, runtime, opts = {}) {
+	const chatPath = opts.chatPath ?? "/message";
+	const channelsOn = opts.channels ?? true;
+	const ctx = {
+		agent,
+		run: (message, o) => runtime.session(agent.name, o?.session ?? "default").turn({
+			turnId: o?.turnId,
+			userText: message
+		})
+	};
+	const channels = channelFetch(agent, ctx);
+	const surface = async (req) => {
+		const url = new URL(req.url);
+		if (req.method === "POST" && url.pathname === chatPath) {
+			const { message, session } = await req.json();
+			return Response.json({ text: await ctx.run(message, { session }) });
+		}
+		return channelsOn ? channels(req) : null;
+	};
+	return {
+		ctx,
+		surface,
+		fetch: channels,
+		startAll: async () => {
+			await Promise.all(agent.channels.filter((c) => c.start).map((c) => c.start(ctx)));
+		}
+	};
+}
+//#endregion
+export { MemoryRuntime, NativeRuntime, createAgentRuntime, createNativeRuntime, mountAgent };

package/dist/app.d.ts

@@ -0,0 +1,15 @@
+import { JuneConfig } from "@junejs/core/config";
+//#region src/app.d.ts
+type CreateAppOptions = {
+  appDir: string;
+  config?: JuneConfig;
+};
+type JuneApp = {
+  fetch(request: Request): Promise<Response>;
+  warmup(): Promise<void>;
+  routePaths(): Promise<string[]>;
+  earlyHints(): string[];
+};
+declare function createApp({ appDir: appDirInput, config }: CreateAppOptions): JuneApp;
+//#endregion
+export { CreateAppOptions, JuneApp, createApp };

package/dist/app.js

@@ -0,0 +1,218 @@
+import { discoverAgent } from "./agent-discover.js";
+import { createAgentRuntime, mountAgent } from "./agent-native.js";
+import { findMiddlewareFile, isResourceFile, listRoutes, matchRouteTree, resolveNotFound, routeFiles } from "./router.js";
+import { createPipeline } from "./pipeline.js";
+import { resolveBoundary } from "./segment.js";
+import { memoizeResources } from "./resources.js";
+import { MODULE_STYLES_URL, buildModuleCss, registerCssModules } from "./css-modules.js";
+import { CLIENT_SCRIPT_URL, bundleClientSplit, findClientEntry } from "./client-bundle.js";
+import { generateIslandRegistry } from "./island-registry.js";
+import { STYLES_URL, findGlobalCss, globalCssUsesTailwind, processCssCached } from "./css.js";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { buildSystemPrompt } from "@junejs/core/agent-config";
+import { routeFromModule } from "@junejs/core/route";
+import { resolveAgent, resolveClientRouter, resolveSpeculationRules } from "@junejs/core/config";
+import { runWithTrace } from "@junejs/core/instrumentation";
+import { anthropic } from "@junejs/core/agent-models";
+//#region src/app.ts
+const layoutCache = /* @__PURE__ */ new Map();
+async function loadLayout(file) {
+	const cached = layoutCache.get(file);
+	if (cached !== void 0) return cached;
+	const mod = await import(pathToFileURL(file).href);
+	const result = typeof mod.default === "function" ? {
+		component: mod.default,
+		boundary: mod.segmentBoundary === true
+	} : null;
+	layoutCache.set(file, result);
+	return result;
+}
+const loadingCache = /* @__PURE__ */ new Map();
+async function nearestLoading(segments) {
+	const file = [...segments].reverse().find((s) => s.loading)?.loading;
+	if (!file) return void 0;
+	const cached = loadingCache.get(file);
+	if (cached) return cached;
+	const mod = await import(pathToFileURL(file).href);
+	if (typeof mod.default !== "function") return void 0;
+	loadingCache.set(file, mod.default);
+	return mod.default;
+}
+async function loadChain(segments) {
+	const items = [];
+	for (const seg of segments) {
+		if (!seg.layout) continue;
+		const L = await loadLayout(seg.layout);
+		items.push({
+			file: seg.layout,
+			entry: L?.component ?? null,
+			boundary: !!L?.boundary
+		});
+	}
+	const { chain, boundaryIndex, key } = resolveBoundary(items);
+	return {
+		chain,
+		boundaryIndex,
+		boundaryKey: key
+	};
+}
+function createApp({ appDir: appDirInput, config = {} }) {
+	const appDir = resolve(appDirInput);
+	const juneRoutesDir = join(dirname(appDir), ".june", "routes");
+	const hasJuneRoutes = existsSync(juneRoutesDir);
+	const agent = resolveAgent(config.agent);
+	const speculation = config.speculation;
+	const clientEntry = findClientEntry(appDir) ?? findClientEntry(join(dirname(appDir), ".june", "routes"));
+	const cssEntry = findGlobalCss(appDir);
+	const docConfig = {
+		site: config.site ?? {},
+		speculationRules: resolveSpeculationRules(speculation ?? void 0),
+		speculationDelivery: speculation ? speculation.delivery ?? "inline" : "inline",
+		viewTransitions: config.viewTransitions ?? true,
+		cssReset: config.cssReset ?? !globalCssUsesTailwind(appDir),
+		clientRouter: resolveClientRouter(config.clientRouter),
+		clientScript: clientEntry ? CLIENT_SCRIPT_URL : null,
+		styles: cssEntry ? STYLES_URL : null
+	};
+	let moduleCssPromise;
+	const getModuleCss = () => moduleCssPromise ??= buildModuleCss(appDir, dirname(appDir));
+	let clientBundle;
+	const serveClient = () => clientBundle ??= getModuleCss().then(async ({ maps }) => {
+		await generateIslandRegistry(appDir);
+		return bundleClientSplit(clientEntry, dirname(appDir), "development", maps);
+	});
+	const routePaths = async () => {
+		const own = await listRoutes(appDir, { pageConvention: true });
+		if (!hasJuneRoutes) return own;
+		const seen = new Set(own);
+		const gen = (await listRoutes(juneRoutesDir, { pageConvention: true })).filter((p) => !seen.has(p));
+		return [...own, ...gen].sort();
+	};
+	const resources = memoizeResources(config.resources);
+	config.dataLayer?.install();
+	let pipelinePromise;
+	const getPipeline = () => pipelinePromise ??= buildPipeline();
+	async function buildPipeline() {
+		const { maps, css } = await getModuleCss();
+		await registerCssModules(maps);
+		if (css !== null) docConfig.moduleStyles = MODULE_STYLES_URL;
+		const { notFound } = await resolveNotFound(appDir, "/");
+		let notFoundComponent;
+		if (notFound) {
+			const mod = await import(pathToFileURL(notFound).href);
+			if (typeof mod.default === "function") notFoundComponent = mod.default;
+		}
+		let extra;
+		const extraFile = findMiddlewareFile(appDir);
+		if (extraFile) {
+			const mod = await import(pathToFileURL(extraFile).href);
+			if (typeof mod.default === "function") extra = mod.default;
+		}
+		let agentSurface;
+		const agentDir = join(appDir, agent.runtime.dir);
+		if (agent.runtime.enabled && existsSync(agentDir)) {
+			const def = await discoverAgent(agentDir);
+			const backend = agent.runtime.backend === "durable" ? "native" : agent.runtime.backend;
+			const model = anthropic({ model: def.model });
+			const mounted = mountAgent(def, await createAgentRuntime({ [def.name]: {
+				model,
+				tools: def.tools,
+				instructions: buildSystemPrompt(def)
+			} }, { backend }), {
+				chatPath: agent.runtime.chat.path,
+				channels: agent.runtime.channels
+			});
+			agentSurface = (req) => mounted.surface(req);
+			await mounted.startAll();
+		}
+		return createPipeline({
+			extra,
+			docConfig,
+			agent,
+			agentSurface,
+			i18n: config.i18n,
+			routeList: routePaths,
+			earlyHints: config.earlyHints,
+			resources,
+			notFoundComponent,
+			resolve: async (pathname) => {
+				const match = await matchRouteTree(appDir, pathname, { pageConvention: true }) ?? (hasJuneRoutes ? await matchRouteTree(juneRoutesDir, pathname, { pageConvention: true }) : null);
+				if (!match) return null;
+				const mod = await import(pathToFileURL(match.file).href);
+				if (isResourceFile(match.file)) {
+					const handler = mod.default;
+					if (typeof handler !== "function") return null;
+					return {
+						handler,
+						params: match.params
+					};
+				}
+				const def = routeFromModule(mod);
+				if (!def) return null;
+				const { chain, boundaryIndex, boundaryKey } = await loadChain(match.segments);
+				return {
+					def,
+					params: match.params,
+					chain,
+					boundaryIndex,
+					boundaryKey,
+					loading: await nearestLoading(match.segments)
+				};
+			}
+		});
+	}
+	function newTrace() {
+		return {
+			id: crypto.randomUUID(),
+			startedAt: performance.now(),
+			events: []
+		};
+	}
+	return {
+		fetch(request) {
+			if (cssEntry && new URL(request.url).pathname === "/_june/global.css") return processCssCached(appDir).then((css) => new Response(css ?? "", { headers: { "content-type": "text/css; charset=utf-8" } }), (err) => {
+				console.error("[june] global.css failed:", err);
+				return new Response(`/* global.css failed: ${err instanceof Error ? err.message : String(err)} */\n`, {
+					status: 500,
+					headers: { "content-type": "text/css; charset=utf-8" }
+				});
+			});
+			if (new URL(request.url).pathname === "/_june/modules.css") return getModuleCss().then(({ css }) => new Response(css ?? "", { headers: { "content-type": "text/css; charset=utf-8" } }));
+			{
+				const pathname = new URL(request.url).pathname;
+				if (clientEntry && pathname.startsWith("/_june/") && pathname.endsWith(".js")) {
+					const file = pathname.slice(7);
+					return serveClient().then((chunks) => {
+						const code = chunks.get(file);
+						if (code === void 0) return new Response(`unknown client chunk: ${file}\n`, {
+							status: 404,
+							headers: { "content-type": "text/plain; charset=utf-8" }
+						});
+						return new Response(code, { headers: { "content-type": "text/javascript; charset=utf-8" } });
+					}, (err) => {
+						clientBundle = void 0;
+						console.error("[june] client bundle failed:", err);
+						return new Response(`client bundle failed: ${err instanceof Error ? err.message : String(err)}\n`, {
+							status: 500,
+							headers: { "content-type": "text/plain; charset=utf-8" }
+						});
+					});
+				}
+			}
+			return runWithTrace(newTrace(), async () => (await getPipeline()).fetch(request));
+		},
+		async warmup() {
+			const files = await routeFiles(appDir, { pageConvention: true });
+			if (hasJuneRoutes) files.push(...await routeFiles(juneRoutesDir, { pageConvention: true }));
+			for (const file of files) await import(pathToFileURL(file).href).catch((err) => {
+				console.error(`[june] failed to load route ${file}`, err);
+			});
+		},
+		routePaths,
+		earlyHints: () => config.earlyHints ?? []
+	};
+}
+//#endregion
+export { createApp };

package/dist/blob.d.ts

@@ -0,0 +1,23 @@
+import { BlobFactory } from "@junejs/core/resources";
+//#region src/blob.d.ts
+declare function localBlob(opts?: {
+  dir?: string;
+}): BlobFactory;
+interface R2ObjectBody {
+  arrayBuffer(): Promise<ArrayBuffer>;
+}
+interface R2Bucket {
+  get(key: string): Promise<R2ObjectBody | null>;
+  put(key: string, data: ArrayBuffer | Uint8Array | string): Promise<unknown>;
+  delete(key: string): Promise<void>;
+  list(opts?: {
+    prefix?: string;
+  }): Promise<{
+    objects: {
+      key: string;
+    }[];
+  }>;
+}
+declare function r2(bucket: R2Bucket): BlobFactory;
+//#endregion
+export { R2Bucket, localBlob, r2 };

package/dist/blob.js

@@ -0,0 +1,78 @@
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+//#region src/blob.ts
+function safeKey(key) {
+	if (key.startsWith("/") || key.split(/[\\/]/).includes("..")) throw new Error(`unsafe blob key: ${key}`);
+	return key;
+}
+function localBlobHandle(dir) {
+	return {
+		async get(key) {
+			const file = join(dir, safeKey(key));
+			try {
+				return new Uint8Array(await readFile(file));
+			} catch {
+				return null;
+			}
+		},
+		async put(key, data) {
+			const file = join(dir, safeKey(key));
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(file, typeof data === "string" ? data : Buffer.from(data));
+		},
+		async delete(key) {
+			await rm(join(dir, safeKey(key)), { force: true });
+		},
+		async list(prefix = "") {
+			const out = [];
+			async function walk(d, base) {
+				let entries;
+				try {
+					entries = await readdir(d, { withFileTypes: true });
+				} catch {
+					return;
+				}
+				for (const e of entries) {
+					const rel = base ? `${base}/${e.name}` : e.name;
+					if (e.isDirectory()) await walk(join(d, e.name), rel);
+					else if (rel.startsWith(prefix)) out.push(rel);
+				}
+			}
+			await walk(dir, "");
+			return out.sort();
+		}
+	};
+}
+function localBlob(opts = {}) {
+	const dir = opts.dir ?? ".june/blob";
+	return {
+		kind: "local",
+		open: async () => {
+			await mkdir(dir, { recursive: true });
+			return localBlobHandle(dir);
+		}
+	};
+}
+function r2(bucket) {
+	const handle = {
+		async get(key) {
+			const obj = await bucket.get(key);
+			return obj ? new Uint8Array(await obj.arrayBuffer()) : null;
+		},
+		async put(key, data) {
+			await bucket.put(key, data);
+		},
+		async delete(key) {
+			await bucket.delete(key);
+		},
+		async list(prefix) {
+			return (await bucket.list({ prefix })).objects.map((o) => o.key);
+		}
+	};
+	return {
+		kind: "r2",
+		open: async () => handle
+	};
+}
+//#endregion
+export { localBlob, r2 };

package/dist/build.d.ts

@@ -0,0 +1,40 @@
+import { JuneAdapter } from "./adapter.js";
+import { WorkerManifest } from "./worker.js";
+import { JuneConfig } from "@junejs/core/config";
+import { DocumentConfig } from "@junejs/core/document";
+//#region src/build.d.ts
+type BuildResult = {
+  outFile: string;
+  routes: string[];
+  dynamicRoutes: string[];
+  contentCollections: string[];
+  prerendered: string[];
+};
+type RouteEntry = {
+  path: string;
+  file: string;
+  dynamic: boolean;
+  resource?: boolean;
+  layouts: string[];
+  loading?: string;
+};
+declare const isBunSpecifier: (id: string) => boolean;
+declare function resolveDeployAdapter(deploy: JuneConfig["deploy"]): JuneAdapter;
+declare function scanRoutes(appDir: string, dir?: string, layouts?: string[], out?: RouteEntry[], loading?: string): Promise<RouteEntry[]>;
+declare function generateContent(appRoot: string): Promise<string[]>;
+declare function freezeConfig(appRoot: string): Promise<{
+  document: DocumentConfig;
+  agent: WorkerManifest["agent"];
+  i18n: WorkerManifest["i18n"];
+  earlyHints: string[];
+  buildExternal: string[];
+}>;
+declare function normalizeBase(base?: string): string;
+declare function workerName(raw: string): string;
+declare function buildManifest(appRoot: string): Promise<WorkerManifest>;
+declare function juneBuild(appRoot: string, options?: {
+  outDir?: string;
+  external?: string[];
+}): Promise<BuildResult>;
+//#endregion
+export { BuildResult, buildManifest, freezeConfig, generateContent, isBunSpecifier, juneBuild, normalizeBase, resolveDeployAdapter, scanRoutes, workerName };