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

package/dist/adapter.d.ts

@@ -0,0 +1,55 @@
+import { JuneConfig } from "@junejs/core/config";
+//#region src/adapter.d.ts
+type AdapterCapabilities = {
+  runtime: "edge" | "node" | "serverless" | "native" | "static";
+  persistentConnections: boolean;
+  assets: "platform" | "server" | "none";
+};
+type AdapterEntry = {
+  imports: string[];
+  wrap(pipelineVar: string): string;
+};
+type ResourcePlan = {
+  db?: {
+    binding: string;
+    databaseName: string;
+  };
+};
+type AdapterEmitContext = {
+  appRoot: string;
+  outDir: string;
+  hasAssets: boolean;
+  linkHeader: string | null;
+  config: JuneConfig;
+  plan: ResourcePlan;
+  defaultName: string;
+};
+interface JuneAdapter {
+  readonly name: string;
+  readonly capabilities: AdapterCapabilities;
+  readonly conditions: string[];
+  readonly buildExternal?: string[];
+  validate?(ctx: {
+    plan: ResourcePlan;
+    config: JuneConfig;
+  }): void;
+  entry(opts: {
+    linkHeader: string | null;
+  }): AdapterEntry;
+  emit(ctx: AdapterEmitContext): Promise<void>;
+}
+declare function workers(opts?: {
+  name?: string;
+  domain?: string;
+}): JuneAdapter;
+declare function vercel(opts?: {
+  runtime?: "node" | "edge";
+  regions?: string[];
+}): JuneAdapter;
+declare function deno(opts?: {
+  org?: string;
+  app?: string;
+}): JuneAdapter;
+declare function staticSite(): JuneAdapter;
+//#endregion
+export { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, staticSite, vercel, workers };

package/dist/adapter.js

