@neopress/mcp 1.3.1 → 1.4.0

package/README.md

@@ -39,23 +39,72 @@ Endpoints:
 
 | Method | Path                                      | Purpose                         |
 | ------ | ----------------------------------------- | ------------------------------- |
-| `POST` | `/mcp`                                    | MCP Streamable HTTP endpoint    |
-| `GET`  | `/.well-known/oauth-protected-resource/mcp` | OAuth protected resource metadata |
-| `GET`  | `/.well-known/oauth-authorization-server` | OAuth authorization server metadata |
-| `POST` | `/oauth/register`                         | Dynamic public client registration |
-| `GET`  | `/oauth/authorize`                        | Supabase OAuth PKCE redirect    |
-| `POST` | `/oauth/token`                            | Supabase PKCE/refresh proxy     |
+| `POST` | `/mcp`                                    | MCP Streamable HTTP endpoint (OAuth bearer required) |
+| `GET`  | `/.well-known/oauth-protected-resource/mcp` | RFC 9728 protected resource metadata (also served at `/.well-known/oauth-protected-resource`) |
 | `GET`  | `/healthz`                                | Liveness probe                  |
 | `GET`  | `/readyz`                                 | Readiness probe                 |
 
-Remote MCP requires OAuth bearer tokens for `/mcp`. It exposes dynamic client
-registration and PKCE token exchange for clients that support remote MCP OAuth.
-The access token is then used against the Neopress first-party `/api/v1` API,
-so tenant membership remains enforced by the app API.
+The server is a pure Resource Server (RS-only): the OAuth 2.1 Authorization
+Server is Supabase Auth. Clients discover it from `authorization_servers` in
+the protected resource metadata and run dynamic client registration
+(`/auth/v1/oauth/clients/register`), authorization, and token exchange against
+Supabase directly — this server hosts no OAuth routes of its own.
+Unauthenticated `/mcp` requests get a 401 with a `WWW-Authenticate:
+Bearer resource_metadata="..."` pointer. The resource metadata deliberately
+omits `scopes_supported`: clients echo advertised scopes into their authorize
+request, and Supabase rejects custom scopes.
+
+Bearer tokens are verified live against Supabase (`GET /auth/v1/user`), so a
+global logout invalidates them immediately. The access token is then used
+against the Neopress first-party `/api/v1` API, so tenant membership remains
+enforced by the app API.
+
+### OAuth consent flow
+
+Consent is delegated by Supabase to the Neopress app (Authorization Path
+`https://app.neopress.ai/oauth/consent`, configured in the Supabase dashboard):
+
+1. Client registers via Supabase DCR, then starts
+   `GET {SUPABASE_URL}/auth/v1/oauth/authorize` (PKCE, S256).
+2. Supabase redirects the browser to the app consent page with
+   `?authorization_id={id}`.
+3. The consent page (session-gated on the app origin) fetches the pending
+   authorization from `GET {SUPABASE_URL}/auth/v1/oauth/authorizations/{id}`
+   using the anon `apikey` plus the signed-in user's access token, and shows
+   the client name, account, and a static access description. If the
+   authorization was already approved, Supabase returns only `{redirect_url}`
+   and the page redirects immediately.
+4. Approve/deny posts to `POST .../oauth/authorizations/{id}/consent` with
+   `{"action":"approve"|"deny"}`; the browser follows the returned
+   `redirect_url` back to the client (deny carries `error=access_denied`).
+5. The client exchanges the code at the Supabase token endpoint. The MCP
+   server only ever sees the resulting bearer token.
 
 Remote MCP disables `neopress_asset_upload_file` because a hosted server cannot
