@neopress/mcp 1.3.1 → 1.4.0

package/dist/index.js

@@ -3,9 +3,11 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync
 import { basename, dirname, join } from "node:path";
 import { z } from "zod";
 import { homedir } from "node:os";
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
 import { createServer } from "node:http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { Redis } from "@upstash/redis";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -22987,6 +22989,7 @@ function serializeTemplate(t) {
 		referenceUrl: t.reference_url,
 		previewImgUrls: t.preview_img_urls,
 		previewVideoUrl: t.preview_video_url ?? null,
+		language: t.language ?? null,
 		createdAt: t.created_at
 	};
 }
@@ -23960,7 +23963,7 @@ var TemplatesEndpoint = class {
 		if (siteIds.length === 0) return [];
 		const namePrefix = params?.namePrefix?.trim();
 		const limit = Math.min(Math.max(params?.limit ?? 100, 1), 500);
-		let query = this.client.db.from("templates").select("id, name, reference_url, preview_img_urls, description, created_at").in("id", siteIds);
+		let query = this.client.db.from("templates").select("id, name, reference_url, preview_img_urls, description, language, created_at").in("id", siteIds);
 		if (namePrefix) query = query.ilike("name", `${namePrefix}%`);
 		if (params?.order) query = query.order("created_at", { ascending: params.order === "asc" });
 		query = query.limit(limit);
@@ -23976,6 +23979,7 @@ var TemplatesEndpoint = class {
 				referenceUrl: t.reference_url,
 				previewImgUrls: t.preview_img_urls ?? null,
 				description: t.description ?? null,
+				language: t.language ?? null,
 				createdAt: t.created_at
 			};
 		});
@@ -24378,7 +24382,7 @@ function getSiteId(siteIdOverride) {
 	if (projectConfig.siteId) return projectConfig.siteId;
 	return loadSession().activeSiteId;
 }
