emdash 0.0.0-b → 0.0.2

package/src/import/sources/wordpress-rest.ts

@@ -0,0 +1,191 @@
+/**
+ * WordPress REST API probe
+ *
+ * Probes self-hosted WordPress sites to detect capabilities.
+ * This source is probe-only - it tells users what's available
+ * and suggests next steps (usually: upload WXR file).
+ */
+
+import { ssrfSafeFetch, validateExternalUrl } from "../ssrf.js";
+import type {
+	ImportSource,
+	ImportAnalysis,
+	ImportContext,
+	SourceInput,
+	SourceProbeResult,
+	FetchOptions,
+	NormalizedItem,
+} from "../types.js";
+
+const TRAILING_SLASHES = /\/+$/;
+const WP_JSON_SUFFIX = /\/wp-json\/?$/;
+
+/** WordPress REST API discovery response */
+interface WpApiDiscovery {
+	name?: string;
+	description?: string;
+	url?: string;
+	home?: string;
+	gmt_offset?: number;
+	timezone_string?: string;
+	namespaces?: string[];
+	authentication?: Record<string, unknown>;
+	routes?: Record<string, unknown>;
+}
+
+export const wordpressRestSource: ImportSource = {
+	id: "wordpress-rest",
+	name: "WordPress Site",
+	description: "Connect to a self-hosted WordPress site",
+	icon: "globe",
+	requiresFile: false,
+	canProbe: true,
+
+	async probe(url: string): Promise<SourceProbeResult | null> {
+		try {
+			const siteUrl = normalizeUrl(url);
+
+			// SSRF protection: validate URL before any outbound requests
+			validateExternalUrl(siteUrl);
+
+			// Try to fetch the WP REST API root
+			const apiUrl = `${siteUrl}/wp-json/`;
+			const response = await ssrfSafeFetch(apiUrl, {
+				headers: { Accept: "application/json" },
+				signal: AbortSignal.timeout(10000),
+			});
+
+			if (!response.ok) {
+				// Try alternate location (some sites use different prefix)
+				const altResponse = await ssrfSafeFetch(`${siteUrl}/?rest_route=/`, {
+					headers: { Accept: "application/json" },
+					signal: AbortSignal.timeout(10000),
+				});
+
+				if (!altResponse.ok) {
+					return null;
+				}
+			}
+
+			const data: WpApiDiscovery = await response.json();
+
+			// Check if this looks like WordPress
+			if (!data.namespaces?.includes("wp/v2")) {
+				return null;
+			}
+
+			// Get content counts (unauthenticated - published only)
+			const preview = await getPublicContentCounts(siteUrl);
+
+			// Check for authentication methods
+			const hasAppPasswords = !!data.authentication?.["application-passwords"];
+
+			return {
+				sourceId: "wordpress-rest",
+				confidence: "definite",
+				detected: {
+					platform: "wordpress",
+					siteTitle: data.name,
+					siteUrl: data.url || data.home || siteUrl,
+				},
+				capabilities: {
+					publicContent: true,
+					privateContent: false, // Would need auth
+					customPostTypes: false, // Only if show_in_rest: true
+					allMeta: false, // Only if registered for REST
+					mediaStream: true,
+				},
+				auth: hasAppPasswords
+					? {
+							type: "password",
+							instructions:
+								"To import drafts and private content, create an Application Password in WordPress → Users → Your Profile → Application Passwords",
+						}
+					: undefined,
+				preview,
+				suggestedAction: {
+					type: "upload",
+					instructions:
+						"For a complete import including drafts, custom post types, and all metadata, export your content from WordPress (Tools → Export) and upload the file here.",
+				},
+			};
+		} catch {
+			// Probe failed - not a WordPress site or not accessible
+			return null;
+		}
+	},
+
+	async analyze(_input: SourceInput, _context: ImportContext): Promise<ImportAnalysis> {
+		// REST-only import not implemented - we use this for probe only
+		// and suggest WXR upload for actual import
+		throw new Error("Direct REST API import not implemented. Please upload a WXR export file.");
+	},
+
+	// eslint-disable-next-line require-yield
+	async *fetchContent(_input: SourceInput, _options: FetchOptions): AsyncGenerator<NormalizedItem> {
+		throw new Error("Direct REST API import not implemented. Please upload a WXR export file.");
+	},
+};
+
+/**
+ * Normalize a URL for API requests
+ */
+function normalizeUrl(url: string): string {
+	let normalized = url.trim();
+
+	// Add protocol if missing
+	if (!normalized.startsWith("http")) {
+		normalized = `https://${normalized}`;
+	}
+
+	// Remove trailing slash
+	normalized = normalized.replace(TRAILING_SLASHES, "");
+
+	// Remove /wp-json if included
+	normalized = normalized.replace(WP_JSON_SUFFIX, "");
+
+	return normalized;
+}
+
+/**
+ * Get public content counts from REST API
+ */
+async function getPublicContentCounts(
+	siteUrl: string,
+): Promise<{ posts?: number; pages?: number; media?: number }> {
+	const result: { posts?: number; pages?: number; media?: number } = {};
+
+	try {
+		// Fetch with per_page=1 to get total from headers
+		const [postsRes, pagesRes, mediaRes] = await Promise.allSettled([
+			ssrfSafeFetch(`${siteUrl}/wp-json/wp/v2/posts?per_page=1`, {
+				signal: AbortSignal.timeout(5000),
+			}),
+			ssrfSafeFetch(`${siteUrl}/wp-json/wp/v2/pages?per_page=1`, {
+				signal: AbortSignal.timeout(5000),
+			}),
+			ssrfSafeFetch(`${siteUrl}/wp-json/wp/v2/media?per_page=1`, {
+				signal: AbortSignal.timeout(5000),
+			}),
+		]);
+
+		if (postsRes.status === "fulfilled" && postsRes.value.ok) {
+			const total = postsRes.value.headers.get("X-WP-Total");
+			if (total) result.posts = parseInt(total, 10);
+		}
+
+		if (pagesRes.status === "fulfilled" && pagesRes.value.ok) {
+			const total = pagesRes.value.headers.get("X-WP-Total");
+			if (total) result.pages = parseInt(total, 10);
+		}
+
+		if (mediaRes.status === "fulfilled" && mediaRes.value.ok) {
+			const total = mediaRes.value.headers.get("X-WP-Total");
+			if (total) result.media = parseInt(total, 10);
+		}
+	} catch {
+		// Counts are optional, continue without them
+	}
+
+	return result;
+}

