emdash 0.0.0-b → 0.0.2

package/src/import/registry.ts

@@ -0,0 +1,111 @@
+/**
+ * Import source registry
+ *
+ * Manages available import sources and provides URL probing.
+ */
+
+import { validateExternalUrl } from "./ssrf.js";
+import type { ImportSource, ProbeResult, SourceProbeResult } from "./types.js";
+
+// Regex pattern for URL normalization
+const TRAILING_SLASHES_PATTERN = /\/+$/;
+
+/** Registered import sources */
+const sources = new Map<string, ImportSource>();
+
+/**
+ * Register an import source
+ */
+export function registerSource(source: ImportSource): void {
+	sources.set(source.id, source);
+}
+
+/**
+ * Get a source by ID
+ */
+export function getSource(id: string): ImportSource | undefined {
+	return sources.get(id);
+}
+
+/**
+ * Get all registered sources
+ */
+export function getAllSources(): ImportSource[] {
+	return [...sources.values()];
+}
+
+/**
+ * Get sources that can handle file uploads
+ */
+export function getFileSources(): ImportSource[] {
+	return getAllSources().filter((s) => s.requiresFile);
+}
+
+/**
+ * Get sources that can probe URLs
+ */
+export function getUrlSources(): ImportSource[] {
+	return getAllSources().filter((s) => s.canProbe);
+}
+
+/**
+ * Probe a URL against all registered sources
+ *
+ * Returns probe results sorted by confidence (definite > likely > possible)
+ */
+export async function probeUrl(url: string): Promise<ProbeResult> {
+	// Normalize URL
+	let normalizedUrl = url.trim();
+	if (!normalizedUrl.startsWith("http")) {
+		normalizedUrl = `https://${normalizedUrl}`;
+	}
+
+	// Remove trailing slash for consistency
+	normalizedUrl = normalizedUrl.replace(TRAILING_SLASHES_PATTERN, "");
+
+	// SSRF: reject internal/private network targets
+	validateExternalUrl(normalizedUrl);
+
+	const results: SourceProbeResult[] = [];
+	const urlSources = getUrlSources();
+
+	// Probe all sources in parallel
+	const probePromises = urlSources.map(async (source) => {
+		try {
+			const result = await source.probe?.(normalizedUrl);
+			if (result) {
+				return result;
+			}
+		} catch (error) {
+			// Probe failed, skip this source
+			console.debug(`Probe failed for ${source.id}:`, error);
+		}
+		return null;
+	});
+
+	const probeResults = await Promise.allSettled(probePromises);
+
+	for (const result of probeResults) {
+		if (result.status === "fulfilled" && result.value) {
+			results.push(result.value);
+		}
+	}
+
+	// Sort by confidence
+	const confidenceOrder = { definite: 0, likely: 1, possible: 2 };
+	results.sort((a, b) => confidenceOrder[a.confidence] - confidenceOrder[b.confidence]);
+
+	return {
+		url: normalizedUrl,
+		isWordPress: results.length > 0,
+		bestMatch: results[0] ?? null,
+		allMatches: results,
+	};
+}
+
+/**
+ * Clear all registered sources (useful for testing)
+ */
+export function clearSources(): void {
+	sources.clear();
+}

package/src/import/sections.ts