@@ -0,0 +1,204 @@
+import { existsSync } from "node:fs";
+import { copyFile, cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/adapter.ts
+function workers(opts) {
+	return {
+		name: "workers",
+		capabilities: {
+			runtime: "edge",
+			persistentConnections: true,
+			assets: "platform"
+		},
+		conditions: [
+			"source",
+			"workerd",
+			"edge",
+			"import",
+			"default"
+		],
+		buildExternal: ["workers-og"],
+		entry({ linkHeader }) {
+			return {
+				imports: [`import { withAssets } from "@junejs/server/worker";`],
+				wrap: (pipelineVar) => `export default withAssets(${pipelineVar}, { link: ${JSON.stringify(linkHeader)} });`
+			};
+		},
+		async emit({ appRoot, outDir, hasAssets, config, plan, defaultName }) {
+			if (existsSync(join(appRoot, "wrangler.toml")) || existsSync(join(appRoot, "wrangler.jsonc"))) return;
+			const deployCfg = config.deploy;
+			await writeFile(join(outDir, "wrangler.jsonc"), JSON.stringify({
+				name: opts?.name ?? deployCfg?.name ?? defaultName,
+				main: "./worker.js",
+				compatibility_date: "2025-01-01",
+				compatibility_flags: ["nodejs_compat"],
+				...hasAssets ? { assets: {
+					directory: "./assets",
+					binding: "ASSETS",
+					run_worker_first: true
+				} } : {},
+				...plan.db ? { d1_databases: [{
+					binding: plan.db.binding,
+					database_name: plan.db.databaseName,
+					database_id: ""
+				}] } : {},
+				...opts?.domain ?? deployCfg?.domain ? { routes: [{
+					pattern: opts?.domain ?? deployCfg?.domain,
+					custom_domain: true
+				}] } : {}
+			}, null, 2) + "\n");
+		}
+	};
+}
+const VERCEL_FUNCTION = "__june";
+function vercel(opts) {
+	const isEdge = (opts?.runtime ?? "node") === "edge";
+	return {
+		name: "vercel",
+		capabilities: {
+			runtime: isEdge ? "edge" : "node",
+			persistentConnections: !isEdge,
+			assets: "platform"
+		},
+		conditions: [
+			"source",
+			"edge-light",
+			"edge",
+			"import",
+			"default"
+		],
+		validate({ config }) {
+			const kind = config.resources?.db?.kind;
+			if (kind && kind !== "turso") throw new Error(`vercel(): the '${kind}' db isn't supported on Vercel (D1 is Cloudflare-only).\n  Use turso() (libsql over HTTPS) for a Vercel db, or deploy to Workers.`);
+		},
+		entry() {
+			const env = `const __env = typeof process !== "undefined" && process.env ? process.env : {};\n`;
+			return {
+				imports: [],
+				wrap: (pipelineVar) => isEdge ? env + `export default (request) => ${pipelineVar}.fetch(request, __env);` : env + `export default { fetch: (request) => ${pipelineVar}.fetch(request, __env) };`
+			};
+		},
+		async emit({ appRoot, outDir, hasAssets }) {
+			const out = join(appRoot, ".vercel", "output");
+			const fnDir = join(out, "functions", `${VERCEL_FUNCTION}.func`);
+			await rm(out, {
+				recursive: true,
+				force: true
+			});
+			await mkdir(fnDir, { recursive: true });
+			const jsFiles = (await readdir(outDir)).filter((f) => f.endsWith(".js"));
+			for (const f of jsFiles) await copyFile(join(outDir, f), join(fnDir, f));
+			const regions = opts?.regions ? { regions: opts.regions } : {};
+			const vcConfig = isEdge ? {
+				runtime: "edge",
+				entrypoint: "worker.js",
+				...regions
+			} : {
+				runtime: "nodejs22.x",
+				handler: "worker.js",
+				launcherType: "Nodejs",
+				supportsResponseStreaming: true,
+				...regions
+			};
+			await writeFile(join(fnDir, ".vc-config.json"), JSON.stringify(vcConfig, null, 2) + "\n");
+			if (!isEdge) await writeFile(join(fnDir, "package.json"), JSON.stringify({ type: "module" }, null, 2) + "\n");
+			if (hasAssets) {
+				const src = join(outDir, "assets", "_june");
+				if (existsSync(src)) await cp(src, join(out, "static", "_june"), { recursive: true });
+			}
+			await writeFile(join(out, "config.json"), JSON.stringify({
+				version: 3,
+				routes: [
+					{
+						src: "^/_june/(.*)$",
+						headers: { "cache-control": "public, max-age=31536000, immutable" },
+						continue: true
+					},
+					{ handle: "filesystem" },
+					{
+						src: "^/.*$",
+						dest: `/${VERCEL_FUNCTION}`
+					}
+				]
+			}, null, 2) + "\n");
+		}
+	};
+}
+function deno(opts) {
+	return {
+		name: "deno",
+		capabilities: {
+			runtime: "edge",
+			persistentConnections: true,
+			assets: "server"
+		},
+		conditions: [
+			"source",
+			"deno",
+			"edge-light",
+			"edge",
+			"import",
+			"default"
+		],
+		validate({ config }) {
+			const kind = config.resources?.db?.kind;
+			if (kind && kind !== "turso") throw new Error(`deno(): the '${kind}' db isn't supported on Deno Deploy (D1 is Cloudflare-only).\n  Use turso() (libsql over HTTPS) for a Deno db, or deploy to Workers.`);
+		},
+		entry() {
+			return {
+				imports: [`import { withDenoAssets } from "@junejs/server/worker";`],
+				wrap: (pipelineVar) => `export default { fetch: withDenoAssets(${pipelineVar}) };`
+			};
+		},
+		async emit({ outDir }) {
+			await writeFile(join(outDir, "deno.json"), JSON.stringify({ deploy: {
+				...opts?.org ? { org: opts.org } : {},
+				...opts?.app ? { app: opts.app } : {},
+				runtime: {
+					type: "dynamic",
+					entrypoint: "worker.js"
+				}
+			} }, null, 2) + "\n");
+		}
+	};
+}
+function staticSite() {
+	return {
+		name: "static",
+		capabilities: {
+			runtime: "static",
+			persistentConnections: false,
+			assets: "none"
+		},
+		conditions: [
+			"source",
+			"edge-light",
+			"edge",
+			"import",
+			"default"
+		],
+		buildExternal: ["workers-og"],
+		validate({ config }) {
+			const kind = config.resources?.db?.kind;
+			if (kind) throw new Error(`static(): a '${kind}' db needs a server — a static site has no runtime.\n  Drop the db resource, or deploy to workers()/vercel()/deno().`);
+		},
+		entry() {
+			return {
+				imports: [],
+				wrap: (pipelineVar) => `export default { fetch: (request) => ${pipelineVar}.fetch(request) };`
+			};
+		},
+		async emit({ outDir }) {
+			const src = join(outDir, "assets");
+			const site = join(outDir, "static");
+			await rm(site, {
+				recursive: true,
+				force: true
+			});
+			await cp(src, site, { recursive: true });
+			await writeFile(join(site, ".nojekyll"), "");
+		}
+	};
+}
+//#endregion
+export { deno, staticSite, vercel, workers };

package/dist/agent-discover.d.ts

@@ -0,0 +1,5 @@
+import { AgentDefinition } from "@junejs/core/agent-config";
+//#region src/agent-discover.d.ts
+declare function discoverAgent(dir: string): Promise<AgentDefinition>;
+//#endregion
+export { discoverAgent };

package/dist/agent-discover.js

@@ -0,0 +1,75 @@
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { defineAgent } from "@junejs/core/agent-config";
+import { connectAll } from "@junejs/core/connections";
+//#region src/agent-discover.ts
+async function scan(dir, ext) {
+	if (!existsSync(dir)) return [];
+	return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isFile() && extname(e.name) === ext).map((e) => join(dir, e.name)).sort();
+}
+function parseSkill(name, text) {
+	if (text.startsWith("---")) {
+		const end = text.indexOf("\n---", 3);
+		if (end !== -1) {
+			const front = text.slice(3, end);
+			const body = text.slice(end + 4).replace(/^\s*\n/, "");
+			const meta = {};
+			for (const line of front.split("\n")) {
+				const m = line.match(/^\s*(\w+)\s*:\s*(.+?)\s*$/);
+				if (m) meta[m[1]] = m[2];
+			}
+			return {
+				name: meta.name ?? name,
+				description: meta.description ?? "",
+				body
+			};
+		}
+	}
+	return {
+		name,
+		description: (text.split("\n").find((l) => l.trim()) ?? "").replace(/^#\s*/, ""),
+		body: text
+	};
+}
+async function discoverAgent(dir) {
+	const configFile = join(dir, "agent.ts");
+	const config = existsSync(configFile) ? (await import(pathToFileURL(configFile).href)).default : { name: basename(dir) };
+	const instructionsFile = join(dir, "instructions.md");
+	const instructions = existsSync(instructionsFile) ? await readFile(instructionsFile, "utf8") : config.instructions ?? "";
+	const tools = [];
+	for (const f of await scan(join(dir, "tools"), ".ts")) {
+		const mod = await import(pathToFileURL(f).href);
+		if (mod.default) tools.push(mod.default);
+	}
+	const skills = [];
+	for (const f of await scan(join(dir, "skills"), ".md")) skills.push(parseSkill(basename(f, ".md"), await readFile(f, "utf8")));
+	const channels = [];
+	for (const f of await scan(join(dir, "channels"), ".ts")) {
+		const mod = await import(pathToFileURL(f).href);
+		if (mod.default) channels.push(mod.default);
+	}
+	const connectionDefs = [];
+	for (const f of await scan(join(dir, "connections"), ".ts")) {
+		const mod = await import(pathToFileURL(f).href);
+		if (mod.default) connectionDefs.push(mod.default);
+	}
+	const { actions: connectionActions, report: connections } = connectionDefs.length ? await connectAll(connectionDefs) : {
+		actions: [],
+		report: []
+	};
+	tools.push(...connectionActions);
+	return defineAgent({
+		name: config.name,
+		model: config.model,
+		description: config.description,
+		instructions,
+		tools,
+		skills,
+		channels,
+		connections
+	});
+}
+//#endregion
+export { discoverAgent };

package/dist/agent-durable.d.ts

@@ -0,0 +1,60 @@
+import { Model, Msg, SessionStore, Tool } from "@junejs/core/agent-runtime";
+//#region src/agent-durable.d.ts
+interface SqlStorageCursor<T = Record<string, unknown>> {
+  toArray(): T[];
+  one(): T;
+}
+interface SqlStorage {
+  exec<T = Record<string, unknown>>(query: string, ...bindings: unknown[]): SqlStorageCursor<T>;
+}
+interface DurableStorage {
+  sql: SqlStorage;
+  transactionSync<T>(fn: () => T): T;
+}
+interface DurableObjectState {
+  storage: DurableStorage;
+}
+interface DurableObjectStub {
+  fetch(request: Request): Promise<Response>;
+}
+interface DurableObjectNamespace {
+  idFromName(name: string): unknown;
+  get(id: unknown): DurableObjectStub;
+}
+declare class DoSessionStore implements SessionStore {
+  private readonly storage;
+  constructor(storage: DurableStorage);
+  private get sql();
+  appendMessage(m: Msg): void;
+  messages(): Msg[];
+  hasUserTurn(turnId: string): boolean;
+  getStep(id: string): unknown | undefined;
+  putStep(id: string, output: unknown): void;
+  getStatus(): string;
+  setStatus(s: string): void;
+  tx<T>(fn: () => T): T;
+  unwrap<H = unknown>(): H;
+}
+type DoAgentDef = {
+  name?: string;
+  model: Model;
+  tools: Tool[];
+  instructions?: string;
+};
+declare class AgentDurableObject {
+  private session;
+  constructor(state: DurableObjectState, def: DoAgentDef);
+  turn(input: {
+    turnId?: string;
+    userText: string;
+  }): Promise<string>;
+  transcript(): import("@junejs/core/agent-runtime").Turn[];
+  fetch(req: Request): Promise<Response>;
+}
+declare function durableFetch(namespace: DurableObjectNamespace, agent: string, session: string, req: Request): Promise<Response>;
+declare function durableAgentSurface(getNamespace: () => DurableObjectNamespace | undefined, opts: {
+  agentName: string;
+  chatPath?: string;
+}): (req: Request) => Promise<Response | null>;
+//#endregion
+export { AgentDurableObject, DoAgentDef, DoSessionStore, DurableObjectNamespace, DurableObjectState, DurableObjectStub, DurableStorage, SqlStorage, SqlStorageCursor, durableAgentSurface, durableFetch };

package/dist/agent-durable.js

@@ -0,0 +1,106 @@
+import { AgentSession, withSystem } from "@junejs/core/agent-runtime";
+//#region src/agent-durable.ts
+var DoSessionStore = class {
+	storage;
+	constructor(storage) {
+		this.storage = storage;
+		const sql = storage.sql;
+		sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages (seq INTEGER PRIMARY KEY AUTOINCREMENT, body TEXT)`);
+		sql.exec(`CREATE TABLE IF NOT EXISTS agent_steps (id TEXT PRIMARY KEY, output TEXT)`);
+		sql.exec(`CREATE TABLE IF NOT EXISTS agent_meta (k TEXT PRIMARY KEY, v TEXT)`);
+	}
+	get sql() {
+		return this.storage.sql;
+	}
+	appendMessage(m) {
+		this.sql.exec("INSERT INTO agent_messages (body) VALUES (?)", JSON.stringify(m));
+	}
+	messages() {
+		return this.sql.exec("SELECT body FROM agent_messages ORDER BY seq").toArray().map((r) => JSON.parse(r.body));
+	}
+	hasUserTurn(turnId) {
+		return this.messages().some((m) => m.role === "user" && m.turnId === turnId);
+	}
+	getStep(id) {
+		const rows = this.sql.exec("SELECT output FROM agent_steps WHERE id = ?", id).toArray();
+		return rows.length ? JSON.parse(rows[0].output) : void 0;
+	}
+	putStep(id, output) {
+		this.sql.exec("INSERT INTO agent_steps (id, output) VALUES (?, ?)", id, JSON.stringify(output));
+	}
+	getStatus() {
+		const rows = this.sql.exec("SELECT v FROM agent_meta WHERE k = 'status'").toArray();
+		return rows.length ? rows[0].v : "new";
+	}
+	setStatus(s) {
+		this.sql.exec("INSERT INTO agent_meta (k, v) VALUES ('status', ?) ON CONFLICT(k) DO UPDATE SET v = ?", s, s);
+	}
+	tx(fn) {
+		return this.storage.transactionSync(fn);
+	}
+	unwrap() {
+		return this.sql;
+	}
+};
+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);
+	}
+};
+const crossDoUnsupported = { session() {
+	throw new Error("subagents on the Durable Object target require cross-DO wiring (not yet implemented)");
+} };
+var AgentDurableObject = class {
+	session;
+	constructor(state, def) {
+		const store = new DoSessionStore(state.storage);
+		const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
+		this.session = new AgentSession(def.name ?? "agent", "self", store, new InProcBroadcaster(), model, def.tools, crossDoUnsupported);
+	}
+	turn(input) {
+		return this.session.turn(input);
+	}
+	transcript() {
+		return this.session.transcript();
+	}
+	async fetch(req) {
+		const url = new URL(req.url);
+		if (req.method === "POST" && url.pathname.endsWith("/turn")) {
+			const { userText, turnId } = await req.json();
+			return Response.json({ text: await this.turn({
+				userText,
+				turnId
+			}) });
+		}
+		if (url.pathname.endsWith("/transcript")) return Response.json({ transcript: this.transcript() });
+		return new Response("agent DO — POST /turn or GET /transcript", { status: 404 });
+	}
+};
+function durableFetch(namespace, agent, session, req) {
+	return namespace.get(namespace.idFromName(`${agent}:${session}`)).fetch(req);
+}
+function durableAgentSurface(getNamespace, opts) {
+	const chatPath = opts.chatPath ?? "/message";
+	return async (req) => {
+		const url = new URL(req.url);
+		if (req.method !== "POST" || url.pathname !== chatPath) return null;
+		const namespace = getNamespace();
+		if (!namespace) return null;
+		const { message, session } = await req.json();
+		return durableFetch(namespace, opts.agentName, session ?? "default", new Request("https://do/turn", {
+			method: "POST",
+			body: JSON.stringify({ userText: message })
+		}));
+	};
+}
+//#endregion
+export { AgentDurableObject, DoSessionStore, durableAgentSurface, durableFetch };

package/dist/agent-native.d.ts

@@ -0,0 +1,40 @@
+import { SyncSqlite } from "./sqlite-driver.js";
+import { AgentDefinition, ChannelContext } from "@junejs/core/agent-config";
+import { AgentSession, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
+//#region src/agent-native.d.ts
+type AgentDef = {
+  model: Model;
+  tools: Tool[];
+  instructions?: string;
+};
+declare class NativeRuntime implements Runtime {
+  private actors;
+  private readonly agents;
+  private readonly db;
+  constructor(agents: Record<string, AgentDef>, db: SyncSqlite);
+  session(agent: string, id: string): AgentSession;
+}
+declare function createNativeRuntime(agents: Record<string, AgentDef>, path?: string): Promise<NativeRuntime>;
+declare class MemoryRuntime implements Runtime {
+  private actors;
+  private stores;
+  private readonly agents;
+  constructor(agents: Record<string, AgentDef>);
+  session(agent: string, id: string): AgentSession;
+}
+type AgentBackend = "native" | "memory" | "durable";
+declare function createAgentRuntime(agents: Record<string, AgentDef>, opts?: {
+  backend?: AgentBackend;
+  path?: string;
+}): Promise<Runtime>;
+declare function mountAgent(agent: AgentDefinition, runtime: Runtime, opts?: {
+  chatPath?: string;
+  channels?: boolean;
+}): {
+  surface: (req: Request) => Promise<Response | null>;
+  fetch: (req: Request) => Promise<Response | null>;
+  startAll: () => Promise<void>;
+  ctx: ChannelContext;
+};
+//#endregion
+export { AgentBackend, AgentDef, MemoryRuntime, NativeRuntime, createAgentRuntime, createNativeRuntime, mountAgent };