@wervt/nuxt 0.2.12 → 0.2.14

package/README.md

@@ -20,7 +20,9 @@ export default defineNuxtConfig({
 - `useWervtUser()`: the signed-in wervt user, on the server and in the app.
 - `useValidatedBody()` / `useValidatedQuery()` / `useValidatedParams()`: valibot validation.
 - `useWervtTrack()`: custom events for wervt's cookieless analytics (page views are counted automatically).
-- `defineTool()` (server): tools in `server/tools/` that browser agents call through WebMCP.
+- `wervt: { feedback: { key } }` and `useWervtFeedback()`: the kontor feedback widget, reports go into a kontor project's triage.
+- `defineTool()` (server): tools in `server/tools/` that browser agents call through WebMCP, and
+  MCP clients (Claude Code, Cursor, …) at `/mcp`, signed in through wervt's OAuth login.
 - `nuxt dev` starts against the local wervt stack (Postgres, Electric) and a dev user.
 
 Deploy with [`@wervt/cli`](https://www.npmjs.com/package/@wervt/cli): `wervt deploy`.

package/dist/module.d.ts

@@ -18,12 +18,48 @@ export interface ModuleOptions {
    * Defaults to true; `false` leaves them out of the build.
    */
   webmcp?: boolean;
+  /**
+   * Serves the tools in `server/tools/` to MCP clients (Claude Code, Cursor, …) at `/mcp`,
+   * signed in through wervt's login. Defaults to true; `false` turns it off. An object names
+   * the server and tells clients how to use the tools (`instructions`).
+   */
+  mcp?: boolean | McpOptions;
   /**
    * Reports client-side navigations and `useWervtTrack()` events to wervt's usage analytics, so
    * page views count more than the first load. Defaults to true. Cookieless; page loads are
    * counted by the runtime either way.
    */
   analytics?: boolean;
+  /**
+   * The kontor feedback widget: a "Feedback" button that reports issues into a kontor project's
+   * triage, as the signed-in wervt user when the app's URL is an allowed origin of the key.
+   * With `true`, the key comes from `wervt env <app> --set NUXT_PUBLIC_WERVT_FEEDBACK_KEY=pk_…`
+   * (it can override a configured key the same way).
+   */
+  feedback?: FeedbackOptions | boolean;
+}
+export interface FeedbackOptions {
+  /** Public intake key of the kontor project (Project settings → Intake keys). */
+  key?: string;
+  /** The kontor instance. Defaults to https://kontor.wervt.app. */
+  url?: string;
+  /** Widget language. Defaults to the browser's. */
+  lang?: 'de' | 'en';
+  /** `none` hides the floating button; open the form with `useWervtFeedback().open()`. */
+  position?: 'bottom-right' | 'bottom-left' | 'none';
+  label?: string;
+  /** Accent color (any CSS color). */
+  color?: string;
+  /** Also load it in `nuxt dev`. Off by default: localhost usually isn't an allowed origin. */
+  dev?: boolean;
+}
+export interface McpOptions {
+  /** Server name clients show. Defaults to the app name. */
+  name?: string;
+  title?: string;
+  description?: string;
+  /** How to use the tools together, e.g. which one to call first. Clients pass it to the model. */
+  instructions?: string;
 }
 /** `server/wervt-tasks.json` in the build: the app's tasks and schedules, for the control plane. */
 export interface TasksManifest {

package/dist/module.js

@@ -1,7 +1,7 @@
 import { resolveAppName, setupDev } from "./dev.js";
 import { addImports, addPlugin, addServerHandler, addServerPlugin, addServerTemplate, createResolver, defineNuxtModule, getNuxtVersion, hasNuxtModule, installModule, useLogger } from "nuxt/kit";
 import { existsSync } from "node:fs";
-import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { builtinModules, createRequire } from "node:module";
 import { dirname, extname, join, relative, resolve, sep } from "node:path";
 import evlog from "evlog/nuxt";
@@ -163,12 +163,18 @@ var module_default = defineNuxtModule({
 			});
 		}
 		const toolsDir = join(nuxt.options.serverDir, "tools");
-		const tools = options.webmcp === false ? [] : await findTools(toolsDir);
-		if (tools.length > 0) {
-			addServerTemplate({
-				filename: "#wervt/tools",
-				getContents: () => `export const tools = {\n${tools.map(({ name, path }) => `  ${JSON.stringify(name)}: () => import(${JSON.stringify(path)}),`).join("\n")}\n}\n`
-			});
+		const webmcp = options.webmcp !== false;
+		let mcp = options.mcp !== false;
+		const tools = webmcp || mcp ? await findTools(toolsDir) : [];
+		if (tools.length > 0 && mcp && nitroMajor < 3) {
+			if (options.mcp) logger.warn("`/mcp` needs Nuxt 5; this app keeps its tools for WebMCP only.");
+			mcp = false;
+		}
+		if (tools.length > 0) addServerTemplate({
+			filename: "#wervt/tools",
+			getContents: () => `export const tools = {\n${tools.map(({ name, path }) => `  ${JSON.stringify(name)}: () => import(${JSON.stringify(path)}),`).join("\n")}\n}\n`
+		});
+		if (tools.length > 0 && webmcp) {
 			addServerHandler({
 				route: "/_wervt/tools",
 				method: "get",
@@ -184,7 +190,34 @@ var module_default = defineNuxtModule({
 				mode: "client"
 			});
 		}
-		if (nuxt.options.dev && options.webmcp !== false) nuxt.hook("builder:watch", async (event, path) => {
+		if (tools.length > 0 && mcp) {
+			const config = typeof options.mcp === "object" ? options.mcp : {};
+			const app = await resolveAppName(nuxt.options.rootDir, options.app);
+			const server = {
+				name: config.name ?? app,
+				version: await appVersion(nuxt.options.rootDir),
+				title: config.title,
+				description: config.description,
+				instructions: config.instructions
+			};
+			addServerTemplate({
+				filename: "#wervt/mcp",
+				getContents: () => `export const server = ${JSON.stringify(server)}\n`
+			});
+			addServerHandler({
+				route: "/mcp",
+				handler: resolver.resolve("./runtime/server/mcp")
+			});
+			addServerHandler({
+				route: "/.well-known/oauth-protected-resource/mcp",
+				handler: resolver.resolve("./runtime/server/mcp-metadata")
+			});
+			addServerHandler({
+				route: "/.well-known/oauth-authorization-server",
+				handler: resolver.resolve("./runtime/server/mcp-auth-server")
+			});
+		}
+		if (nuxt.options.dev && (webmcp || mcp)) nuxt.hook("builder:watch", async (event, path) => {
 			const file = relative(toolsDir, resolve(nuxt.options.srcDir, path));
 			if ((event === "add" || event === "unlink") && !file.startsWith("..")) await nuxt.callHook("restart");
 		});
@@ -232,6 +265,24 @@ var module_default = defineNuxtModule({
 				mode: "client"
 			});
 		}
+		const feedbackOptions = options.feedback === true ? {} : options.feedback;
+		if (feedbackOptions && (feedbackOptions.dev || !nuxt.options.dev)) {
+			const { dev: _, ...feedback } = feedbackOptions;
+			const config = nuxt.options.runtimeConfig.public;
+			config.wervt = {
+				...config.wervt,
+				feedback: {
+					key: "",
+					url: "https://kontor.wervt.app",
+					...feedback,
+					app: await resolveAppName(nuxt.options.rootDir, options.app)
+				}
+			};
+			addPlugin({
+				src: resolver.resolve("./runtime/app/plugins/feedback.client"),
+				mode: "client"
+			});
+		}
 		nuxt.options.build.transpile.push(resolver.resolve("./runtime"));
 		addImports([
 			{
@@ -257,6 +308,10 @@ var module_default = defineNuxtModule({
 			{
 				name: "useWervtUpdate",
 				from: resolver.resolve("./runtime/app/useWervtUpdate")
+			},
+			{
+				name: "useWervtFeedback",
+				from: resolver.resolve("./runtime/app/useWervtFeedback")
 			}
 		]);
 	}
@@ -288,6 +343,11 @@ async function findTools(dir) {
 	return tools;
 }
 const logger = useLogger("wervt");
+/** The app's package.json version, which MCP clients see as the server version. */
+async function appVersion(rootDir) {
+	const pkg = JSON.parse(await readFile(join(rootDir, "package.json"), "utf8").catch(() => "{}"));
+	return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+}
 /** Whether `name` is in a `node_modules` folder Node would look in from `dir`. */
 function hasPackage(dir, name) {
 	for (let current = dir;; current = dirname(current)) {

package/dist/node_modules/.pnpm/nitro@3.0.260903-beta/node_modules/nitro/dist/runtime/internal/task.js

@@ -1,5 +1,5 @@
-import { HTTPError } from "../../../../../../h3@2.0.2_crossws@0.4.15_srvx@1.0.5__ocache@0.3.0/node_modules/h3/dist/response.js";
 import { tasks } from "#nitro/virtual/tasks";
+import { HTTPError } from "h3";
 //#region ../../node_modules/.pnpm/nitro@3.0.260903-beta/node_modules/nitro/dist/runtime/internal/task.mjs
 const __runningTasks__ = {};
 async function runTask(name, { payload = {}, context = {} } = {}) {

package/dist/runtime/app/plugins/feedback.client.d.ts

@@ -0,0 +1,4 @@
+//#region src/runtime/app/plugins/feedback.client.d.ts
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+//#endregion
+export { _default as default };

package/dist/runtime/app/plugins/feedback.client.js

@@ -0,0 +1,32 @@
+import { pendingFeedbackContext } from "../useWervtFeedback.js";
+import { defineNuxtPlugin, onNuxtReady, useRuntimeConfig } from "#app";
+//#region src/runtime/app/plugins/feedback.client.ts
+var feedback_client_default = defineNuxtPlugin({
+	name: "wervt:feedback",
+	setup() {
+		const config = useRuntimeConfig();
+		const feedback = config.public.wervt?.feedback;
+		if (!feedback?.key) return;
+		onNuxtReady(() => {
+			const script = document.createElement("script");
+			script.src = `${feedback.url.replace(/\/$/, "")}/widget.js`;
+			script.async = true;
+			script.dataset.key = feedback.key;
+			for (const name of [
+				"lang",
+				"position",
+				"label",
+				"color"
+			]) if (feedback[name]) script.dataset[name] = feedback[name];
+			script.dataset.context = JSON.stringify({
+				app: feedback.app,
+				release: config.app.buildId,
+				...pendingFeedbackContext
+			});
+			script.addEventListener("load", () => window.kontor?.setContext(pendingFeedbackContext));
+			document.head.appendChild(script);
+		});
+	}
+});
+//#endregion
+export { feedback_client_default as default };

package/dist/runtime/app/useWervtFeedback.d.ts

@@ -0,0 +1,24 @@
+//#region src/runtime/app/useWervtFeedback.d.ts
+interface KontorWidget {
+  open(): void;
+  close(): void;
+  setContext(values: Record<string, unknown>): void;
+}
+declare global {
+  interface Window {
+    kontor?: KontorWidget;
+  }
+}
+export declare const pendingFeedbackContext: Record<string, unknown>;
+/**
+ * Controls the feedback widget (`wervt: { feedback: { key } }`): open it from your own button,
+ * or add context to every report, e.g. what the user was looking at.
+ *
+ * @example useWervtFeedback().setContext({ room: room.id })
+ */
+export declare function useWervtFeedback(): {
+  open: () => void | undefined;
+  close: () => void | undefined;
+  setContext(values: Record<string, unknown>): void;
+};
+//#endregion

package/dist/runtime/app/useWervtFeedback.js

@@ -0,0 +1,21 @@
+//#region src/runtime/app/useWervtFeedback.ts
+const pendingFeedbackContext = {};
+/**
+* Controls the feedback widget (`wervt: { feedback: { key } }`): open it from your own button,
+* or add context to every report, e.g. what the user was looking at.
+*
+* @example useWervtFeedback().setContext({ room: room.id })
+*/
+function useWervtFeedback() {
+	const widget = () => import.meta.client ? window.kontor : void 0;
+	return {
+		open: () => widget()?.open(),
+		close: () => widget()?.close(),
+		setContext(values) {
+			Object.assign(pendingFeedbackContext, values);
+			widget()?.setContext(values);
+		}
+	};
+}
+//#endregion
+export { pendingFeedbackContext, useWervtFeedback };

package/dist/runtime/server/index.d.ts

@@ -1,9 +1,10 @@
 import { WervtUser } from "../shared/user.js";
 import { useDb } from "./db.js";
 import { createEvlogError, log, useLogger } from "./logger.js";
+import { McpTokenContext } from "./mcp-auth.js";
 import { ShapeOptions, proxyShape } from "./shape.js";
 import { Task, TaskEvent, TaskResult, defineTask } from "./tasks.js";
 import { SafeResult, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh } from "./validate.js";
 import { Tool, defineTool } from "./tools.js";
 import { useWervtUser } from "./user.js";
-export { type SafeResult, type ShapeOptions, type Task, type TaskEvent, type TaskResult, type Tool, type WervtUser, createEvlogError, defineTask, defineTool, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };
+export { type McpTokenContext, type SafeResult, type ShapeOptions, type Task, type TaskEvent, type TaskResult, type Tool, type WervtUser, createEvlogError, defineTask, defineTool, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };

package/dist/runtime/server/mcp-auth-server.d.ts

@@ -0,0 +1,4 @@
+//#region src/runtime/server/mcp-auth-server.d.ts
+declare const _default: import("nuxt/server").EventHandler<Promise<Response>>;
+//#endregion
+export { _default as default };

package/dist/runtime/server/mcp-auth-server.js

@@ -0,0 +1,21 @@
+import { CORS, fetchAuth, mcpEndpoint } from "./mcp-auth.js";
+import { defineEventHandler } from "nuxt/server";
+//#region src/runtime/server/mcp-auth-server.ts
+var mcp_auth_server_default = defineEventHandler(async (event) => {
+	const endpoint = mcpEndpoint(event);
+	if (event.req.method === "OPTIONS") return new Response(null, {
+		status: 204,
+		headers: CORS
+	});
+	if (!endpoint) return Response.json({ error: "No login configured." }, { status: 404 });
+	const issuer = new URL(endpoint.issuer);
+	const url = new URL(`/.well-known/oauth-authorization-server${issuer.pathname}`, issuer);
+	const res = await fetchAuth(url.href);
+	if (!res.ok) return Response.json({ error: "authorization_server_unavailable" }, {
+		status: 502,
+		headers: CORS
+	});
+	return Response.json(await res.json(), { headers: CORS });
+});
+//#endregion
+export { mcp_auth_server_default as default };

package/dist/runtime/server/mcp-auth.d.ts

@@ -0,0 +1,59 @@
+import { WervtUser } from "../shared/user.js";
+import { RequestEvent } from "nuxt/server";
+//#region src/runtime/server/mcp-auth.d.ts
+/** What `wervt:mcp:token` handlers get: set `user` to accept the token. */
+export interface McpTokenContext {
+  token: string;
+  event: RequestEvent;
+  user?: WervtUser;
+}
+declare module 'nuxt/schema' {
+  interface NuxtServerHooks {
+    /**
+     * A bearer token on `/mcp` that isn't a wervt access token, e.g. the app's own API token
+     * for scripts. Set `ctx.user` to accept it; tools then see that user in `useWervtUser`.
+     */
+    'wervt:mcp:token': (ctx: McpTokenContext) => void | Promise<void>;
+  }
+}
+export interface McpEndpoint {
+  /** This app's `/mcp`, the audience its access tokens must carry. */
+  resource: string;
+  /** wervt's login as OAuth issuer, e.g. `https://auth.wervt.app/api/auth`. */
+  issuer: string;
+  /** RFC 9728 metadata of `resource`, where the 401 points MCP clients. */
+  metadataUrl: string;
+}
+/**
+ * Where this app's `/mcp` and wervt's login live, from the runtime's `WERVT_APP_URL` and
+ * `WERVT_AUTH_URL`. Undefined without a login: `nuxt dev` then serves `/mcp` as the dev user.
+ */
+export declare function mcpEndpoint(event: RequestEvent): McpEndpoint | undefined;
+/** Discovery documents are public; browser-based MCP clients read them cross-origin. */
+export declare const CORS: {
+  'access-control-allow-origin': string;
+  'access-control-allow-methods': string;
+  'access-control-allow-headers': string;
+  'access-control-max-age': string;
+};
+/** RFC 9728: tells MCP clients which login issues tokens for `/mcp`. */
+export declare function protectedResourceMetadata(endpoint: McpEndpoint): {
+  resource: string;
+  authorization_servers: string[];
+  bearer_methods_supported: string[];
+  scopes_supported: string[];
+  resource_name: string;
+};
+/**
+ * Fetches from wervt's login. Inside wervt it's another isolate on the same runtime, so the
+ * request goes to the runtime directly (named by `x-wervt-host`): no round trip through the
+ * internet, and `*.localhost` of the local stack doesn't resolve inside the runtime anyway.
+ */
+export declare function fetchAuth(issuerUrl: string, init?: RequestInit): Promise<Response>;
+/** Verifies a wervt access token for `endpoint` and returns its user. */
+export declare function verifyAccessToken(token: string, endpoint: McpEndpoint): Promise<WervtUser | undefined>;
+/** The user a bearer token on `/mcp` stands for: a wervt access token, or the app's own. */
+export declare function authenticateMcp(token: string, event: RequestEvent, endpoint: McpEndpoint): Promise<WervtUser | undefined>;
+/** Makes `useWervtUser(event)` return the token's user while a tool runs over MCP. */
+export declare function setMcpUser(event: RequestEvent, user: WervtUser): void;
+//#endregion

package/dist/runtime/server/mcp-auth.js

@@ -0,0 +1,98 @@
+import { userFromClaims } from "./mcp-claims.js";
+import { getRequestURL, useServerHooks } from "nuxt/server";
+import { createRemoteJWKSet, customFetch, errors, jwtVerify } from "jose";
+//#region src/runtime/server/mcp-auth.ts
+const trimSlash = (url) => url.replace(/\/+$/, "");
+/**
+* Where this app's `/mcp` and wervt's login live, from the runtime's `WERVT_APP_URL` and
+* `WERVT_AUTH_URL`. Undefined without a login: `nuxt dev` then serves `/mcp` as the dev user.
+*/
+function mcpEndpoint(event) {
+	const authUrl = process.env.WERVT_AUTH_URL;
+	if (!authUrl) return void 0;
+	const appUrl = trimSlash(process.env.WERVT_APP_URL ?? getRequestURL(event).origin);
+	return {
+		resource: `${appUrl}/mcp`,
+		issuer: `${trimSlash(authUrl)}/api/auth`,
+		metadataUrl: `${appUrl}/.well-known/oauth-protected-resource/mcp`
+	};
+}
+/** Discovery documents are public; browser-based MCP clients read them cross-origin. */
+const CORS = {
+	"access-control-allow-origin": "*",
+	"access-control-allow-methods": "GET, OPTIONS",
+	"access-control-allow-headers": "*",
+	"access-control-max-age": "86400"
+};
+/** RFC 9728: tells MCP clients which login issues tokens for `/mcp`. */
+function protectedResourceMetadata(endpoint) {
+	return {
+		resource: endpoint.resource,
+		authorization_servers: [endpoint.issuer],
+		bearer_methods_supported: ["header"],
+		scopes_supported: [
+			"openid",
+			"profile",
+			"email",
+			"offline_access"
+		],
+		resource_name: new URL(endpoint.resource).hostname.split(".")[0]
+	};
+}
+/**
+* Fetches from wervt's login. Inside wervt it's another isolate on the same runtime, so the
+* request goes to the runtime directly (named by `x-wervt-host`): no round trip through the
+* internet, and `*.localhost` of the local stack doesn't resolve inside the runtime anyway.
+*/
+function fetchAuth(issuerUrl, init = {}) {
+	const runtime = process.env.WERVT_RUNTIME_URL;
+	if (!runtime) return fetch(issuerUrl, init);
+	const url = new URL(issuerUrl);
+	const headers = new Headers(init.headers);
+	headers.set("x-wervt-host", url.host);
+	return fetch(new URL(url.pathname + url.search, runtime), {
+		...init,
+		headers
+	});
+}
+const keySets = /* @__PURE__ */ new Map();
+function keySet(issuer) {
+	let keys = keySets.get(issuer);
+	if (!keys) {
+		keys = createRemoteJWKSet(new URL(`${issuer}/jwks`), { [customFetch]: (url, init) => fetchAuth(url, init) });
+		keySets.set(issuer, keys);
+	}
+	return keys;
+}
+/** Verifies a wervt access token for `endpoint` and returns its user. */
+async function verifyAccessToken(token, endpoint) {
+	try {
+		const { payload } = await jwtVerify(token, keySet(endpoint.issuer), {
+			issuer: endpoint.issuer,
+			audience: endpoint.resource,
+			requiredClaims: ["exp", "sub"],
+			clockTolerance: 5
+		});
+		return userFromClaims(payload);
+	} catch (error) {
+		if (error instanceof errors.JOSEError && !(error instanceof errors.JWKSTimeout)) return void 0;
+		throw error;
+	}
+}
+/** The user a bearer token on `/mcp` stands for: a wervt access token, or the app's own. */
+async function authenticateMcp(token, event, endpoint) {
+	const user = await verifyAccessToken(token, endpoint);
+	if (user) return user;
+	const ctx = {
+		token,
+		event
+	};
+	await useServerHooks().callHook("wervt:mcp:token", ctx);
+	return ctx.user;
+}
+/** Makes `useWervtUser(event)` return the token's user while a tool runs over MCP. */
+function setMcpUser(event, user) {
+	event.context.wervtMcpUser = user;
+}
+//#endregion
+export { CORS, authenticateMcp, fetchAuth, mcpEndpoint, protectedResourceMetadata, setMcpUser, verifyAccessToken };

package/dist/runtime/server/mcp-claims.d.ts

@@ -0,0 +1,5 @@
+import { WervtUser } from "../shared/user.js";
+//#region src/runtime/server/mcp-claims.d.ts
+/** The wervt user an access token's claims name, or undefined when they're incomplete. */
+export declare function userFromClaims(claims: Record<string, unknown>): WervtUser | undefined;
+//#endregion

package/dist/runtime/server/mcp-claims.js

@@ -0,0 +1,18 @@
+//#region src/runtime/server/mcp-claims.ts
+/** The wervt user an access token's claims name, or undefined when they're incomplete. */
+function userFromClaims(claims) {
+	const { sub, email, name, picture, accounts } = claims;
+	if (typeof sub !== "string" || !sub || typeof email !== "string") return void 0;
+	return {
+		id: sub,
+		email: email.toLowerCase(),
+		name: typeof name === "string" ? name : void 0,
+		image: typeof picture === "string" ? picture : void 0,
+		accounts: isAccounts(accounts) ? accounts : void 0
+	};
+}
+function isAccounts(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((id) => typeof id === "string");
+}
+//#endregion
+export { userFromClaims };

package/dist/runtime/server/mcp-metadata.d.ts

@@ -0,0 +1,4 @@
+//#region src/runtime/server/mcp-metadata.d.ts
+declare const _default: import("nuxt/server").EventHandler<Response>;
+//#endregion
+export { _default as default };

package/dist/runtime/server/mcp-metadata.js

@@ -0,0 +1,14 @@
+import { CORS, mcpEndpoint, protectedResourceMetadata } from "./mcp-auth.js";
+import { defineEventHandler } from "nuxt/server";
+//#region src/runtime/server/mcp-metadata.ts
+var mcp_metadata_default = defineEventHandler((event) => {
+	const endpoint = mcpEndpoint(event);
+	if (event.req.method === "OPTIONS") return new Response(null, {
+		status: 204,
+		headers: CORS
+	});
+	if (!endpoint) return Response.json({ error: "No login configured." }, { status: 404 });
+	return Response.json(protectedResourceMetadata(endpoint), { headers: CORS });
+});
+//#endregion
+export { mcp_metadata_default as default };

package/dist/runtime/server/mcp.d.ts

@@ -0,0 +1,4 @@
+//#region src/runtime/server/mcp.d.ts
+declare const _default: import("nuxt/server").EventHandler<Promise<unknown>>;
+//#endregion
+export { _default as default };

package/dist/runtime/server/mcp.js

@@ -0,0 +1,112 @@
+import { devUser } from "../shared/user.js";
+import { useLogger } from "./logger.js";
+import { safeValidate } from "./validate.js";
+import { authenticateMcp, mcpEndpoint, setMcpUser } from "./mcp-auth.js";
+import { loadTool, toolInputSchema } from "./tool-handlers.js";
+import { defineEventHandler } from "nuxt/server";
+import { server } from "#wervt/mcp";
+import { tools } from "#wervt/tools";
+import { defineMcpHandler } from "h3-mcp";
+//#region src/runtime/server/mcp.ts
+const MAX_BODY = 4194304;
+const text = (value) => [{
+	type: "text",
+	text: value
+}];
+/** What the client sees of a thrown error: its status and message, like the WebMCP route. */
+function errorResult(error) {
+	const { status, message, data } = error ?? {};
+	let body = message || "Tool failed.";
+	if (typeof status === "number") body = `[${status}] ${body}`;
+	if (data !== void 0) body += `\n${JSON.stringify(data)}`;
+	return {
+		content: text(body),
+		isError: true
+	};
+}
+function toMcpTool(name, tool) {
+	return {
+		name,
+		description: tool.description,
+		inputSchema: toolInputSchema(tool),
+		annotations: { readOnlyHint: tool.readOnly === true },
+		async handler(args, event) {
+			const requestEvent = event;
+			useLogger(requestEvent).set({
+				tool: name,
+				mcp: true
+			});
+			let input;
+			if (tool.input) {
+				const result = await safeValidate(tool.input, args ?? {});
+				if (!result.success) return {
+					content: text(`Invalid arguments.\n${JSON.stringify(result.issues)}`),
+					isError: true
+				};
+				input = result.data;
+			}
+			try {
+				const result = await tool.handler(requestEvent, input);
+				return { content: result === void 0 ? [] : text(JSON.stringify(result)) };
+			} catch (error) {
+				return errorResult(error);
+			}
+		}
+	};
+}
+let handler;
+async function createHandler() {
+	const definitions = (await Promise.all(Object.keys(tools).map(async (name) => {
+		const tool = await loadTool(name);
+		return tool ? toMcpTool(name, tool) : void 0;
+	}))).filter((tool) => tool !== void 0);
+	return defineMcpHandler((event) => ({
+		...server,
+		tools: definitions,
+		origin: mcpEndpoint(event) ? false : {}
+	}));
+}
+function unauthorized(metadataUrl, invalid) {
+	const params = [`resource_metadata="${metadataUrl}"`];
+	if (invalid) params.push("error=\"invalid_token\"");
+	return new Response(JSON.stringify({ error: "Sign in with wervt to use this app over MCP." }), {
+		status: 401,
+		headers: {
+			"content-type": "application/json",
+			"www-authenticate": `Bearer ${params.join(", ")}`,
+			"cache-control": "no-store"
+		}
+	});
+}
+var mcp_default = defineEventHandler(async (event) => {
+	const endpoint = mcpEndpoint(event);
+	if (endpoint) {
+		const authorization = event.req.headers.get("authorization") ?? "";
+		const token = /^bearer\s+(\S+)$/i.exec(authorization)?.[1];
+		const user = token ? await authenticateMcp(token, event, endpoint) : void 0;
+		if (!user) return unauthorized(endpoint.metadataUrl, Boolean(token));
+		setMcpUser(event, user);
+	} else if (import.meta.dev) {
+		const user = devUser(true);
+		if (user) setMcpUser(event, user);
+	} else return Response.json({ error: "MCP needs WERVT_AUTH_URL, which the wervt runtime sets." }, { status: 503 });
+	if (event.req.method === "POST") {
+		if (Number(event.req.headers.get("content-length") ?? 0) > MAX_BODY) return Response.json({ error: "Body too large." }, { status: 413 });
+		const body = await event.req.arrayBuffer();
+		if (body.byteLength > MAX_BODY) return Response.json({ error: "Body too large." }, { status: 413 });
+		const h3Event = event;
+		h3Event.req = new Request(event.req.url, {
+			method: "POST",
+			headers: event.req.headers,
+			body,
+			signal: event.req.signal
+		});
+	}
+	handler ??= createHandler().catch((error) => {
+		handler = void 0;
+		throw error;
+	});
+	return (await handler)(event);
+});
+//#endregion
+export { mcp_default as default };

package/dist/runtime/server/task-run-nitro2.d.ts

@@ -3,8 +3,8 @@ declare const _default: import("nuxt/server").EventHandler<Promise<{
   error: string;
   result?: undefined;
 } | {
-  result: {} | null;
   error?: undefined;
+  result: {} | null;
 }>>;
 //#endregion
 export { _default as default };

package/dist/runtime/server/tool-handlers.d.ts

@@ -1,4 +1,11 @@
+import { Input } from "./validate.js";
+import { Tool } from "./tools.js";
 //#region src/runtime/server/tool-handlers.d.ts
+export declare function loadTool(name: string): Promise<Tool<Input | undefined, unknown> | undefined>;
+export declare function toolInputSchema(tool: Tool): import("@valibot/to-json-schema").JsonSchema | {
+  type: string;
+  properties: {};
+};
 /** `GET /_wervt/tools`: name, description and JSON Schema of each tool, for the client plugin. */
 export declare const listTools: import("nuxt/server").EventHandler<Promise<{
   name: string;

package/dist/runtime/server/tool-handlers.js

@@ -1,13 +1,13 @@
 import { useLogger } from "./logger.js";
 import { safeValidate, toSchema } from "./validate.js";
 import { defineEventHandler } from "nuxt/server";
-import { toJsonSchema } from "@valibot/to-json-schema";
 import { tools } from "#wervt/tools";
+import { toJsonSchema } from "@valibot/to-json-schema";
 //#region src/runtime/server/tool-handlers.ts
-async function load(name) {
+async function loadTool(name) {
 	return (await (Object.hasOwn(tools, name) ? tools[name] : void 0)?.())?.default;
 }
-function inputSchema(tool) {
+function toolInputSchema(tool) {
 	if (!tool.input) return {
 		type: "object",
 		properties: {}
@@ -23,12 +23,12 @@ function inputSchema(tool) {
 const listTools = defineEventHandler(async (event) => {
 	event.res.headers.set("cache-control", "no-store");
 	return (await Promise.all(Object.keys(tools).map(async (name) => {
-		const tool = await load(name);
+		const tool = await loadTool(name);
 		if (!tool) return void 0;
 		return {
 			name,
 			description: tool.description,
-			inputSchema: inputSchema(tool),
+			inputSchema: toolInputSchema(tool),
 			readOnly: tool.readOnly === true
 		};
 	}))).filter((tool) => tool !== void 0);
@@ -45,7 +45,7 @@ const runTool = defineEventHandler(async (event) => {
 		return { error: "Tools can only be called from the app itself." };
 	}
 	const name = decodeURIComponent(new URL(event.req.url).pathname.split("/").pop() ?? "");
-	const tool = await load(name);
+	const tool = await loadTool(name);
 	if (!tool) {
 		event.res.status = 404;
 		return { error: `No tool named ${name}.` };
@@ -67,4 +67,4 @@ const runTool = defineEventHandler(async (event) => {
 	return { result: await tool.handler(event, input) ?? null };
 });
 //#endregion
-export { listTools, runTool };
+export { listTools, loadTool, runTool, toolInputSchema };

package/dist/runtime/server/user.d.ts

@@ -1,11 +1,11 @@
 import { DEV_LOGIN_COOKIE, WervtUser, parseWervtUser } from "../shared/user.js";
-import "./user.js";
 import { RequestEvent } from "nuxt/server";
 //#region src/runtime/server/user.d.ts
 /**
  * The signed-in wervt user, or `undefined` when nobody is signed in.
  * Private apps always have one (the runtime checked the login and the allow-list); public
  * apps get one when the visitor is signed in. Send people to `/_wervt/login` to sign in.
+ * In a tool called over MCP, it's the user the client signed in as.
  */
 export declare const useWervtUser: (event: RequestEvent) => WervtUser | undefined;
 //#endregion

package/dist/runtime/server/user.js

@@ -1,11 +1,13 @@
 import { DEV_LOGIN_COOKIE, devUser, parseWervtUser } from "../shared/user.js";
 import { getCookie } from "nuxt/server";
 //#region src/runtime/server/user.ts
+const MCP_USER = "wervtMcpUser";
 /**
 * The signed-in wervt user, or `undefined` when nobody is signed in.
 * Private apps always have one (the runtime checked the login and the allow-list); public
 * apps get one when the visitor is signed in. Send people to `/_wervt/login` to sign in.
+* In a tool called over MCP, it's the user the client signed in as.
 */
-const useWervtUser = (event) => parseWervtUser(event.req.headers.get("x-wervt-user")) ?? devUser(getCookie(event, "wervt_dev_login") === "1");
+const useWervtUser = (event) => event.context[MCP_USER] ?? parseWervtUser(event.req.headers.get("x-wervt-user")) ?? devUser(getCookie(event, "wervt_dev_login") === "1");
 //#endregion
 export { DEV_LOGIN_COOKIE, parseWervtUser, useWervtUser };

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@wervt/nuxt",
-  "version": "0.2.12",
-  "description": "Nuxt module for apps hosted on wervt: database, live data and runtime setup.",
+  "version": "0.2.14",
+  "description": "Nuxt module for apps hosted on wervt: database, live data, MCP and runtime setup.",
   "keywords": [
     "drizzle",
     "electric",
+    "mcp",
     "nuxt",
     "nuxt-module",
     "postgres",
@@ -42,19 +43,28 @@
     "@valibot/to-json-schema": "^1.8.0",
     "aws4fetch": "^1.0.20",
     "evlog": "^2.30.1",
+    "h3-mcp": "0.2.0",
+    "jose": "^6.2.12",
     "postgres": "^3.4.9",
     "valibot": "^1.5.0"
   },
   "devDependencies": {
     "drizzle-orm": "1.0.0-rc.4",
+    "h3": "2.0.2",
     "nitro": "3.0.260903-beta",
     "nuxt": "npm:nuxt-nightly@5x",
     "vue": "^3.5.43"
   },
   "peerDependencies": {
     "drizzle-orm": "1.0.0-rc.4",
+    "h3": "^2.0.1",
     "nuxt": ">=4.2"
   },
+  "peerDependenciesMeta": {
+    "h3": {
+      "optional": true
+    }
+  },
   "scripts": {
     "build": "vp pack"
   }

package/dist/node_modules/.pnpm/h3@2.0.2_crossws@0.4.15_srvx@1.0.5__ocache@0.3.0/node_modules/h3/dist/response.js

@@ -1,96 +0,0 @@
-String.raw`%(?:2[146-9A-E]|3[0-9ABD]|4[0-9A-F]|5[0-9ABDF]|6[1-9A-F]|7[0-9ACE])`;
-const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
-function sanitizeStatusMessage(statusMessage = "") {
-	return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
-}
-function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
-	if (!statusCode) return defaultStatusCode;
-	if (typeof statusCode === "string") statusCode = +statusCode;
-	if (!Number.isInteger(statusCode) || statusCode < 100 || statusCode > 599) return defaultStatusCode;
-	return statusCode;
-}
-var HTTPError = class HTTPError extends Error {
-	get name() {
-		return "HTTPError";
-	}
-	status;
-	statusText;
-	headers;
-	cause;
-	data;
-	body;
-	unhandled;
-	static isError(input) {
-		return input instanceof Error && input?.name === "HTTPError" && input.status > 99;
-	}
-	static status(status, statusText, details) {
-		return new HTTPError({
-			...details,
-			statusText,
-			status
-		});
-	}
-	constructor(arg1, arg2) {
-		let messageInput;
-		let details;
-		if (typeof arg1 === "string") {
-			messageInput = arg1;
-			details = arg2;
-		} else details = arg1;
-		const status = sanitizeStatusCode(details?.status || details?.statusCode || (details?.cause)?.status || (details?.cause)?.statusCode, 500);
-		const statusText = sanitizeStatusMessage(details?.statusText || details?.statusMessage || (details?.cause)?.statusText || (details?.cause)?.statusMessage);
-		const message = messageInput || details?.message || (details?.cause)?.message || details?.statusText || details?.statusMessage || [
-			"HTTPError",
-			status,
-			statusText
-		].filter(Boolean).join(" ");
-		super(message, { cause: details });
-		this.cause = details;
-		this.status = status;
-		this.statusText = statusText || void 0;
-		const rawHeaders = details?.headers || (details?.cause)?.headers;
-		this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
-		this.unhandled = details?.unhandled ?? (details?.cause)?.unhandled ?? void 0;
-		this.data = details?.data;
-		this.body = details?.body;
-	}
-	get statusCode() {
-		return this.status;
-	}
-	get statusMessage() {
-		return this.statusText;
-	}
-	toJSON() {
-		const unhandled = this.unhandled;
-		return {
-			status: this.status,
-			statusText: this.statusText,
-			unhandled,
-			message: unhandled ? "HTTPError" : this.message,
-			data: unhandled ? void 0 : this.data,
-			...unhandled ? void 0 : this.body
-		};
-	}
-};
-const kHTTPResponse = /* @__PURE__ */ Symbol.for("h3.HTTPResponse");
-var HTTPResponse = class {
-	#headers;
-	#init;
-	body;
-	constructor(body, init) {
-		this.body = body;
-		this.#init = init;
-	}
-	get status() {
-		return this.#init?.status;
-	}
-	get statusText() {
-		return this.#init?.statusText;
-	}
-	get headers() {
-		return this.#headers ||= new Headers(this.#init?.headers);
-	}
-};
-HTTPResponse.prototype[kHTTPResponse] = true;
-//#endregion
-export { HTTPError, HTTPResponse, sanitizeStatusCode, sanitizeStatusMessage };