-function setActiveSiteId(siteId) {
+async function setActiveSiteId(siteId) {
 	saveSession({
 		...loadSession(),
 		activeSiteId: siteId
@@ -24492,8 +24496,9 @@ Use these rules before generating pages, collection schemas, entries, forms, or
 - Reusable templates are normal Neopress sites marked by a \`templates\` metadata row.
 - \`templates.id\` equals \`sites.id\`.
 - Build layout, pages, collections, entries, forms, assets, compile, publish, and verify before marking a finished template.
-- Use \`neopress_template_mark\` to create or update the metadata row with \`name\`, required \`referenceUrl\`, required \`previewImgUrls\` (at least one), and optional \`description\` and \`previewVideoUrl\`. The gallery card renders \`previewImgUrls[0]\` at rest and cross-fades to \`previewVideoUrl\` on hover, so the first preview image must be that video's first frame.
+- Use \`neopress_template_mark\` to create or update the metadata row with \`name\`, required \`referenceUrl\`, required \`language\`, required \`previewImgUrls\` (at least one), and optional \`description\` and \`previewVideoUrl\`. The gallery card renders \`previewImgUrls[0]\` at rest and cross-fades to \`previewVideoUrl\` on hover, so the first preview image must be that video's first frame.
 - \`referenceUrl\` is a single http(s) provenance URL. \`description\` is an optional summary of the template (max 150 characters).
+- \`language\` is the language the template's own content is written in, as a two-letter lowercase ISO 639-1 code (\`ko\`, \`en\`, \`es\`). Region locales like \`en-US\` are rejected.
 - Template metadata does not replace page TSX, CMS content, forms, or publish state.
 - Use \`neopress_template_delete\` only for explicit template-site hard deletion. It removes the metadata row and connected site.
 
@@ -24502,6 +24507,7 @@ Use these rules before generating pages, collection schemas, entries, forms, or
 - Dynamic pages require a collection, a page path like \`/blog/[slug]\`, a numeric \`collectionId\`, matching entries, entry publish, page compile, and site publish.
 - \`queryConfig\` is stored in page \`draftMeta.queryConfig\`.
 - Query labels become React props. Entry query results are flattened, so use \`post.body\` instead of \`post.data.body\`.
+- A query may include \`collectionWindow\` on an \`entries\` query for a dynamic detail route. Its label receives \`{ before, after, items }\`; each is a flattened-entry array around the current entry, and \`items\` combines both directions. Windows use \`published_at DESC, id DESC\`, allow 0–20 entries per direction, and may only declare that exact order. Use the exact configured label, never a guessed prop name. Optional \`matchFields\` compare raw anchor-snapshot fields only when the source field has a value.
 - Initial CMS data arrives through those injected query props. \`entryClient\`, when injected in reader/preview for a site handle, is only a client-side auxiliary for load-more/filter/get/create interactions after the initial render; do not use it for initial render or server data loading.
 - Use numeric \`collection_id\` filters. Runtime controls site, status, locale, deleted state, and published snapshots.
 
@@ -24561,6 +24567,198 @@ function toToolError(error) {
 		}]
 	};
 }
+var AssetImportError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AssetImportError";
+	}
+};
+function ipv4ToInt(address) {
+	const parts = address.split(".");
+	if (parts.length !== 4) return null;
+	let value = 0;
+	for (const part of parts) {
+		const octet = Number(part);
+		if (!Number.isInteger(octet) || octet < 0 || octet > 255) return null;
+		value = value * 256 + octet;
+	}
+	return value;
+}
+/**
+* Blocks every address that is not routable on the public internet. Includes
+* the ranges that matter for cloud metadata (169.254.0.0/16) and for reaching
+* back into our own VPC.
+*/
+function isBlockedAddress(address) {
+	const family = isIP(address);
+	if (family === 4) {
+		const value = ipv4ToInt(address);
+		if (value === null) return true;
+		const inRange = (cidrBase, bits) => {
+			const base = ipv4ToInt(cidrBase);
+			if (base === null) return false;
+			const mask = bits === 0 ? 0 : -1 << 32 - bits >>> 0;
+			return (value & mask) === (base & mask);
+		};
+		return inRange("0.0.0.0", 8) || inRange("10.0.0.0", 8) || inRange("100.64.0.0", 10) || inRange("127.0.0.0", 8) || inRange("169.254.0.0", 16) || inRange("172.16.0.0", 12) || inRange("192.0.0.0", 24) || inRange("192.168.0.0", 16) || inRange("198.18.0.0", 15) || inRange("224.0.0.0", 4) || inRange("240.0.0.0", 4);
+	}
+	if (family === 6) {
+		const normalized = address.toLowerCase().split("%")[0] ?? "";
+		const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+		if (mapped?.[1]) return isBlockedAddress(mapped[1]);
+		if (normalized === "::" || normalized === "::1") return true;
+		return normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb");
+	}
+	return true;
+}
+/**
+* Rejects non-public destinations. Resolving here (rather than trusting the
+* hostname) is what stops `metadata.internal`-style names and DNS entries that
+* deliberately point at private space.
+*/
+async function assertPublicUrl(rawUrl, resolver = defaultResolver) {
+	let url;
+	try {
+		url = new URL(rawUrl);
+	} catch {
+		throw new AssetImportError(`Not a valid URL: ${rawUrl}`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new AssetImportError(`Only http(s) URLs can be imported, got ${url.protocol}`);
+	const hostname = url.hostname.replace(/^\[|\]$/g, "");
+	const addresses = isIP(hostname) ? [hostname] : await resolver(hostname);
+	if (addresses.length === 0) throw new AssetImportError(`Could not resolve ${url.hostname}`);
+	for (const address of addresses) if (isBlockedAddress(address)) throw new AssetImportError(`Refusing to fetch ${url.hostname}: it resolves to the non-public address ${address}`);
+	return url;
+}
+async function defaultResolver(hostname) {
+	return (await lookup(hostname, { all: true }).catch(() => [])).map((record) => record.address);
+}
+/**
+* Fetches the URL with every hop validated, then reads the body under a hard
+* byte cap. `redirect: 'manual'` is deliberate: letting fetch follow redirects
+* would skip the address check on the hops in between.
+*/
+async function fetchImportableAsset(rawUrl, options) {
+	const maxBytes = options.maxBytes ?? 52428800;
+	let currentUrl = rawUrl;
+	for (let hop = 0; hop <= 3; hop += 1) {
+		const url = await assertPublicUrl(currentUrl, options.resolver);
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 3e4);
+		let response;
+		try {
+			response = await options.fetch(url.toString(), {
+				redirect: "manual",
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+		if (response.status >= 300 && response.status < 400) {
+			const location = response.headers.get("location");
+			if (!location) throw new AssetImportError(`Redirect from ${url.toString()} had no Location header`);
+			currentUrl = new URL(location, url).toString();
+			continue;
+		}
+		if (!response.ok) throw new AssetImportError(`Source responded ${response.status} ${response.statusText || ""}`.trim());
+		const declaredLength = Number(response.headers.get("content-length"));
+		if (Number.isFinite(declaredLength) && declaredLength > maxBytes) throw new AssetImportError(`Source is ${declaredLength} bytes, over the ${maxBytes} byte limit`);
+		return {
+			bytes: await readCapped(response, maxBytes),
+			contentType: (response.headers.get("content-type") || "").split(";")[0]?.trim() || "",
+			finalUrl: url.toString()
+		};
+	}
+	throw new AssetImportError(`Too many redirects (max 3)`);
+}
+/** Reads the body incrementally so a lying Content-Length cannot blow the cap. */
+async function readCapped(response, maxBytes) {
+	const reader = response.body?.getReader();
+	if (!reader) {
+		const buffer = new Uint8Array(await response.arrayBuffer());
+		if (buffer.byteLength > maxBytes) throw new AssetImportError(`Source exceeds the ${maxBytes} byte limit`);
+		return buffer;
+	}
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (!value) continue;
+		total += value.byteLength;
+		if (total > maxBytes) {
+			await reader.cancel().catch(() => {});
+			throw new AssetImportError(`Source exceeds the ${maxBytes} byte limit`);
+		}
+		chunks.push(value);
+	}
+	const merged = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return merged;
+}
+/**
+* Derives a storage-safe file name. The source path is only a hint — anything
+* outside the allowed character set is dropped so a crafted URL cannot steer
+* the object key.
+*/
+function deriveImportFileName(finalUrl, contentType) {
+	const sanitized = decodeURIComponent(new URL(finalUrl).pathname.split("/").pop() || "").replace(/[^\w.-]/g, "").replace(/^\.+/, "");
+	if (sanitized && /\.[a-z0-9]{1,5}$/i.test(sanitized)) return sanitized.slice(0, 120);
+	const extension = extensionForContentType(contentType);
+	const stem = (sanitized || "imported-asset").slice(0, 100);
+	return extension ? `${stem}.${extension}` : stem;
+}
+function extensionForContentType(contentType) {
+	return {
+		"image/avif": "avif",
+		"image/gif": "gif",
+		"image/jpeg": "jpg",
+		"image/png": "png",
+		"image/svg+xml": "svg",
+		"image/webp": "webp",
+		"video/mp4": "mp4",
+		"application/pdf": "pdf",
+		"text/csv": "csv"
+	}[contentType.toLowerCase()] ?? null;
+}
+/**
+* Ceiling for the inline (base64) upload fallback. Enforced on the *decoded*
+* bytes: capping the base64 string instead would let a caller slip ~33% more
+* through, and the number that matters downstream is the object size.
+*
+* 1MB is a deliberate cost ceiling rather than a technical one. Inline bytes
+* traverse the model's context, so 1MB costs roughly 90K tokens — already
+* enough that a caller should reach for presign or URL import when it can.
+*/
+const MAX_INLINE_UPLOAD_BYTES = 1048576;
+/**
+* Decodes a base64 payload, tolerating a `data:` URL wrapper since models
+* routinely produce one. Rejects anything that is not valid base64: Buffer
+* silently drops invalid characters, so a corrupted payload would otherwise
+* upload as a truncated file instead of failing.
+*/
+function decodeInlineUpload(payload, maxBytes = MAX_INLINE_UPLOAD_BYTES) {
+	const dataUrl = payload.match(/^data:([^;,]*)(;base64)?,(.*)$/s);
+	const contentTypeHint = dataUrl?.[1]?.trim() || null;
+	const base64 = (dataUrl?.[3] ?? payload).replace(/\s/g, "");
+	if (base64.length === 0) throw new AssetImportError("base64Content is empty.");
+	if (!/^[A-Za-z0-9+/]*={0,2}$/.test(base64)) throw new AssetImportError("base64Content is not valid base64. Send the raw base64 of the file (a data: URL prefix is also accepted).");
+	const approximateBytes = Math.floor(base64.length * 3 / 4);
+	if (approximateBytes > maxBytes) throw new AssetImportError(oversizeMessage(approximateBytes, maxBytes));
+	const bytes = new Uint8Array(Buffer.from(base64, "base64"));
+	if (bytes.byteLength > maxBytes) throw new AssetImportError(oversizeMessage(bytes.byteLength, maxBytes));
+	return {
+		bytes,
+		contentTypeHint
+	};
+}
+function oversizeMessage(actual, maxBytes) {
+	return `Inline upload is ${Math.round(actual / 1024)}KB, over the ${Math.round(maxBytes / 1024)}KB limit. Inline bytes pass through the conversation and are expensive; use neopress_asset_presign (upload straight to storage) or neopress_asset_import_url (server fetches a public URL) instead.`;
+}
 //#endregion
 //#region src/tools.ts
 const siteIdShape = { siteId: z.number().int().positive().optional() };
@@ -24673,11 +24871,7 @@ function getToolMeta(tool) {
 	return {
 		securitySchemes: [{
 			type: "oauth2",
-			scopes: [
-				"neopress:read",
-				"neopress:write",
-				"offline_access"
-			]
+			scopes: []
 		}],
 		"openai/toolInvocation/invoking": `Running ${tool.title}`,
 		"openai/toolInvocation/invoked": `Finished ${tool.title}`
@@ -24755,7 +24949,7 @@ const toolDefinitions = [
 		handler: async (input, context, extra) => {
 			const selectedSiteId = asNumber(input, "siteId");
 			const site = await (await context.createClient({ siteId: selectedSiteId }, extra)).site.get();
-			context.setActiveSiteId(selectedSiteId, extra);
+			await context.setActiveSiteId(selectedSiteId, extra);
 			return {
 				siteId: selectedSiteId,
 				baseUrl: context.getBaseUrl(),
@@ -24792,7 +24986,7 @@ const toolDefinitions = [
 				language: asOptionalString(input, "language"),
 				placeholder: asOptionalBoolean(input, "placeholder")
 			});
-			if (input.select !== false) context.setActiveSiteId(site.id, extra);
+			if (input.select !== false) await context.setActiveSiteId(site.id, extra);
 			return site;
 		}
 	},
@@ -24830,12 +25024,13 @@ const toolDefinitions = [
 	{
 		name: "neopress_template_mark",
 		title: "Mark Site As Template",
-		description: "Create or update the template metadata row for a finished template site. The template id is the site id. Requires at least one previewImgUrl. The gallery card shows previewImgUrls[0] at rest and plays previewVideoUrl on hover, so pass the video together with its own first frame as the first preview image.",
+		description: "Create or update the template metadata row for a finished template site. The template id is the site id. Requires at least one previewImgUrl and a language. The gallery card shows previewImgUrls[0] at rest and plays previewVideoUrl on hover, so pass the video together with its own first frame as the first preview image.",
 		inputSchema: {
 			...siteIdShape,
 			name: z.string(),
 			description: z.string().max(150).optional(),
 			referenceUrl: httpUrlSchema,
+			language: z.string().regex(/^[a-z]{2}$/, "must be a two-letter ISO 639-1 language code (e.g. ko, en, es)").describe("Primary language of the template's own content, as a two-letter lowercase ISO 639-1 code (ko, en, es). Not a region locale like en-US."),
 			previewImgUrls: z.array(z.string()).min(1),
 			previewVideoUrl: httpUrlSchema.optional()
 		},
@@ -24844,6 +25039,7 @@ const toolDefinitions = [
 				name: asString(input, "name"),
 				description: asOptionalString(input, "description"),
 				referenceUrl: asString(input, "referenceUrl"),
+				language: asString(input, "language"),
 				previewImgUrls: input.previewImgUrls,
 				previewVideoUrl: asOptionalString(input, "previewVideoUrl")
 			});
@@ -25544,6 +25740,118 @@ const toolDefinitions = [
 			});
 		}
 	},
+	{
+		name: "neopress_asset_presign",
+		title: "Get Presigned Asset Upload URL",
+		description: "Preferred way to upload bytes you hold (a local file, a generated image): returns a short-lived URL to PUT the file straight to Neopress storage, then call neopress_asset_register with the returned publicUrl. Nothing passes through the conversation, so size and count cost you nothing. This requires your environment to reach the storage host directly — if that PUT is refused by a proxy or egress allowlist, fall back to neopress_asset_upload_base64. neopress_asset_upload_file does all three steps at once but only over a local (stdio) connection, since a remote server cannot read your filesystem.",
+		inputSchema: {
+			...siteIdShape,
+			fileName: z.string(),
+			contentType: z.string().optional(),
+			contentLength: z.number().int().positive(),
+			folder: z.string().optional()
+		},
+		handler: async (input, context, extra) => {
+			const client = await context.createClient({ siteId: siteId(input) }, extra);
+			const fileName = basename(asString(input, "fileName"));
+			const folder = asOptionalString(input, "folder") || "uploads";
+			return client.assets.presign({
+				fileKey: `${folder}/${Date.now()}-${fileName}`,
+				contentType: asOptionalString(input, "contentType") || getContentType(fileName),
+				contentLength: asNumber(input, "contentLength")
+			});
+		}
+	},
+	{
+		name: "neopress_asset_import_url",
+		title: "Import Asset From URL",
+		description: "Copy a publicly reachable file into Neopress storage and register it as an asset. Unlike neopress_asset_register — which only records an external URL and breaks when the source moves — this stores our own copy. The server does the fetching, so no bytes pass through the conversation.",
+		inputSchema: {
+			...siteIdShape,
+			sourceUrl: z.string().url(),
+			folder: z.string().optional(),
+			displayName: z.string().optional(),
+			altText: z.string().optional(),
+			description: z.string().optional(),
+			tags: z.array(z.string()).optional(),
+			metadata: optionalJsonObjectSchema
+		},
+		handler: async (input, context, extra) => {
+			const client = await context.createClient({ siteId: siteId(input) }, extra);
+			const fetched = await fetchImportableAsset(asString(input, "sourceUrl"), { fetch: context.fetch });
+			const fileName = deriveImportFileName(fetched.finalUrl, fetched.contentType);
+			const contentType = fetched.contentType || getContentType(fileName);
+			const folder = asOptionalString(input, "folder") || "uploads";
+			const { presignedUrl, publicUrl } = await client.assets.presign({
+				fileKey: `${folder}/${Date.now()}-${fileName}`,
+				contentType,
+				contentLength: fetched.bytes.byteLength
+			});
+			const uploadResponse = await context.fetch(presignedUrl, {
+				method: "PUT",
+				headers: { "Content-Type": contentType },
+				body: fetched.bytes
+			});
+			if (!uploadResponse.ok) throw new Error(`Asset upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
+			return client.assets.register({
+				assetUrl: publicUrl,
+				displayName: asOptionalString(input, "displayName") || fileName,
+				mimeType: contentType,
+				size: fetched.bytes.byteLength,
+				altText: asOptionalString(input, "altText"),
+				description: asOptionalString(input, "description"),
+				tags: input.tags,
+				folderPath: folder,
+				metadata: input.metadata
+			});
+		}
+	},
+	{
+		name: "neopress_asset_upload_base64",
+		title: "Upload Asset Inline (base64)",
+		description: "Fallback upload for environments with no outbound network of their own: the bytes ride inside this tool call, so they travel over the connection your host already has instead of one you must open. Expensive — inline bytes pass through the conversation, so ~1MB costs roughly 90K tokens, and the limit is 1MB decoded. Reach for this only when neopress_asset_presign is refused by a proxy or egress allowlist, and prefer neopress_asset_import_url whenever the file already has a public URL.",
+		inputSchema: {
+			...siteIdShape,
+			fileName: z.string(),
+			base64Content: z.string(),
+			contentType: z.string().optional(),
+			folder: z.string().optional(),
+			displayName: z.string().optional(),
+			altText: z.string().optional(),
+			description: z.string().optional(),
+			tags: z.array(z.string()).optional(),
+			metadata: optionalJsonObjectSchema
+		},
+		handler: async (input, context, extra) => {
+			const client = await context.createClient({ siteId: siteId(input) }, extra);
+			const fileName = basename(asString(input, "fileName"));
+			const { bytes, contentTypeHint } = decodeInlineUpload(asString(input, "base64Content"));
+			const contentType = asOptionalString(input, "contentType") || contentTypeHint || getContentType(fileName);
+			const folder = asOptionalString(input, "folder") || "uploads";
+			const { presignedUrl, publicUrl } = await client.assets.presign({
+				fileKey: `${folder}/${Date.now()}-${fileName}`,
+				contentType,
+				contentLength: bytes.byteLength
+			});
+			const uploadResponse = await context.fetch(presignedUrl, {
+				method: "PUT",
+				headers: { "Content-Type": contentType },
+				body: bytes
+			});
+			if (!uploadResponse.ok) throw new Error(`Asset upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
+			return client.assets.register({
+				assetUrl: publicUrl,
+				displayName: asOptionalString(input, "displayName") || fileName,
+				mimeType: contentType,
+				size: bytes.byteLength,
+				altText: asOptionalString(input, "altText"),
+				description: asOptionalString(input, "description"),
+				tags: input.tags,
+				folderPath: folder,
+				metadata: input.metadata
+			});
+		}
+	},
 	{
 		name: "neopress_asset_upload_file",
 		title: "Upload Local Asset File",
@@ -25663,19 +25971,65 @@ function createNeopressMcpServer(options = {}) {
 	return server;
 }
 //#endregion
+//#region src/remote/redis.ts
+let redisClient;
+/**
+* Upstash Redis client factory. Returns `undefined` when the environment is
+* not configured so callers can fall back to in-memory implementations.
+*/
+function getRedisClient() {
+	if (redisClient) return redisClient;
+	const url = process.env.UPSTASH_REDIS_REST_URL;
+	const token = process.env.UPSTASH_REDIS_REST_TOKEN;
+	if (!url || !token) return void 0;
+	redisClient = new Redis({
+		url,
+		token
+	});
+	return redisClient;
+}
+//#endregion
 //#region src/remote/context.ts
+/** Site selections are session-like data — expire them after 30 days. */
+const SITE_SELECTION_TTL_SECONDS = 2592e3;
+function siteSelectionKey(userKey) {
+	return `mcp:site-selection:${userKey}`;
+}
 var MemoryRemoteSiteSelectionStore = class {
 	siteIds = /* @__PURE__ */ new Map();
-	get(userKey) {
+	async get(userKey) {
 		return this.siteIds.get(userKey);
 	}
-	set(userKey, siteId) {
+	async set(userKey, siteId) {
 		this.siteIds.set(userKey, siteId);
 	}
 };
+var RedisRemoteSiteSelectionStore = class {
+	redis;
+	constructor(redis) {
+		this.redis = redis;
+	}
+	async get(userKey) {
+		return await this.redis.get(siteSelectionKey(userKey)) ?? void 0;
+	}
+	async set(userKey, siteId) {
+		await this.redis.set(siteSelectionKey(userKey), siteId, { ex: SITE_SELECTION_TTL_SECONDS });
+	}
+};
 function createMemoryRemoteSiteSelectionStore() {
 	return new MemoryRemoteSiteSelectionStore();
 }
+function createRedisRemoteSiteSelectionStore(redis) {
+	return new RedisRemoteSiteSelectionStore(redis);
+}
+/**
+* Redis-backed store when Upstash env is configured, in-memory otherwise.
+* Callers passing an explicit store always take precedence over this default.
+*/
+function createDefaultRemoteSiteSelectionStore() {
+	const redis = getRedisClient();
+	return redis ? createRedisRemoteSiteSelectionStore(redis) : createMemoryRemoteSiteSelectionStore();
+}
 function getUserKey(extra) {
 	const userId = extra?.authInfo?.extra?.userId;
 	if (typeof userId === "string" && userId) return `user:${userId}`;
@@ -25691,7 +26045,7 @@ function createRemoteToolContext(options) {
 	const siteSelectionStore = options.siteSelectionStore ?? createMemoryRemoteSiteSelectionStore();
 	return {
 		async createClient(clientOptions = {}, extra) {
-			const siteId = clientOptions.siteId ?? siteSelectionStore.get(getUserKey(extra));
+			const siteId = clientOptions.siteId ?? await siteSelectionStore.get(getUserKey(extra));
 			const requireSite = clientOptions.requireSite ?? true;
 			if (!siteId && requireSite) throw new Error("No site selected. Call neopress_site_select or pass siteId explicitly.");
 			const sb = getSupabaseConfig();
@@ -25710,16 +26064,19 @@ function createRemoteToolContext(options) {
 			throw new Error("Local file uploads are only available through the stdio MCP server. Use neopress_asset_register with a public URL for remote MCP.");
 		},
 		fetch,
-		setActiveSiteId(siteId, extra) {
-			siteSelectionStore.set(getUserKey(extra), siteId);
+		async setActiveSiteId(siteId, extra) {
+			await siteSelectionStore.set(getUserKey(extra), siteId);
 		},
 		getBaseUrl() {
 			return options.baseUrl;
 		}
 	};
 }
-const DEFAULT_CLIENT_TTL_SECONDS = 2592e3;
-let generatedClientSecret;
+/**
+* Error shape for the bearer-token verification path. The MCP server is a
+* pure Resource Server (RFC 9728) — the OAuth 2.1 Authorization Server lives
+* in Supabase, not here, so this module only verifies access tokens.
+*/
 var OAuthProtocolError = class extends Error {
 	status;
 	errorCode;
@@ -25730,130 +26087,11 @@ var OAuthProtocolError = class extends Error {
 		this.errorCode = errorCode;
 	}
 };
-function toBase64Url(value) {
-	return Buffer.from(value, "utf-8").toString("base64url");
-}
-function fromBase64Url(value) {
-	return Buffer.from(value, "base64url").toString("utf-8");
-}
-function sign(value, secret) {
-	return createHmac("sha256", secret).update(value).digest("base64url");
-}
-function safeEqual(left, right) {
-	const leftBuffer = Buffer.from(left);
-	const rightBuffer = Buffer.from(right);
-	return leftBuffer.byteLength === rightBuffer.byteLength && timingSafeEqual(leftBuffer, rightBuffer);
-}
-function getOAuthClientSecret(explicitSecret) {
-	if (explicitSecret) return explicitSecret;
-	if (process.env.NODE_ENV === "production") throw new Error("NEOPRESS_MCP_OAUTH_CLIENT_SECRET is required in production.");
-	generatedClientSecret ??= randomBytes(32).toString("base64url");
-	return generatedClientSecret;
-}
-function normalizeRedirectUris(redirectUris) {
-	if (!Array.isArray(redirectUris)) throw new OAuthProtocolError(400, "invalid_client_metadata", "redirect_uris must be an array.");
-	const normalized = redirectUris.map((uri) => typeof uri === "string" ? uri.trim() : "").filter(Boolean);
-	if (normalized.length === 0) throw new OAuthProtocolError(400, "invalid_client_metadata", "At least one redirect_uri is required.");
-	for (const uri of normalized) try {
-		new URL(uri);
-	} catch {
-		throw new OAuthProtocolError(400, "invalid_redirect_uri", `Invalid redirect_uri: ${uri}`);
-	}
-	return [...new Set(normalized)];
-}
-function createClientRegistration(input, secret, nowSeconds = Math.floor(Date.now() / 1e3)) {
-	const redirectUris = normalizeRedirectUris(input.redirect_uris);
-	const payload = {
-		v: 1,
-		clientName: input.client_name,
-		redirectUris,
-		issuedAt: nowSeconds,
-		expiresAt: nowSeconds + DEFAULT_CLIENT_TTL_SECONDS
-	};
-	const encodedPayload = toBase64Url(JSON.stringify(payload));
-	return {
-		client_id: `${encodedPayload}.${sign(encodedPayload, secret)}`,
-		client_id_issued_at: payload.issuedAt,
-		client_name: payload.clientName,
-		redirect_uris: payload.redirectUris,
-		token_endpoint_auth_method: "none"
-	};
-}
-function verifyClientRegistration(clientId, secret, nowSeconds = Math.floor(Date.now() / 1e3)) {
-	const [encodedPayload, signature] = clientId.split(".");
-	if (!encodedPayload || !signature) throw new OAuthProtocolError(401, "invalid_client", "Invalid client_id.");
-	if (!safeEqual(signature, sign(encodedPayload, secret))) throw new OAuthProtocolError(401, "invalid_client", "Invalid client_id.");
-	let payload;
-	try {
-		payload = JSON.parse(fromBase64Url(encodedPayload));
-	} catch {
-		throw new OAuthProtocolError(401, "invalid_client", "Invalid client_id.");
-	}
-	if (payload.v !== 1 || !Array.isArray(payload.redirectUris)) throw new OAuthProtocolError(401, "invalid_client", "Invalid client_id.");
-	if (payload.expiresAt <= nowSeconds) throw new OAuthProtocolError(401, "invalid_client", "client_id has expired.");
-	return payload;
-}
-function requireParam(params, name) {
-	const value = params.get(name);
-	if (!value) throw new OAuthProtocolError(400, "invalid_request", `Missing required parameter: ${name}`);
-	return value;
-}
-function createAuthorizationRedirectUrl(requestUrl, config) {
-	if (requireParam(requestUrl.searchParams, "response_type") !== "code") throw new OAuthProtocolError(400, "unsupported_response_type", "Only response_type=code is supported.");
-	const client = verifyClientRegistration(requireParam(requestUrl.searchParams, "client_id"), config.clientSecret);
-	const redirectUri = requireParam(requestUrl.searchParams, "redirect_uri");
-	if (!client.redirectUris.includes(redirectUri)) throw new OAuthProtocolError(400, "invalid_redirect_uri", "redirect_uri is not registered for this client.");
-	const codeChallenge = requireParam(requestUrl.searchParams, "code_challenge");
-	if ((requestUrl.searchParams.get("code_challenge_method") || "S256") !== "S256") throw new OAuthProtocolError(400, "invalid_request", "Only S256 PKCE is supported.");
-	const redirectTo = new URL(redirectUri);
-	const state = requestUrl.searchParams.get("state");
-	if (state) redirectTo.searchParams.set("state", state);
-	const supabaseAuthorizeUrl = new URL(`${config.supabaseUrl}/auth/v1/authorize`);
-	supabaseAuthorizeUrl.searchParams.set("provider", config.provider);
-	supabaseAuthorizeUrl.searchParams.set("redirect_to", redirectTo.toString());
-	supabaseAuthorizeUrl.searchParams.set("code_challenge", codeChallenge);
-	supabaseAuthorizeUrl.searchParams.set("code_challenge_method", "S256");
-	return supabaseAuthorizeUrl.toString();
-}
-async function proxyTokenRequest(params, config) {
-	verifyClientRegistration(requireParam(params, "client_id"), config.clientSecret);
-	const grantType = requireParam(params, "grant_type");
-	let supabaseGrantType;
-	let body;
-	if (grantType === "authorization_code") {
-		supabaseGrantType = "pkce";
-		body = {
-			auth_code: requireParam(params, "code"),
-			code_verifier: requireParam(params, "code_verifier")
-		};
-	} else if (grantType === "refresh_token") {
-		supabaseGrantType = "refresh_token";
-		body = { refresh_token: requireParam(params, "refresh_token") };
-	} else throw new OAuthProtocolError(400, "unsupported_grant_type", "Only authorization_code and refresh_token grants are supported.");
-	const response = await (config.fetch ?? fetch)(`${config.supabaseUrl}/auth/v1/token?grant_type=${supabaseGrantType}`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			apikey: config.supabaseAnonKey
-		},
-		body: JSON.stringify(body)
-	});
-	const responseText = await response.text();
-	let data;
-	try {
-		data = responseText ? JSON.parse(responseText) : {};
-	} catch {
-		data = { message: responseText };
-	}
-	if (!response.ok) throw new OAuthProtocolError(response.status, "invalid_grant", typeof data.message === "string" ? data.message : "Token exchange failed.");
-	return {
-		access_token: data.access_token,
-		refresh_token: data.refresh_token,
-		expires_in: data.expires_in,
-		token_type: typeof data.token_type === "string" ? data.token_type : "bearer",
-		scope: "neopress:read neopress:write offline_access"
-	};
-}
+/**
+* Live verification against Supabase GoTrue (`GET /auth/v1/user`). Live
+* lookups mean a global logout invalidates tokens immediately — a JWKS/local
+* verification swap is a pre-listing gate, not a launch requirement.
+*/
 async function verifySupabaseAccessToken(accessToken, config) {
 	const response = await (config.fetch ?? fetch)(`${config.supabaseUrl}/auth/v1/user`, {
 		method: "GET",
@@ -25882,11 +26120,25 @@ async function verifySupabaseAccessToken(accessToken, config) {
 //#region src/remote/http-server.ts
 const MCP_PATH = "/mcp";
 const DISABLED_REMOTE_TOOLS = ["neopress_asset_upload_file"];
-const OAUTH_SCOPES = [
-	"neopress:read",
-	"neopress:write",
-	"offline_access"
-];
+/**
+* Production guard: site selections must survive restarts and be shared
+* across instances, so production requires Upstash Redis unless an explicit
+* store is injected.
+*/
+function resolveSiteSelectionStore(explicitStore) {
+	if (explicitStore) return explicitStore;
+	if (!getRedisClient() && process.env.NODE_ENV === "production") throw new Error("UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN are required in production so site selections persist across restarts and instances.");
+	return createDefaultRemoteSiteSelectionStore();
+}
+/**
+* Production guard: the protected-resource metadata URLs (`resource` and the
+* 401 `resource_metadata` pointer) are built from the public URL, so
+* production must not fall back to request-header-derived origins.
+*/
+function resolvePublicUrl(explicitPublicUrl) {
+	if (explicitPublicUrl) return explicitPublicUrl.replace(/\/$/, "");
+	if (process.env.NODE_ENV === "production") throw new Error("NEOPRESS_MCP_PUBLIC_URL is required in production.");
+}
 function resolveOptions(options) {
 	return {
 		authMode: options.authMode ?? "oauth",
@@ -25899,11 +26151,10 @@ function resolveOptions(options) {
 		],
 		fetch: options.fetch ?? fetch,
 		host: options.host ?? "0.0.0.0",
-		oauthClientSecret: getOAuthClientSecret(options.oauthClientSecret),
-		oauthProvider: options.oauthProvider ?? "google",
+		openaiAppsChallengeToken: options.openaiAppsChallengeToken,
 		port: options.port ?? 4002,
-		publicUrl: options.publicUrl?.replace(/\/$/, ""),
-		siteSelectionStore: options.siteSelectionStore ?? createMemoryRemoteSiteSelectionStore(),
+		publicUrl: resolvePublicUrl(options.publicUrl),
+		siteSelectionStore: resolveSiteSelectionStore(options.siteSelectionStore),
 		supabaseAnonKey: options.supabaseAnonKey ?? "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imd4cmZ5am1zbWlha2lybXR6a212Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjIxNDM2MzQsImV4cCI6MjA3NzcxOTYzNH0.Xzx6Xg5O1EBXZ64_5BP7KhsVyafJ0GI-62HcDpq6WRk",
 		supabaseUrl: (options.supabaseUrl ?? "https://gxrfyjmsmiakirmtzkmv.supabase.co").replace(/\/$/, "")
 	};
@@ -25950,22 +26201,9 @@ function sendText(response, body, options = {}) {
 	for (const [key, value] of Object.entries(options.headers ?? {})) response.setHeader(key, value);
 	response.end(body);
 }
-function sendOAuthError(response, error) {
-	if (error instanceof OAuthProtocolError) {
-		sendJson(response, {
-			error: error.errorCode,
-			error_description: error.message
-		}, { status: error.status });
-		return;
-	}
-	sendJson(response, {
-		error: "server_error",
-		error_description: error instanceof Error ? error.message : "Unexpected OAuth error."
-	}, { status: 500 });
-}
 function sendUnauthorized(request, response, options) {
-	const issuer = getRequestBaseUrl(request, options);
-	response.setHeader("WWW-Authenticate", `Bearer resource_metadata="${issuer}/.well-known/oauth-protected-resource/mcp"`);
+	const resourceBaseUrl = getRequestBaseUrl(request, options);
+	response.setHeader("WWW-Authenticate", `Bearer resource_metadata="${resourceBaseUrl}/.well-known/oauth-protected-resource/mcp"`);
 	sendJson(response, {
 		error: "unauthorized",
 		error_description: "A valid Neopress OAuth bearer token is required."
@@ -25974,128 +26212,30 @@ function sendUnauthorized(request, response, options) {
 function readBearerToken(request) {
 	return (getHeaderValue(request.headers.authorization)?.match(/^Bearer\s+(.+)$/i))?.[1]?.trim() || null;
 }
-async function readBody(request) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of request) {
-		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += buffer.byteLength;
-		if (size > 1048576) throw new OAuthProtocolError(413, "invalid_request", "Request body is too large.");
-		chunks.push(buffer);
-	}
-	return Buffer.concat(chunks).toString("utf-8");
-}
-async function readRequestParams(request) {
-	const body = await readBody(request);
-	if ((getHeaderValue(request.headers["content-type"]) ?? "").includes("application/json")) {
-		let parsed;
-		try {
-			parsed = body ? JSON.parse(body) : {};
-		} catch {
-			throw new OAuthProtocolError(400, "invalid_request", "Invalid JSON body.");
-		}
-		const params = new URLSearchParams();
-		for (const [key, value] of Object.entries(parsed)) if (Array.isArray(value)) {
-			for (const item of value) if (item !== void 0 && item !== null) params.append(key, String(item));
-		} else if (value !== void 0 && value !== null) params.set(key, String(value));
-		return params;
-	}
-	return new URLSearchParams(body);
-}
-function protectedResourceMetadata(issuer) {
+/**
+* RFC 9728 Protected Resource Metadata. This server is RS-only: clients
+* discover the Supabase OAuth 2.1 Authorization Server from
+* `authorization_servers` and run DCR, authorize, and token exchange against
+* it directly.
+*
+* `scopes_supported` is intentionally absent — clients copy advertised scopes
+* verbatim into their authorize request, and Supabase rejects custom scopes
+* (and returns 500 for `openid`), so advertising any value here would break
+* every connection.
+*/
+function protectedResourceMetadata(resourceBaseUrl, options) {
 	return {
-		resource: `${issuer}${MCP_PATH}`,
-		authorization_servers: [issuer],
+		resource: `${resourceBaseUrl}${MCP_PATH}`,
+		authorization_servers: [`${options.supabaseUrl}/auth/v1`],
 		bearer_methods_supported: ["header"],
-		scopes_supported: OAUTH_SCOPES,
 		resource_documentation: "https://app.neopress.ai"
 	};
 }
-function authorizationServerMetadata(issuer) {
-	return {
-		issuer,
-		authorization_endpoint: `${issuer}/oauth/authorize`,
-		token_endpoint: `${issuer}/oauth/token`,
-		registration_endpoint: `${issuer}/oauth/register`,
-		response_types_supported: ["code"],
-		grant_types_supported: ["authorization_code", "refresh_token"],
-		token_endpoint_auth_methods_supported: ["none"],
-		code_challenge_methods_supported: ["S256"],
-		scopes_supported: OAUTH_SCOPES,
-		resource_parameter_supported: true
-	};
-}
-function parseRedirectUrisParam(value) {
-	if (!value) return [];
-	if (!value.startsWith("[")) return [value];
-	try {
-		const parsed = JSON.parse(value);
-		return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
-	} catch {
-		throw new OAuthProtocolError(400, "invalid_client_metadata", "redirect_uris must be a string or JSON array of strings.");
-	}
-}
-async function handleRegister(request, response, options) {
-	if (request.method !== "POST") {
-		sendJson(response, { error: "method_not_allowed" }, { status: 405 });
-		return;
-	}
-	try {
-		const params = await readRequestParams(request);
-		const redirectUris = params.getAll("redirect_uris");
-		const parsed = params.get("redirect_uris");
-		sendJson(response, createClientRegistration({
-			client_name: params.get("client_name") ?? void 0,
-			redirect_uris: redirectUris.length > 1 ? redirectUris : parseRedirectUrisParam(parsed)
-		}, options.oauthClientSecret), { status: 201 });
-	} catch (error) {
-		sendOAuthError(response, error);
-	}
-}
-function handleAuthorize(request, response, options) {
-	if (request.method !== "GET") {
-		sendJson(response, { error: "method_not_allowed" }, { status: 405 });
-		return;
-	}
-	try {
-		const authorizationUrl = createAuthorizationRedirectUrl(getRequestUrl(request, options), {
-			clientSecret: options.oauthClientSecret,
-			fetch: options.fetch,
-			issuer: getRequestBaseUrl(request, options),
-			provider: options.oauthProvider,
-			supabaseAnonKey: options.supabaseAnonKey,
-			supabaseUrl: options.supabaseUrl
-		});
-		response.statusCode = 302;
-		response.setHeader("Location", authorizationUrl);
-		response.end();
-	} catch (error) {
-		sendOAuthError(response, error);
-	}
-}
-async function handleToken(request, response, options) {
-	if (request.method !== "POST") {
-		sendJson(response, { error: "method_not_allowed" }, { status: 405 });
-		return;
-	}
-	try {
-		sendJson(response, await proxyTokenRequest(await readRequestParams(request), {
-			clientSecret: options.oauthClientSecret,
-			fetch: options.fetch,
-			issuer: getRequestBaseUrl(request, options),
-			provider: options.oauthProvider,
-			supabaseAnonKey: options.supabaseAnonKey,
-			supabaseUrl: options.supabaseUrl
-		}));
-	} catch (error) {
-		sendOAuthError(response, error);
-	}
-}
 async function authenticateMcpRequest(request, options) {
 	if (options.authMode === "none") return {
 		token: "",
 		clientId: "anonymous",
-		scopes: OAUTH_SCOPES,
+		scopes: [],
 		extra: { userId: "anonymous" }
 	};
 	const accessToken = readBearerToken(request);
@@ -26108,7 +26248,7 @@ async function authenticateMcpRequest(request, options) {
 	return {
 		token: accessToken,
 		clientId: "neopress-oauth",
-		scopes: OAUTH_SCOPES,
+		scopes: [],
 		expiresAt: user.expiresAt,
 		extra: {
 			email: user.email,
@@ -26126,7 +26266,7 @@ function createNeopressMcpHttpServer(rawOptions = {}) {
 			return;
 		}
 		const url = getRequestUrl(request, options);
-		const issuer = getRequestBaseUrl(request, options);
+		const resourceBaseUrl = getRequestBaseUrl(request, options);
 		try {
 			if (url.pathname === "/" || url.pathname === "/healthz" || url.pathname === "/livez") {
 				sendText(response, "ok");
@@ -26137,23 +26277,15 @@ function createNeopressMcpHttpServer(rawOptions = {}) {
 				return;
 			}
 			if (url.pathname === "/.well-known/oauth-protected-resource" || url.pathname === "/.well-known/oauth-protected-resource/mcp") {
-				sendJson(response, protectedResourceMetadata(issuer));
-				return;
-			}
-			if (url.pathname === "/.well-known/oauth-authorization-server" || url.pathname === "/.well-known/openid-configuration") {
-				sendJson(response, authorizationServerMetadata(issuer));
-				return;
-			}
-			if (url.pathname === "/oauth/register") {
-				await handleRegister(request, response, options);
+				sendJson(response, protectedResourceMetadata(resourceBaseUrl, options));
 				return;
 			}
-			if (url.pathname === "/oauth/authorize") {
-				handleAuthorize(request, response, options);
-				return;
-			}
-			if (url.pathname === "/oauth/token") {
-				await handleToken(request, response, options);
+			if (url.pathname === "/.well-known/openai-apps-challenge") {
+				if (!options.openaiAppsChallengeToken) {
+					sendJson(response, { error: "not_found" }, { status: 404 });
+					return;
+				}
+				sendText(response, options.openaiAppsChallengeToken);
 				return;
 			}
 			if (url.pathname === MCP_PATH) {