-read the client's local filesystem. Use `neopress_asset_register` for public
-URLs, or use local stdio MCP for local file uploads.
+read the client's local filesystem. Two remote-native paths cover the same
+ground without pushing file bytes through the model's context:
+
+| You have | Tool | What happens |
+| --- | --- | --- |
+| The bytes, and outbound network of your own | `neopress_asset_presign` → your own PUT → `neopress_asset_register` | You upload straight to storage; nothing crosses the conversation, so size and count are free |
+| A public URL | `neopress_asset_import_url` | The server fetches it and stores our own copy, then registers it |
+| The bytes, but no outbound network | `neopress_asset_upload_base64` | Bytes ride inside the tool call, over the connection your host already has |
+
+`neopress_asset_upload_base64` is a deliberate fallback, not a default. Inline
+bytes pass through the model's context (~90K tokens per MB), so it is capped at
+1MB decoded and should only be used where the presign PUT is refused — a
+sandbox whose egress runs through a domain allowlist, for instance. The cap is
+enforced on decoded bytes, since capping the base64 string would let ~33% more
+through.
+
+`neopress_asset_register` on its own only records an external URL — the image
+breaks if the source moves. Prefer `neopress_asset_import_url` unless you
+deliberately want to reference someone else's host.
+
+`neopress_asset_import_url` fetches a caller-supplied URL server-side, so it
+resolves and range-checks every hop (including redirects) against private and
+link-local space before connecting, and caps the body at 50MB while streaming.
+See `src/asset-import.ts`.
 
 ## Environment
 
@@ -64,11 +113,11 @@ URLs, or use local stdio MCP for local file uploads.
 | `PORT` | `4002` | Remote HTTP listen port |
 | `HOST` | `0.0.0.0` | Remote HTTP listen host |
 | `NEOPRESS_BASE_URL` | `https://app.neopress.ai` | Neopress API base URL |
-| `NEOPRESS_MCP_PUBLIC_URL` | request-derived | Public issuer/resource origin |
+| `NEOPRESS_MCP_PUBLIC_URL` | request-derived in dev | Public resource origin for the protected resource metadata and 401 pointer; required when `NODE_ENV=production` |
+| `UPSTASH_REDIS_REST_URL` | unset (in-memory store) | Upstash Redis for the active site selection store; required together with the token when `NODE_ENV=production` so selections persist across restarts and instances |
+| `UPSTASH_REDIS_REST_TOKEN` | unset (in-memory store) | See `UPSTASH_REDIS_REST_URL` |
 | `NEOPRESS_MCP_CORS_ORIGINS` | local dev origins | Comma-separated allowlist or `*` |
-| `NEOPRESS_MCP_OAUTH_PROVIDER` | `google` | Supabase OAuth provider |
-| `NEOPRESS_MCP_OAUTH_CLIENT_SECRET` | generated at boot in non-production | Stable HMAC secret for signed dynamic client IDs; required when `NODE_ENV=production` |
-| `NEOPRESS_SUPABASE_URL` | Neopress Supabase project | Supabase Auth base URL |
+| `NEOPRESS_SUPABASE_URL` | Neopress Supabase project | Supabase Auth base URL (authorization server issuer origin) |
 | `NEOPRESS_SUPABASE_ANON_KEY` | Neopress anon key | Supabase Auth anon key |
 | `NEOPRESS_MCP_AUTH_MODE` | `oauth` | `none` is dev/test only and rejected in production |
 
@@ -86,7 +135,6 @@ docker run --rm -p 8080:8080 \
 Deploy through Artifact Registry / Cloud Run:
 
 ```bash
-export NEOPRESS_MCP_OAUTH_CLIENT_SECRET="$(openssl rand -base64 32)"
 export NEOPRESS_MCP_PUBLIC_URL="https://mcp.neopress.ai"
 pnpm deploy:mcp
 ```
@@ -94,6 +142,22 @@ pnpm deploy:mcp
 The deploy script defaults to project `inblog-ver-2`, region `us-west1`,
 repository `neopress`, and service `neopress-mcp-server`.
 
