emdash 0.8.0 → 0.10.0

package/src/astro/routes/api/import/wordpress/rewrite-url-helpers.ts

@@ -0,0 +1,196 @@
+const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+const WORDPRESS_IMAGE_SIZE_SUFFIX = /-\d+x\d+(?=\.[^./?#]+$)/;
+const BASE_URL_EXTENSION = /^(.+)(\.[^./?#]+)$/;
+
+/**
+ * Strip query parameters from a URL for base matching
+ */
+export function getBaseUrl(url: string): string {
+	try {
+		const parsed = new URL(url);
+		return `${parsed.origin}${parsed.pathname}`;
+	} catch {
+		// If URL parsing fails, try simple string split
+		return url.split("?")[0] || url;
+	}
+}
+
+/**
+ * Build a map of base URLs to new URLs for flexible matching
+ */
+export function buildBaseUrlMap(urlMap: Record<string, string>): Map<string, string> {
+	const baseMap = new Map<string, string>();
+	for (const [oldUrl, newUrl] of Object.entries(urlMap)) {
+		const baseUrl = getBaseUrl(oldUrl);
+		baseMap.set(baseUrl, newUrl);
+	}
+	return baseMap;
+}
+
+/**
+ * Find matching new URL for a given URL, checking exact, base, and WordPress image-size matches
+ */
+export function findMatchingUrl(
+	url: string,
+	exactMap: Record<string, string>,
+	baseMap: Map<string, string>,
+): string | null {
+	if (exactMap[url]) {
+		return exactMap[url];
+	}
+
+	const baseUrl = getBaseUrl(url);
+	const baseMatch = baseMap.get(baseUrl);
+	if (baseMatch) {
+		return baseMatch;
+	}
+
+	const wordPressImageMatch = baseMap.get(stripWordPressImageSizeSuffix(baseUrl));
+	if (wordPressImageMatch) {
+		return wordPressImageMatch;
+	}
+
+	return null;
+}
+
+/**
+ * Portable Text block type (simplified for URL rewriting)
+ */
+export interface PortableTextBlock {
+	_type: string;
+	_key?: string;
+	asset?: {
+		_type?: string;
+		_ref?: string;
+		url?: string;
+	};
+	link?: string;
+	// For nested content like galleries
+	images?: PortableTextBlock[];
+	columns?: Array<{ content?: PortableTextBlock[] }>;
+	[key: string]: unknown;
+}
+
+/**
+ * Rewrite URLs in a Portable Text array, returning whether any changes were made
+ */
+export function rewritePortableTextUrls(
+	blocks: PortableTextBlock[],
+	exactMap: Record<string, string>,
+	baseMap: Map<string, string>,
+): { changed: boolean; urlsRewritten: number } {
+	let changed = false;
+	let urlsRewritten = 0;
+
+	for (const block of blocks) {
+		// Handle image blocks
+		if (block._type === "image" && block.asset?.url) {
+			const newUrl = findMatchingUrl(block.asset.url, exactMap, baseMap);
+			if (newUrl) {
+				block.asset.url = newUrl;
+				block.asset._ref = newUrl; // Also update the reference
+				changed = true;
+				urlsRewritten++;
+			}
+		}
+
+		// Handle image link URLs (for linked images)
+		if (block._type === "image" && block.link) {
+			const newUrl = findMatchingUrl(block.link, exactMap, baseMap);
+			if (newUrl) {
+				block.link = newUrl;
+				changed = true;
+				urlsRewritten++;
+			}
+		}
+
+		// Handle gallery blocks with nested images
+		if (block._type === "gallery" && Array.isArray(block.images)) {
+			const result = rewritePortableTextUrls(block.images, exactMap, baseMap);
+			if (result.changed) {
+				changed = true;
+				urlsRewritten += result.urlsRewritten;
+			}
+		}
+
+		// Handle columns blocks with nested content
+		if (block._type === "columns" && Array.isArray(block.columns)) {
+			for (const column of block.columns) {
+				if (Array.isArray(column.content)) {
+					const result = rewritePortableTextUrls(column.content, exactMap, baseMap);
+					if (result.changed) {
+						changed = true;
+						urlsRewritten += result.urlsRewritten;
+					}
+				}
+			}
+		}
+	}
+
+	return { changed, urlsRewritten };
+}
+
+/**
+ * Rewrite URLs in a string field using simple string replacement
+ */
+export function rewriteStringUrls(
+	value: string,
+	exactMap: Record<string, string>,
+	baseMap: Map<string, string>,
+): { newValue: string; changed: boolean; urlsRewritten: number } {
+	let newValue = value;
+	let changed = false;
+	let urlsRewritten = 0;
+
+	// Try exact matches first
+	for (const [oldUrl, newUrl] of Object.entries(exactMap)) {
+		if (newValue.includes(oldUrl)) {
+			newValue = newValue.split(oldUrl).join(newUrl);
+			changed = true;
+			urlsRewritten++;
+		}
+	}
+
+	// For base URL matching in strings, we need to be more careful
+	// Only match if we find a URL that starts with the base
+	for (const [baseUrl, newUrl] of baseMap.entries()) {
+		// Look for the base URL followed by optional query string or end
+		const regex = buildBaseUrlMatchRegex(baseUrl);
+		const matches = newValue.match(regex);
+		if (matches) {
+			for (const match of matches) {
+				// Don't replace if we already have an exact match in the map
+				if (!exactMap[match]) {
+					newValue = newValue.split(match).join(newUrl);
+					changed = true;
+					urlsRewritten++;
+				}
+			}
+		}
+	}
+
+	return { newValue, changed, urlsRewritten };
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegExp(string: string): string {
+	return string.replace(REGEX_SPECIAL_CHARS, "\\$&");
+}
+
+function stripWordPressImageSizeSuffix(url: string): string {
+	return url.replace(WORDPRESS_IMAGE_SIZE_SUFFIX, "");
+}
+
+function buildBaseUrlMatchRegex(baseUrl: string): RegExp {
+	const extensionMatch = BASE_URL_EXTENSION.exec(baseUrl);
+	const basePattern = extensionMatch
+		? `${escapeRegExp(extensionMatch[1])}(?:-\\d+x\\d+)?${escapeRegExp(extensionMatch[2])}`
+		: escapeRegExp(baseUrl);
+
+	return new RegExp(
+		`${basePattern}(\\?[^"'\\s]*)?(?=$|["'\\s<>)\\],;:!?]|\\.(?=$|["'\\s<>)\\]]))`,
+		"g",
+	);
+}

package/src/astro/routes/api/import/wordpress/rewrite-urls.ts

@@ -22,9 +22,13 @@ import { normalizeMediaValue } from "#media/normalize.js";
 import type { MediaProvider } from "#media/types.js";
 import type { EmDashHandlers } from "#types";
 
-export const prerender = false;
-
-const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+import {
+	buildBaseUrlMap,
+	findMatchingUrl,
+	rewritePortableTextUrls,
+	rewriteStringUrls,
+} from "./rewrite-url-helpers.js";
+import type { PortableTextBlock } from "./rewrite-url-helpers.js";
 
 export interface RewriteUrlsResult {
 	/** Total items updated */
@@ -37,6 +41,8 @@ export interface RewriteUrlsResult {
 	errors: Array<{ collection: string; id: string; error: string }>;
 }
 
+export const prerender = false;
+
 export const POST: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
 
@@ -70,180 +76,6 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	}
 };
 
-/**
- * Strip query parameters from a URL for base matching
- */
-function getBaseUrl(url: string): string {
-	try {
-		const parsed = new URL(url);
-		return `${parsed.origin}${parsed.pathname}`;
-	} catch {
-		// If URL parsing fails, try simple string split
-		return url.split("?")[0] || url;
-	}
-}
-
-/**
- * Build a map of base URLs to new URLs for flexible matching
- */
-function buildBaseUrlMap(urlMap: Record<string, string>): Map<string, string> {
-	const baseMap = new Map<string, string>();
-	for (const [oldUrl, newUrl] of Object.entries(urlMap)) {
-		const baseUrl = getBaseUrl(oldUrl);
-		baseMap.set(baseUrl, newUrl);
-	}
-	return baseMap;
-}
-
-/**
- * Find matching new URL for a given URL, checking both exact and base matches
- */
-function findMatchingUrl(
-	url: string,
-	exactMap: Record<string, string>,
-	baseMap: Map<string, string>,
-): string | null {
-	// Try exact match first
-	if (exactMap[url]) {
-		return exactMap[url];
-	}
-
-	// Try base URL match (ignoring query params)
-	const baseUrl = getBaseUrl(url);
-	const baseMatch = baseMap.get(baseUrl);
-	if (baseMatch) {
-		return baseMatch;
-	}
-
-	return null;
-}
-
-/**
- * Portable Text block type (simplified for URL rewriting)
- */
-interface PortableTextBlock {
-	_type: string;
-	_key?: string;
-	asset?: {
-		_type?: string;
-		_ref?: string;
-		url?: string;
-	};
-	link?: string;
-	// For nested content like galleries
-	images?: PortableTextBlock[];
-	columns?: Array<{ content?: PortableTextBlock[] }>;
-	[key: string]: unknown;
-}
-
-/**
- * Rewrite URLs in a Portable Text array, returning whether any changes were made
- */
-function rewritePortableTextUrls(
-	blocks: PortableTextBlock[],
-	exactMap: Record<string, string>,
-	baseMap: Map<string, string>,
-): { changed: boolean; urlsRewritten: number } {
-	let changed = false;
-	let urlsRewritten = 0;
-
-	for (const block of blocks) {
-		// Handle image blocks
-		if (block._type === "image" && block.asset?.url) {
-			const newUrl = findMatchingUrl(block.asset.url, exactMap, baseMap);
-			if (newUrl) {
-				block.asset.url = newUrl;
-				block.asset._ref = newUrl; // Also update the reference
-				changed = true;
-				urlsRewritten++;
-			}
-		}
-
-		// Handle image link URLs (for linked images)
-		if (block._type === "image" && block.link) {
-			const newUrl = findMatchingUrl(block.link, exactMap, baseMap);
-			if (newUrl) {
-				block.link = newUrl;
-				changed = true;
-				urlsRewritten++;
-			}
-		}
-
-		// Handle gallery blocks with nested images
-		if (block._type === "gallery" && Array.isArray(block.images)) {
-			const result = rewritePortableTextUrls(block.images, exactMap, baseMap);
-			if (result.changed) {
-				changed = true;
-				urlsRewritten += result.urlsRewritten;
-			}
-		}
-
-		// Handle columns blocks with nested content
-		if (block._type === "columns" && Array.isArray(block.columns)) {
-			for (const column of block.columns) {
-				if (Array.isArray(column.content)) {
-					const result = rewritePortableTextUrls(column.content, exactMap, baseMap);
-					if (result.changed) {
-						changed = true;
-						urlsRewritten += result.urlsRewritten;
-					}
-				}
-			}
-		}
-	}
-
-	return { changed, urlsRewritten };
-}
-
-/**
- * Rewrite URLs in a string field using simple string replacement
- */
-function rewriteStringUrls(
-	value: string,
-	exactMap: Record<string, string>,
-	baseMap: Map<string, string>,
-): { newValue: string; changed: boolean; urlsRewritten: number } {
-	let newValue = value;
-	let changed = false;
-	let urlsRewritten = 0;
-
-	// Try exact matches first
-	for (const [oldUrl, newUrl] of Object.entries(exactMap)) {
-		if (newValue.includes(oldUrl)) {
-			newValue = newValue.split(oldUrl).join(newUrl);
-			changed = true;
-			urlsRewritten++;
-		}
-	}
-
-	// For base URL matching in strings, we need to be more careful
-	// Only match if we find a URL that starts with the base
-	for (const [baseUrl, newUrl] of baseMap.entries()) {
-		// Look for the base URL followed by optional query string or end
-		const regex = new RegExp(escapeRegExp(baseUrl) + "(\\?[^\"'\\s]*)?", "g");
-		const matches = newValue.match(regex);
-		if (matches) {
-			for (const match of matches) {
-				// Don't replace if we already have an exact match in the map
-				if (!exactMap[match]) {
-					newValue = newValue.split(match).join(newUrl);
-					changed = true;
-					urlsRewritten++;
-				}
-			}
-		}
-	}
-
-	return { newValue, changed, urlsRewritten };
-}
-
-/**
- * Escape special regex characters in a string
- */
-function escapeRegExp(string: string): string {
-	return string.replace(REGEX_SPECIAL_CHARS, "\\$&");
-}
-
 async function rewriteUrls(
 	db: NonNullable<EmDashHandlers["db"]>,
 	urlMap: Record<string, string>,

package/src/astro/routes/api/import/wordpress-plugin/execute.ts

@@ -36,7 +36,7 @@ export interface WpPluginImportResponse {
 }
 
 export const POST: APIRoute = async ({ request, locals }) => {
-	const { emdash, emdashManifest, user } = locals;
+	const { emdash, user } = locals;
 
 	const denied = requirePerm(user, "import:execute");
 	if (denied) return denied;
@@ -46,6 +46,8 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	}
 
 	try {
+		const emdashManifest = await emdash.getManifest();
+
 		const body = await parseBody(request, wpPluginExecuteBody);
 		if (isParseError(body)) return body;
 

package/src/astro/routes/api/manifest.ts

@@ -9,64 +9,81 @@
 
 import type { APIRoute } from "astro";
 
+import { handleError } from "#api/error.js";
 import { getAuthMode } from "#auth/mode.js";
 
 import { COMMIT, VERSION } from "../../../version.js";
-import { getStoredConfig } from "../../integration/runtime.js";
 import type { EmDashManifest } from "../../types.js";
 
 export const prerender = false;
 
 export const GET: APIRoute = async ({ locals }) => {
-	const { emdashManifest, emdash } = locals;
+	const { emdash } = locals;
 
-	// Determine auth mode from config
-	const authMode = getAuthMode(emdash?.config);
+	try {
+		// Manifest is built fresh from the live database per admin request.
+		// `requestCached` inside `getManifest` dedupes if multiple consumers
+		// share the request. Wrapped in try/catch so any future DB-touching
+		// additions to `getManifest()` (plugin manifest loading, marketplace
+		// lookup, etc.) return the standard error envelope rather than an
+		// unstructured 500 — matches the pattern used by the WP execute
+		// routes.
+		const emdashManifest = emdash ? await emdash.getManifest() : null;
 
-	// Read admin branding from build-time config
-	const storedConfig = getStoredConfig();
-	const adminBranding = storedConfig?.admin;
+		// Determine auth mode from config
+		const authMode = getAuthMode(emdash?.config);
 
-	// Check if self-signup is enabled (any allowed domain with enabled = 1)
-	// Only relevant for passkey auth — external auth providers handle their own signup
-	let signupEnabled = false;
-	if (emdash?.db && authMode.type === "passkey") {
-		try {
-			const { sql } = await import("kysely");
-			const result = await sql<{ cnt: unknown }>`
-				SELECT COUNT(*) as cnt FROM allowed_domains WHERE enabled = 1
-			`.execute(emdash.db);
-			signupEnabled = Number(result.rows[0]?.cnt ?? 0) > 0;
-		} catch {
-			// Table may not exist yet, that's fine
-		}
-	}
+		// Read admin branding from the per-request config plumbed through middleware
+		// (same source admin.astro reads from). Reading from a build-time global
+		// here was unreliable -- the virtual config module exports the config but
+		// doesn't assign it to globalThis, so getStoredConfig() always returned
+		// null and the React SPA never received custom logo/siteName/favicon.
+		// See issue #835.
+		const adminBranding = emdash?.config?.admin;
 
-	const manifest: EmDashManifest = emdashManifest
-		? {
-				...emdashManifest,
-				authMode: authMode.type === "external" ? authMode.providerType : "passkey",
-				signupEnabled,
-				admin: adminBranding,
+		// Check if self-signup is enabled (any allowed domain with enabled = 1)
+		// Only relevant for passkey auth — external auth providers handle their own signup
+		let signupEnabled = false;
+		if (emdash?.db && authMode.type === "passkey") {
+			try {
+				const { sql } = await import("kysely");
+				const result = await sql<{ cnt: unknown }>`
+					SELECT COUNT(*) as cnt FROM allowed_domains WHERE enabled = 1
+				`.execute(emdash.db);
+				signupEnabled = Number(result.rows[0]?.cnt ?? 0) > 0;
+			} catch {
+				// Table may not exist yet, that's fine
 			}
-		: {
-				version: VERSION,
-				commit: COMMIT,
-				hash: "default",
-				collections: {},
-				plugins: {},
-				taxonomies: [],
-				authMode: "passkey",
-				signupEnabled,
-				admin: adminBranding,
-			};
+		}
 
-	return Response.json(
-		{ data: manifest },
-		{
-			headers: {
-				"Cache-Control": "private, no-store",
+		const manifest: EmDashManifest = emdashManifest
+			? {
+					...emdashManifest,
+					authMode: authMode.type === "external" ? authMode.providerType : "passkey",
+					signupEnabled,
+					admin: adminBranding,
+				}
+			: {
+					version: VERSION,
+					commit: COMMIT,
+					hash: "default",
+					collections: {},
+					plugins: {},
+					taxonomies: [],
+					authMode: "passkey",
+					signupEnabled,
+					admin: adminBranding,
+				};
+
+		return Response.json(
+			{ data: manifest },
+			{
+				headers: {
+					"Cache-Control": "private, no-store",
+				},
 			},
-		},
-	);
+		);
+	} catch (error) {
+		return handleError(error, "Failed to build manifest", "MANIFEST_BUILD_ERROR");
+	}
 };

package/src/astro/routes/api/media/[id]/confirm.ts

@@ -10,7 +10,7 @@
 import type { APIRoute } from "astro";
 import { MediaRepository } from "emdash";
 
-import { requirePerm } from "#api/authorize.js";
+import { requireOwnerPerm, requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseOptionalBody } from "#api/parse.js";
 import { mediaConfirmBody } from "#api/schemas.js";
@@ -62,6 +62,15 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 			return apiError("INVALID_STATE", `Media item is not pending: ${existing.status}`, 400);
 		}
 
+		// Only the uploader or a user with media:edit_any can confirm/fail a pending upload
+		const ownerDenied = requireOwnerPerm(
+			user,
+			existing.authorId ?? "",
+			"media:edit_own",
+			"media:edit_any",
+		);
+		if (ownerDenied) return ownerDenied;
+
 		// Optionally verify the file exists in storage
 		if (emdash.storage) {
 			const exists = await emdash.storage.exists(existing.storageKey);

package/src/astro/routes/api/media/providers/[providerId]/index.ts

@@ -37,9 +37,8 @@ export const GET: APIRoute = async ({ params, request, locals }) => {
 
 	const url = new URL(request.url);
 	const cursor = url.searchParams.get("cursor") || undefined;
-	const limit = url.searchParams.get("limit")
-		? parseInt(url.searchParams.get("limit")!, 10)
-		: undefined;
+	const rawLimit = url.searchParams.get("limit");
+	const limit = rawLimit ? Math.max(1, Math.min(parseInt(rawLimit, 10) || 50, 100)) : undefined;
 	const query = url.searchParams.get("query") || undefined;
 	const mimeType = url.searchParams.get("mimeType") || undefined;
 
@@ -98,6 +97,16 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 			return apiError("NO_FILE", "No file provided", 400);
 		}
 
+		// Basic size validation (default 50MB, configurable via maxUploadSize)
+		const maxSize = emdash.config?.maxUploadSize ?? 50 * 1024 * 1024;
+		if (file.size > maxSize) {
+			return apiError(
+				"FILE_TOO_LARGE",
+				`File exceeds maximum size of ${Math.round(maxSize / 1024 / 1024)}MB`,
+				413,
+			);
+		}
+
 		const item = await provider.upload({
 			file,
 			filename: file.name,

package/src/astro/routes/api/menus/[name]/items.ts

@@ -1,9 +1,9 @@
 /**
  * Menu items CRUD endpoints
  *
- * POST   /_emdash/api/menus/:name/items - Add item
- * PUT    /_emdash/api/menus/:name/items/:id - Update item
- * DELETE /_emdash/api/menus/:name/items/:id - Delete item
+ * POST   /_emdash/api/menus/:name/items[?locale=xx]
+ * PUT    /_emdash/api/menus/:name/items?id=...[&locale=xx]
+ * DELETE /_emdash/api/menus/:name/items?id=...[&locale=xx]
  */
 
 import type { APIRoute } from "astro";
@@ -18,6 +18,7 @@ import {
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
 import {
 	createMenuItemBody,
+	localeFilterQuery,
 	menuItemDeleteQuery,
 	menuItemUpdateQuery,
 	updateMenuItemBody,
@@ -32,11 +33,14 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "menus:manage");
 	if (denied) return denied;
 
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
 	try {
 		const body = await parseBody(request, createMenuItemBody);
 		if (isParseError(body)) return body;
 
-		const result = await handleMenuItemCreate(emdash.db, name, body);
+		const result = await handleMenuItemCreate(emdash.db, name, body, { locale: localeQ.locale });
 		return unwrapResult(result, 201);
 	} catch (error) {
 		return handleError(error, "Failed to create menu item", "MENU_ITEM_CREATE_ERROR");
@@ -53,13 +57,17 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const url = new URL(request.url);
 	const query = parseQuery(url, menuItemUpdateQuery);
 	if (isParseError(query)) return query;
+	const localeQ = parseQuery(url, localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
 	const itemId = query.id;
 
 	try {
 		const body = await parseBody(request, updateMenuItemBody);
 		if (isParseError(body)) return body;
 
-		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body);
+		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body, {
+			locale: localeQ.locale,
+		});
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to update menu item", "MENU_ITEM_UPDATE_ERROR");
@@ -76,10 +84,12 @@ export const DELETE: APIRoute = async ({ params, request, locals }) => {
 	const url = new URL(request.url);
 	const query = parseQuery(url, menuItemDeleteQuery);
 	if (isParseError(query)) return query;
+	const localeQ = parseQuery(url, localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
 	const itemId = query.id;
 
 	try {
-		const result = await handleMenuItemDelete(emdash.db, name, itemId);
+		const result = await handleMenuItemDelete(emdash.db, name, itemId, { locale: localeQ.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to delete menu item", "MENU_ITEM_DELETE_ERROR");