package/src/import/sources/wxr.ts

@@ -0,0 +1,330 @@
+/**
+ * WXR (WordPress eXtended RSS) import source
+ *
+ * Handles WordPress export file uploads (.xml).
+ * This wraps the existing WXR parsing and analysis logic.
+ */
+
+import { gutenbergToPortableText } from "@emdash-cms/gutenberg-to-portable-text";
+
+import { parseWxrString, type WxrData, type WxrPost } from "../../cli/wxr/parser.js";
+import type {
+	ImportSource,
+	ImportAnalysis,
+	ImportContext,
+	SourceInput,
+	FetchOptions,
+	NormalizedItem,
+	PostTypeAnalysis,
+	AttachmentInfo,
+	NavMenuAnalysis,
+	TaxonomyAnalysis,
+	ReusableBlockAnalysis,
+} from "../types.js";
+import {
+	BASE_REQUIRED_FIELDS,
+	FEATURED_IMAGE_FIELD,
+	isInternalPostType,
+	isInternalMetaKey,
+	mapWpStatus,
+	mapPostTypeToCollection,
+	mapMetaKeyToField,
+	inferMetaType,
+	slugify,
+	buildAttachmentMap,
+	getFilenameFromUrl,
+	guessMimeType,
+	checkSchemaCompatibility,
+} from "../utils.js";
+
+export const wxrSource: ImportSource = {
+	id: "wxr",
+	name: "WordPress Export File",
+	description: "Upload a WordPress export file (.xml)",
+	icon: "upload",
+	requiresFile: true,
+	canProbe: false,
+
+	async analyze(input: SourceInput, context: ImportContext): Promise<ImportAnalysis> {
+		if (input.type !== "file") {
+			throw new Error("WXR source requires a file input");
+		}
+
+		const text = await input.file.text();
+		const wxr = await parseWxrString(text);
+
+		// Get existing collections for schema compatibility check
+		const existingCollections = context.getExistingCollections
+			? await context.getExistingCollections()
+			: new Map();
+
+		return analyzeWxrData(wxr, existingCollections);
+	},
+
+	async *fetchContent(input: SourceInput, options: FetchOptions): AsyncGenerator<NormalizedItem> {
+		if (input.type !== "file") {
+			throw new Error("WXR source requires a file input");
+		}
+
+		const text = await input.file.text();
+		const wxr = await parseWxrString(text);
+
+		// Build attachment ID -> URL map for resolving featured images
+		const attachmentMap = buildAttachmentMap(wxr.attachments);
+
+		let count = 0;
+		for (const post of wxr.posts) {
+			const postType = post.postType || "post";
+
+			// Skip if not in requested post types
+			if (!options.postTypes.includes(postType)) {
+				continue;
+			}
+
+			// Skip internal post types
+			if (isInternalPostType(postType)) {
+				continue;
+			}
+
+			// Skip drafts if not requested
+			if (!options.includeDrafts && post.status !== "publish") {
+				continue;
+			}
+
+			// Convert to normalized item
+			yield wxrPostToNormalizedItem(post, attachmentMap);
+
+			count++;
+			if (options.limit && count >= options.limit) {
+				break;
+			}
+		}
+	},
+};
+
+/**
+ * Analyze WXR data and return normalized ImportAnalysis
+ */
+function analyzeWxrData(
+	wxr: WxrData,
+	existingCollections: Map<string, { slug: string; fields: Map<string, { type: string }> }>,
+): ImportAnalysis {
+	// Count post types and track which have featured images
+	const postTypeCounts = new Map<string, number>();
+	const postTypesWithThumbnails = new Set<string>();
+	const metaKeys = new Map<string, { count: number; samples: string[]; isInternal: boolean }>();
+	const authorPostCounts = new Map<string, number>();
+
+	for (const post of wxr.posts) {
+		const type = post.postType || "post";
+		postTypeCounts.set(type, (postTypeCounts.get(type) || 0) + 1);
+
+		// Count posts per author (by login)
+		if (post.creator) {
+			authorPostCounts.set(post.creator, (authorPostCounts.get(post.creator) || 0) + 1);
+		}
+
+		// Track if this post type has featured images
+		if (post.meta.has("_thumbnail_id")) {
+			postTypesWithThumbnails.add(type);
+		}
+
+		// Analyze meta keys
+		for (const [key, value] of post.meta) {
+			const existing = metaKeys.get(key);
+			if (existing) {
+				existing.count++;
+				if (existing.samples.length < 3 && value) {
+					existing.samples.push(value.slice(0, 100));
+				}
+			} else {
+				metaKeys.set(key, {
+					count: 1,
+					samples: value ? [value.slice(0, 100)] : [],
+					isInternal: isInternalMetaKey(key),
+				});
+			}
+		}
+	}
+
+	// Map meta keys to fields (for custom fields analysis)
+	const customFields = [...metaKeys.entries()]
+		.filter(([_, info]) => !info.isInternal)
+		.map(([key, info]) => ({
+			key,
+			count: info.count,
+			samples: info.samples,
+			suggestedField: mapMetaKeyToField(key),
+			suggestedType: inferMetaType(key, info.samples[0]),
+			isInternal: info.isInternal,
+		}))
+		.toSorted((a, b) => b.count - a.count);
+
+	// Build post type analysis with schema compatibility
+	const postTypes: PostTypeAnalysis[] = [...postTypeCounts.entries()]
+		.filter(([type]) => !isInternalPostType(type))
+		.map(([name, count]) => {
+			const suggestedCollection = mapPostTypeToCollection(name);
+			const existingCollection = existingCollections.get(suggestedCollection);
+
+			// Build required fields - add featured_image only if posts have thumbnails
+			const requiredFields = [...BASE_REQUIRED_FIELDS];
+			if (postTypesWithThumbnails.has(name)) {
+				requiredFields.push(FEATURED_IMAGE_FIELD);
+			}
+
+			const schemaStatus = checkSchemaCompatibility(requiredFields, existingCollection);
+
+			return {
+				name,
+				count,
+				suggestedCollection,
+				requiredFields,
+				schemaStatus,
+			};
+		})
+		.toSorted((a, b) => b.count - a.count);
+
+	// Build attachment info list
+	const attachmentItems: AttachmentInfo[] = wxr.attachments.map((att) => {
+		const filename = att.url ? getFilenameFromUrl(att.url) : undefined;
+		const mimeType = filename ? guessMimeType(filename) : undefined;
+		return {
+			id: att.id,
+			title: att.title,
+			url: att.url,
+			filename,
+			mimeType,
+		};
+	});
+
+	// Analyze navigation menus
+	const navMenus: NavMenuAnalysis[] = wxr.navMenus.map((menu) => ({
+		name: menu.name,
+		label: menu.label,
+		itemCount: menu.items.length,
+	}));
+
+	// Analyze custom taxonomies (from wp:term elements, excluding category/post_tag/nav_menu)
+	const taxonomyMap = new Map<string, { count: number; samples: string[] }>();
+	for (const term of wxr.terms) {
+		if (
+			term.taxonomy === "category" ||
+			term.taxonomy === "post_tag" ||
+			term.taxonomy === "nav_menu"
+		) {
+			continue;
+		}
+
+		const existing = taxonomyMap.get(term.taxonomy);
+		if (existing) {
+			existing.count++;
+			if (existing.samples.length < 3) {
+				existing.samples.push(term.name);
+			}
+		} else {
+			taxonomyMap.set(term.taxonomy, {
+				count: 1,
+				samples: [term.name],
+			});
+		}
+	}
+
+	const customTaxonomies: TaxonomyAnalysis[] = Array.from(
+		taxonomyMap.entries(),
+		([slug, info]) => ({
+			slug,
+			termCount: info.count,
+			sampleTerms: info.samples,
+		}),
+	).toSorted((a, b) => b.termCount - a.termCount);
+
+	// Analyze reusable blocks (wp_block post type)
+	const reusableBlocks: ReusableBlockAnalysis[] = wxr.posts
+		.filter((post) => post.postType === "wp_block")
+		.map((post) => ({
+			id: post.id || 0,
+			title: post.title || "Untitled Block",
+			slug: post.postName || slugify(post.title || `block-${post.id || Date.now()}`),
+		}));
+
+	return {
+		sourceId: "wxr",
+		site: {
+			title: wxr.site.title || "WordPress Site",
+			url: wxr.site.link || "",
+		},
+		postTypes,
+		attachments: {
+			count: wxr.attachments.length,
+			items: attachmentItems,
+		},
+		categories: wxr.categories.length,
+		tags: wxr.tags.length,
+		authors: wxr.authors.map((a) => ({
+			id: a.id,
+			login: a.login,
+			email: a.email,
+			displayName: a.displayName || a.login || "Unknown",
+			postCount: a.login ? authorPostCounts.get(a.login) || 0 : 0,
+		})),
+		navMenus: navMenus.length > 0 ? navMenus : undefined,
+		customTaxonomies: customTaxonomies.length > 0 ? customTaxonomies : undefined,
+		reusableBlocks: reusableBlocks.length > 0 ? reusableBlocks : undefined,
+		customFields,
+	};
+}
+
+/**
+ * Convert a WXR post to a normalized item
+ */
+function wxrPostToNormalizedItem(
+	post: WxrPost,
+	attachmentMap: Map<string, string>,
+): NormalizedItem {
+	const content = post.content ? gutenbergToPortableText(post.content) : [];
+
+	// Resolve featured image: _thumbnail_id is the attachment ID, look up the URL
+	const thumbnailId = post.meta.get("_thumbnail_id");
+	const featuredImage = thumbnailId ? attachmentMap.get(String(thumbnailId)) : undefined;
+
+	// Convert custom taxonomies Map to Record
+	let customTaxonomies: Record<string, string[]> | undefined;
+	if (post.customTaxonomies && post.customTaxonomies.size > 0) {
+		customTaxonomies = Object.fromEntries(post.customTaxonomies);
+	}
+
+	return {
+		sourceId: post.id || 0,
+		postType: post.postType || "post",
+		status: mapWpStatus(post.status),
+		slug: post.postName || slugify(post.title || `post-${post.id || Date.now()}`),
+		title: post.title || "Untitled",
+		content,
+		excerpt: post.excerpt,
+		date: post.postDate ? new Date(post.postDate) : new Date(),
+		modified: post.postModified ? new Date(post.postModified) : undefined,
+		author: post.creator,
+		categories: post.categories,
+		tags: post.tags,
+		meta: Object.fromEntries(post.meta),
+		featuredImage,
+		// Hierarchical content support
+		parentId: post.postParent && post.postParent !== 0 ? post.postParent : undefined,
+		menuOrder: post.menuOrder,
+		// Custom taxonomy assignments
+		customTaxonomies,
+	};
+}
+
+// Export for use in other sources
+export { analyzeWxrData, wxrPostToNormalizedItem };
+
+// Re-export shared utilities that other sources may need
+export {
+	BASE_REQUIRED_FIELDS,
+	FEATURED_IMAGE_FIELD,
+	mapPostTypeToCollection,
+	isInternalPostType,
+	checkSchemaCompatibility,
+} from "../utils.js";