+### CI deploy
+
+`.github/workflows/deploy-mcp.yml` deploys automatically on pushes to `main`
+that change the MCP Docker build closure (`packages/mcp`, `packages/sdk`,
+`packages/shared`, `packages/analytics-core`, lockfile/workspace config),
+detected via turbo affected; `workflow_dispatch` always deploys. The job runs
+typecheck/lint, then `pnpm predeploy:mcp` (agent contract gate), authenticates
+with Workload Identity Federation, and executes
+`packages/mcp/scripts/deploy-cloud-run.sh`.
+
+The deploy step maps GitHub secrets `UPSTASH_REDIS_REST_URL`,
+`UPSTASH_REDIS_REST_TOKEN` and repository var `NEOPRESS_MCP_PUBLIC_URL` into
+the Cloud Run service environment. Supabase OAuth Server settings (toggle,
+DCR, Authorization Path) are configured in the Supabase dashboard per the
+human runbook in `docs/plan/2026-07-28-remote-mcp-supabase-as-swap.md`.
+
 ## Official Client Drafts
 
 Submission-ready drafts live under `integrations/`:
@@ -113,4 +177,4 @@ pnpm dlx @anthropic-ai/mcpb pack packages/mcp/dist/mcpb/neopress
 ```
 
 Do not submit the remote connector drafts until the production MCP origin,
-legal/support URLs, review workspace, and real client OAuth scans are verified.
+support URL, review workspace, and real client OAuth scans are verified.

package/dist/bin.cjs

@@ -45,6 +45,8 @@ node_process = __toESM(node_process, 1);
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let node_os = require("node:os");
+let node_dns_promises = require("node:dns/promises");
+let node_net = require("node:net");
 Object.freeze({ status: "aborted" });
 function $constructor(name, initializer, params) {
 	function init(inst, def) {
@@ -42469,6 +42471,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
 	};
 }
@@ -43437,7 +43440,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);
@@ -43453,6 +43456,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
 			};
 		});
@@ -43855,7 +43859,7 @@ function getSiteId(siteIdOverride) {
 	if (projectConfig.siteId) return projectConfig.siteId;
 	return loadSession().activeSiteId;
 }
-function setActiveSiteId(siteId) {
+async function setActiveSiteId(siteId) {
 	saveSession({
 		...loadSession(),
 		activeSiteId: siteId
@@ -43969,8 +43973,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.
 
@@ -43979,6 +43984,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.
 
@@ -44038,6 +44044,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 = (0, node_net.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 = (0, node_net.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 (0, node_dns_promises.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: number().int().positive().optional() };
@@ -44150,11 +44348,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}`
@@ -44232,7 +44426,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(),
@@ -44269,7 +44463,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;
 		}
 	},
@@ -44307,12 +44501,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: string(),
 			description: string().max(150).optional(),
 			referenceUrl: httpUrlSchema,
+			language: 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: array(string()).min(1),
 			previewVideoUrl: httpUrlSchema.optional()
 		},
@@ -44321,6 +44516,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")
 			});
@@ -45021,6 +45217,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: string(),
+			contentType: string().optional(),
+			contentLength: number().int().positive(),
+			folder: string().optional()
+		},
+		handler: async (input, context, extra) => {
+			const client = await context.createClient({ siteId: siteId(input) }, extra);
+			const fileName = (0, node_path.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: string().url(),
+			folder: string().optional(),
+			displayName: string().optional(),
+			altText: string().optional(),
+			description: string().optional(),
+			tags: array(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: string(),
+			base64Content: string(),
+			contentType: string().optional(),
+			folder: string().optional(),
+			displayName: string().optional(),
+			altText: string().optional(),
+			description: string().optional(),
+			tags: array(string()).optional(),
+			metadata: optionalJsonObjectSchema
+		},
+		handler: async (input, context, extra) => {
+			const client = await context.createClient({ siteId: siteId(input) }, extra);
+			const fileName = (0, node_path.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",