@@ -0,0 +1,103 @@
+/**
+ * Sections import functions
+ *
+ * Import reusable blocks from WordPress WXR exports as EmDash sections.
+ */
+
+import type { PortableTextBlock } from "@emdash-cms/gutenberg-to-portable-text";
+import { gutenbergToPortableText } from "@emdash-cms/gutenberg-to-portable-text";
+import type { Kysely } from "kysely";
+import { ulid } from "ulidx";
+
+import type { WxrPost } from "../cli/wxr/parser.js";
+import type { Database } from "../database/types.js";
+import { slugify } from "../utils/slugify.js";
+
+/**
+ * Result of sections import operation
+ */
+export interface SectionsImportResult {
+	/** Number of sections created */
+	sectionsCreated: number;
+	/** Number of sections skipped (already exist) */
+	sectionsSkipped: number;
+	/** Errors encountered during import */
+	errors: Array<{ title: string; error: string }>;
+}
+
+/**
+ * Import reusable blocks (wp_block post type) from WXR as sections
+ *
+ * @param posts - All posts from WXR (will filter to wp_block)
+ * @param db - Database connection
+ * @returns Import result with counts
+ */
+export async function importReusableBlocksAsSections(
+	posts: WxrPost[],
+	db: Kysely<Database>,
+): Promise<SectionsImportResult> {
+	const result: SectionsImportResult = {
+		sectionsCreated: 0,
+		sectionsSkipped: 0,
+		errors: [],
+	};
+
+	// Filter to only wp_block posts
+	const reusableBlocks = posts.filter((post) => post.postType === "wp_block");
+
+	if (reusableBlocks.length === 0) {
+		return result;
+	}
+
+	for (const block of reusableBlocks) {
+		try {
+			const slug = block.postName || slugify(block.title || `block-${block.id || Date.now()}`);
+
+			// Check if section already exists
+			const existing = await db
+				.selectFrom("_emdash_sections")
+				.select("id")
+				.where("slug", "=", slug)
+				.executeTakeFirst();
+
+			if (existing) {
+				result.sectionsSkipped++;
+				continue;
+			}
+
+			// Convert Gutenberg content to Portable Text
+			const content: PortableTextBlock[] = block.content
+				? gutenbergToPortableText(block.content)
+				: [];
+
+			const id = ulid();
+			const now = new Date().toISOString();
+
+			await db
+				.insertInto("_emdash_sections")
+				.values({
+					id,
+					slug,
+					title: block.title || "Untitled Block",
+					description: null,
+					keywords: null,
+					content: JSON.stringify(content),
+					preview_media_id: null,
+					source: "import",
+					theme_id: null,
+					created_at: now,
+					updated_at: now,
+				})
+				.execute();
+
+			result.sectionsCreated++;
+		} catch (error) {
+			result.errors.push({
+				title: block.title || "Untitled Block",
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	return result;
+}

package/src/import/settings.ts

@@ -0,0 +1,281 @@
+/**
+ * Site settings import functions
+ *
+ * Import site settings from WordPress (title, tagline, logo, favicon, etc.)
+ */
+
+import type { Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+
+/**
+ * Site settings analysis from import source
+ */
+export interface SiteSettingsAnalysis {
+	/** Site title */
+	title?: string;
+	/** Site tagline/description */
+	tagline?: string;
+	/** Custom logo */
+	logo?: { url: string; id?: number };
+	/** Favicon/site icon */
+	favicon?: { url: string; id?: number };
+	/** Front page settings */
+	frontPage?: { type: "posts" | "page"; pageId?: number };
+	/** SEO settings (Yoast, RankMath, etc.) */
+	seo?: Record<string, unknown>;
+}
+
+/**
+ * Widget area analysis
+ */
+export interface WidgetAreaAnalysis {
+	/** Widget area ID */
+	id: string;
+	/** Widget area name */
+	name: string;
+	/** Widget area label */
+	label: string;
+	/** Number of widgets */
+	widgetCount: number;
+	/** Widget summaries */
+	widgets: Array<{ type: string; title?: string }>;
+}
+
+/**
+ * Result of site settings import
+ */
+export interface SettingsImportResult {
+	/** Settings that were applied */
+	applied: string[];
+	/** Settings that were skipped (already set) */
+	skipped: string[];
+	/** Errors encountered */
+	errors: Array<{ setting: string; error: string }>;
+}
+
+/**
+ * Import site settings from analysis
+ *
+ * @param settings - Site settings analysis
+ * @param db - Database connection
+ * @param overwrite - Whether to overwrite existing settings
+ * @returns Import result
+ */
+export async function importSiteSettings(
+	settings: SiteSettingsAnalysis,
+	db: Kysely<Database>,
+	overwrite = false,
+): Promise<SettingsImportResult> {
+	const result: SettingsImportResult = {
+		applied: [],
+		skipped: [],
+		errors: [],
+	};
+
+	// Import title
+	if (settings.title) {
+		try {
+			const applied = await setOption(db, "site_title", settings.title, overwrite);
+			if (applied) {
+				result.applied.push("site_title");
+			} else {
+				result.skipped.push("site_title");
+			}
+		} catch (error) {
+			result.errors.push({
+				setting: "site_title",
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	// Import tagline
+	if (settings.tagline) {
+		try {
+			const applied = await setOption(db, "site_tagline", settings.tagline, overwrite);
+			if (applied) {
+				result.applied.push("site_tagline");
+			} else {
+				result.skipped.push("site_tagline");
+			}
+		} catch (error) {
+			result.errors.push({
+				setting: "site_tagline",
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	// Import logo URL (actual media import handled separately)
+	if (settings.logo?.url) {
+		try {
+			const applied = await setOption(db, "site_logo_url", settings.logo.url, overwrite);
+			if (applied) {
+				result.applied.push("site_logo_url");
+			} else {
+				result.skipped.push("site_logo_url");
+			}
+		} catch (error) {
+			result.errors.push({
+				setting: "site_logo_url",
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	// Import favicon URL
+	if (settings.favicon?.url) {
+		try {
+			const applied = await setOption(db, "site_favicon_url", settings.favicon.url, overwrite);
+			if (applied) {
+				result.applied.push("site_favicon_url");
+			} else {
+				result.skipped.push("site_favicon_url");
+			}
+		} catch (error) {
+			result.errors.push({
+				setting: "site_favicon_url",
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	// Import front page settings
+	if (settings.frontPage) {
+		try {
+			const applied = await setOption(db, "front_page_type", settings.frontPage.type, overwrite);
+			if (applied) {
+				result.applied.push("front_page_type");
+			} else {
+				result.skipped.push("front_page_type");
+			}
+
+			if (settings.frontPage.pageId) {
+				const pageApplied = await setOption(
+					db,
+					"front_page_id",
+					String(settings.frontPage.pageId),
+					overwrite,
+				);
+				if (pageApplied) {
+					result.applied.push("front_page_id");
+				} else {
+					result.skipped.push("front_page_id");
+				}
+			}
+		} catch (error) {
+			result.errors.push({
+				setting: "front_page",
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	// Import SEO settings as JSON blob
+	if (settings.seo && Object.keys(settings.seo).length > 0) {
+		try {
+			const applied = await setOption(db, "seo_settings", JSON.stringify(settings.seo), overwrite);
+			if (applied) {
+				result.applied.push("seo_settings");
+			} else {
+				result.skipped.push("seo_settings");
+			}
+		} catch (error) {
+			result.errors.push({
+				setting: "seo_settings",
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Set an option in the database
+ *
+ * @returns true if the option was set, false if skipped (already exists and !overwrite)
+ */
+async function setOption(
+	db: Kysely<Database>,
+	key: string,
+	value: string,
+	overwrite: boolean,
+): Promise<boolean> {
+	const existing = await db
+		.selectFrom("options")
+		.select("value")
+		.where("name", "=", key)
+		.executeTakeFirst();
+
+	if (existing && !overwrite) {
+		return false;
+	}
+
+	if (existing) {
+		await db.updateTable("options").set({ value }).where("name", "=", key).execute();
+	} else {
+		await db.insertInto("options").values({ name: key, value }).execute();
+	}
+
+	return true;
+}
+
+/**
+ * Parse site settings from WordPress plugin options response
+ */
+export function parseSiteSettingsFromPlugin(
+	options: Record<string, unknown>,
+): SiteSettingsAnalysis {
+	const settings: SiteSettingsAnalysis = {};
+
+	// Basic settings
+	if (typeof options.blogname === "string") {
+		settings.title = options.blogname;
+	}
+	if (typeof options.blogdescription === "string") {
+		settings.tagline = options.blogdescription;
+	}
+
+	// Logo and favicon
+	if (typeof options.custom_logo_url === "string") {
+		settings.logo = {
+			url: options.custom_logo_url,
+			id: typeof options.custom_logo === "number" ? options.custom_logo : undefined,
+		};
+	}
+	if (typeof options.site_icon_url === "string") {
+		settings.favicon = {
+			url: options.site_icon_url,
+			id: typeof options.site_icon === "number" ? options.site_icon : undefined,
+		};
+	}
+
+	// Front page settings
+	if (options.show_on_front === "page") {
+		settings.frontPage = {
+			type: "page",
+			pageId: typeof options.page_on_front === "number" ? options.page_on_front : undefined,
+		};
+	} else {
+		settings.frontPage = { type: "posts" };
+	}
+
+	// SEO settings (Yoast)
+	const seo: Record<string, unknown> = {};
+	if (typeof options.wpseo === "object" && options.wpseo !== null) {
+		seo.yoast = options.wpseo;
+	}
+	if (typeof options.wpseo_titles === "object" && options.wpseo_titles !== null) {
+		seo.yoast_titles = options.wpseo_titles;
+	}
+	if (typeof options.wpseo_social === "object" && options.wpseo_social !== null) {
+		seo.yoast_social = options.wpseo_social;
+	}
+	if (Object.keys(seo).length > 0) {
+		settings.seo = seo;
+	}
+
+	return settings;
+}