@fumadocs/cli 1.2.4 → 1.2.6

package/dist/index.js

@@ -1,75 +1,17 @@
 #!/usr/bin/env node
-import { n as transformSpecifiers, r as typescriptExtensions, t as toImportSpecifier } from "./ast-BS3xj9uY.js";
+import { t as exists } from "./fs-CigSthjp.js";
+import { i as initConfig, n as createOrLoadConfig } from "./config-DH5Ggyir.js";
+import "./ast-BRNdmLn5.js";
+import { n as LocalRegistryClient, t as HttpRegistryClient } from "./client-YTcWP1iz.js";
+import { t as ComponentInstaller } from "./installer-DQzu7o9x.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Command } from "commander";
 import picocolors from "picocolors";
-import { z } from "zod";
 import { x } from "tinyexec";
 import { autocompleteMultiselect, box, cancel, confirm, group, intro, isCancel, log, outro, select, spinner } from "@clack/prompts";
-import { parse } from "oxc-parser";
-import { detect } from "package-manager-detector";
-import MagicString from "magic-string";
-
-//#region src/utils/fs.ts
-async function exists(pathLike) {
-	try {
-		await fs.access(pathLike);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-//#region src/utils/is-src.ts
-async function isSrc() {
-	return exists("./src");
-}
-
-//#endregion
-//#region src/config.ts
-function createConfigSchema(isSrc) {
-	const defaultAliases = {
-		uiDir: "./components/ui",
-		componentsDir: "./components",
-		blockDir: "./components",
-		cssDir: "./styles",
-		libDir: "./lib"
-	};
-	return z.object({
-		$schema: z.string().default(isSrc ? "node_modules/@fumadocs/cli/dist/schema/src.json" : "node_modules/@fumadocs/cli/dist/schema/default.json").optional(),
-		aliases: z.object({
-			uiDir: z.string().default(defaultAliases.uiDir),
-			componentsDir: z.string().default(defaultAliases.uiDir),
-			blockDir: z.string().default(defaultAliases.blockDir),
-			cssDir: z.string().default(defaultAliases.componentsDir),
-			libDir: z.string().default(defaultAliases.libDir)
-		}).default(defaultAliases),
-		baseDir: z.string().default(isSrc ? "src" : ""),
-		uiLibrary: z.enum(["radix-ui", "base-ui"]).default("radix-ui"),
-		commands: z.object({ format: z.string().optional() }).default({})
-	});
-}
-async function createOrLoadConfig(file = "./cli.json") {
-	const inited = await initConfig(file);
-	if (inited) return inited;
-	const content = (await fs.readFile(file)).toString();
-	return createConfigSchema(await isSrc()).parse(JSON.parse(content));
-}
-/**
-* Write new config, skip if a config already exists
-*
-* @returns the created config, `undefined` if not created
-*/
-async function initConfig(file = "./cli.json", src) {
-	if (await fs.stat(file).then(() => true).catch(() => false)) return;
-	const defaultConfig = createConfigSchema(src ?? await isSrc()).parse({});
-	await fs.writeFile(file, JSON.stringify(defaultConfig, null, 2));
-	return defaultConfig;
-}
-
-//#endregion
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
 //#region src/commands/file-tree.ts
 const scanned = [
 	"file",
@@ -104,7 +46,6 @@ function treeToJavaScript(input, noRoot, importName = "fumadocs-ui/components/fi
 
 export default (${treeToMdx(input, noRoot)})`;
 }
-
 //#endregion
 //#region src/utils/file-tree/run-tree.ts
 async function runTree(args) {
@@ -120,336 +61,15 @@ async function runTree(args) {
 		throw new Error("failed to run `tree` command", { cause: e });
 	}
 }
-
 //#endregion
 //#region package.json
-var version = "1.2.4";
-
-//#endregion
-//#region src/registry/schema.ts
-const namespaces = [
-	"components",
-	"lib",
-	"css",
-	"route",
-	"ui",
-	"block"
-];
-const indexSchema = z.object({
-	name: z.string(),
-	title: z.string().optional(),
-	description: z.string().optional()
-});
-const fileSchema = z.object({
-	type: z.literal(namespaces),
-	path: z.string(),
-	target: z.string().optional(),
-	content: z.string()
-});
-const httpSubComponent = z.object({
-	type: z.literal("http"),
-	baseUrl: z.string(),
-	component: z.string()
-});
-const componentSchema = z.object({
-	name: z.string(),
-	title: z.string().optional(),
-	description: z.string().optional(),
-	files: z.array(fileSchema),
-	dependencies: z.record(z.string(), z.string().or(z.null())),
-	devDependencies: z.record(z.string(), z.string().or(z.null())),
-	subComponents: z.array(z.string().or(httpSubComponent)).default([])
-});
-const registryInfoSchema = z.object({
-	variables: z.record(z.string(), z.object({
-		description: z.string().optional(),
-		default: z.unknown().optional()
-	})).optional(),
-	env: z.record(z.string(), z.unknown()).optional(),
-	indexes: z.array(indexSchema).default([]),
-	registries: z.array(z.string()).optional()
-});
-
-//#endregion
-//#region src/utils/cache.ts
-/**
-* cache for async resources, finished promises will be resolved into original value, otherwise wrapped with a promise.
-*/
-function createCache(store = /* @__PURE__ */ new Map()) {
-	return {
-		cached(key, fn) {
-			let cached = store.get(key);
-			if (cached) return cached;
-			cached = fn((v) => store.set(key, v));
-			if (cached instanceof Promise) cached = cached.then((out) => {
-				if (store.has(key)) store.set(key, out);
-				return out;
-			});
-			store.set(key, cached);
-			return cached;
-		},
-		invalidate(key) {
-			store.delete(key);
-		},
-		$value() {
-			return this;
-		}
-	};
-}
-
-//#endregion
-//#region src/registry/client.ts
-const fetchCache = createCache();
-var HttpRegistryClient = class HttpRegistryClient {
-	constructor(baseUrl, config) {
-		this.baseUrl = baseUrl;
-		this.config = config;
-		this.registryId = baseUrl;
-	}
-	async fetchRegistryInfo(baseUrl = this.baseUrl) {
-		const url = new URL("_registry.json", `${baseUrl}/`);
-		return fetchCache.$value().cached(url.href, async () => {
-			const res = await fetch(url);
-			if (!res.ok) throw new Error(`failed to fetch ${url.href}: ${res.statusText}`);
-			return registryInfoSchema.parse(await res.json());
-		});
-	}
-	async fetchComponent(name) {
-		const url = new URL(`${name}.json`, `${this.baseUrl}/`);
-		return fetchCache.$value().cached(url.href, async () => {
-			const res = await fetch(`${this.baseUrl}/${name}.json`);
-			if (!res.ok) {
-				if (res.status === 404) throw new Error(`component ${name} not found at ${url.href}`);
-				throw new Error(await res.text());
-			}
-			return componentSchema.parse(await res.json());
-		});
-	}
-	async hasComponent(name) {
-		const url = new URL(`${name}.json`, `${this.baseUrl}/`);
-		return (await fetch(url, { method: "HEAD" })).ok;
-	}
-	createLinkedRegistryClient(name) {
-		return new HttpRegistryClient(`${this.baseUrl}/${name}`, this.config);
-	}
-};
-var LocalRegistryClient = class LocalRegistryClient {
-	constructor(dir, config) {
-		this.dir = dir;
-		this.config = config;
-		this.registryId = dir;
-	}
-	async fetchRegistryInfo(dir = this.dir) {
-		if (this.registryInfo) return this.registryInfo;
-		const filePath = path.join(dir, "_registry.json");
-		const out = await fs.readFile(filePath).then((res) => JSON.parse(res.toString())).catch((e) => {
-			throw new Error(`failed to resolve local file "${filePath}"`, { cause: e });
-		});
-		return this.registryInfo = registryInfoSchema.parse(out);
-	}
-	async fetchComponent(name) {
-		const filePath = path.join(this.dir, `${name}.json`);
-		const out = await fs.readFile(filePath).then((res) => JSON.parse(res.toString())).catch((e) => {
-			throw new Error(`component ${name} not found at ${filePath}`, { cause: e });
-		});
-		return componentSchema.parse(out);
-	}
-	async hasComponent(name) {
-		const filePath = path.join(this.dir, `${name}.json`);
-		try {
-			await fs.stat(filePath);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	createLinkedRegistryClient(name) {
-		return new LocalRegistryClient(path.join(this.dir, name), this.config);
-	}
-};
-
-//#endregion
-//#region src/utils/get-package-manager.ts
-async function getPackageManager() {
-	return (await detect())?.name ?? "npm";
-}
-
-//#endregion
-//#region src/registry/installer/dep-manager.ts
-var DependencyManager = class {
-	constructor() {
-		this.installedDeps = /* @__PURE__ */ new Map();
-		this.dependencies = [];
-		this.devDependencies = [];
-		this.packageManager = "npm";
-	}
-	async init(deps, devDeps) {
-		this.installedDeps.clear();
-		if (await exists("package.json")) {
-			const content = await fs.readFile("package.json");
-			const parsed = JSON.parse(content.toString());
-			if ("dependencies" in parsed && typeof parsed.dependencies === "object") {
-				const records = parsed.dependencies;
-				for (const [k, v] of Object.entries(records)) this.installedDeps.set(k, v);
-			}
-			if ("devDependencies" in parsed && typeof parsed.devDependencies === "object") {
-				const records = parsed.devDependencies;
-				for (const [k, v] of Object.entries(records)) this.installedDeps.set(k, v);
-			}
-		}
-		this.dependencies = this.resolveRequiredDependencies(deps);
-		this.devDependencies = this.resolveRequiredDependencies(devDeps);
-		this.packageManager = await getPackageManager();
-	}
-	resolveRequiredDependencies(deps) {
-		return Object.entries(deps).filter(([k]) => !this.installedDeps.has(k)).map(([k, v]) => v === null || v.length === 0 ? k : `${k}@${v}`);
-	}
-	hasRequired() {
-		return this.dependencies.length > 0 || this.devDependencies.length > 0;
-	}
-	async installRequired() {
-		if (this.dependencies.length > 0) await x(this.packageManager, ["install", ...this.dependencies]);
-		if (this.devDependencies.length > 0) await x(this.packageManager, [
-			"install",
-			...this.devDependencies,
-			"-D"
-		]);
-	}
-};
-
-//#endregion
-//#region src/registry/installer/index.ts
-var ComponentInstaller = class {
-	constructor(rootClient, plugins = []) {
-		this.rootClient = rootClient;
-		this.plugins = plugins;
-		this.installedFiles = /* @__PURE__ */ new Set();
-		this.downloadCache = createCache();
-		this.dependencies = {};
-		this.devDependencies = {};
-		this.pathToFileCache = createCache();
-	}
-	async install(name, io) {
-		let downloaded;
-		const info = await this.rootClient.fetchRegistryInfo();
-		for (const registry of info.registries ?? []) if (name.startsWith(`${registry}/`)) {
-			downloaded = await this.download(name.slice(registry.length + 1), this.rootClient.createLinkedRegistryClient(registry));
-			break;
-		}
-		downloaded ??= await this.download(name, this.rootClient);
-		for (const item of downloaded) {
-			Object.assign(this.dependencies, item.dependencies);
-			Object.assign(this.devDependencies, item.devDependencies);
-		}
-		for (const comp of downloaded) for (const file of comp.files) {
-			const outPath = this.resolveOutputPath(file);
-			if (this.installedFiles.has(outPath)) continue;
-			this.installedFiles.add(outPath);
-			const output = typescriptExtensions.includes(path.extname(outPath)) ? await this.transform(io, name, file, comp, downloaded) : file.content;
-			const status = await fs.readFile(outPath).then((res) => {
-				if (res.toString() === output) return "ignore";
-				return "need-update";
-			}).catch(() => "write");
-			if (status === "ignore") continue;
-			if (status === "need-update") {
-				if (!await io.confirmFileOverride({ path: outPath })) continue;
-			}
-			await fs.mkdir(path.dirname(outPath), { recursive: true });
-			await fs.writeFile(outPath, output);
-			io.onFileDownloaded({
-				path: outPath,
-				file,
-				component: comp
-			});
-		}
-	}
-	async deps() {
-		const manager = new DependencyManager();
-		await manager.init(this.dependencies, this.devDependencies);
-		return manager;
-	}
-	async onEnd() {
-		const config = this.rootClient.config;
-		if (config.commands.format) await x(config.commands.format);
-	}
-	/**
-	* return a list of components, merged with child components & variables.
-	*/
-	async download(name, client, contextVariables) {
-		const hash = `${client.registryId} ${name}`;
-		const info = await client.fetchRegistryInfo();
-		const variables = {
-			...contextVariables,
-			...info.env
-		};
-		for (const [k, v] of Object.entries(info.variables ?? {})) variables[k] ??= v.default;
-		return (await this.downloadCache.cached(hash, async (presolve) => {
-			const comp = await client.fetchComponent(name);
-			const result = [comp];
-			presolve(result);
-			const child = await Promise.all(comp.subComponents.map((sub) => {
-				if (typeof sub === "string") return this.download(sub, client);
-				const baseUrl = this.rootClient instanceof HttpRegistryClient ? new URL(sub.baseUrl, `${this.rootClient.baseUrl}/`).href : sub.baseUrl;
-				return this.download(sub.component, new HttpRegistryClient(baseUrl, client.config), variables);
-			}));
-			for (const sub of child) result.push(...sub);
-			return result;
-		})).map((file) => ({
-			...file,
-			variables
-		}));
-	}
-	async transform(io, taskId, file, component, allComponents) {
-		const filePath = this.resolveOutputPath(file);
-		const parsed = await parse(filePath, file.content);
-		const s = new MagicString(file.content);
-		const prefix = "@/";
-		const variables = Object.entries(component.variables ?? {});
-		const pathToFile = await this.pathToFileCache.cached(taskId, () => {
-			const map = /* @__PURE__ */ new Map();
-			for (const comp of allComponents) for (const file of comp.files) map.set(file.target ?? file.path, file);
-			return map;
-		});
-		transformSpecifiers(parsed.program, s, (specifier) => {
-			for (const [k, v] of variables) specifier = specifier.replaceAll(`<${k}>`, v);
-			if (specifier.startsWith(prefix)) {
-				const lookup = specifier.substring(2);
-				const target = pathToFile.get(lookup);
-				if (target) specifier = toImportSpecifier(filePath, this.resolveOutputPath(target));
-				else io.onWarn(`cannot find the referenced file of ${specifier}`);
-			}
-			return specifier;
-		});
-		for (const plugin of this.plugins) await plugin.transformFile?.({
-			s,
-			parsed,
-			file,
-			component
-		});
-		return s.toString();
-	}
-	resolveOutputPath(file) {
-		const config = this.rootClient.config;
-		const dir = {
-			components: config.aliases.componentsDir,
-			block: config.aliases.blockDir,
-			ui: config.aliases.uiDir,
-			css: config.aliases.cssDir,
-			lib: config.aliases.libDir,
-			route: "./"
-		}[file.type];
-		if (file.target) return path.join(config.baseDir, file.target.replace("<dir>", dir));
-		return path.join(config.baseDir, dir, path.basename(file.path));
-	}
-};
-
+var version = "1.2.6";
 //#endregion
 //#region src/commands/shared.ts
 const UIRegistries = {
 	"base-ui": "fumadocs/base-ui",
 	"radix-ui": "fumadocs/radix-ui"
 };
-
 //#endregion
 //#region src/commands/add.ts
 async function add(input, client) {
@@ -537,7 +157,6 @@ async function install(target, installer) {
 	await installer.onEnd();
 	outro(picocolors.bold(picocolors.greenBright("Successful")));
 }
-
 //#endregion
 //#region src/commands/customise.ts
 async function customise(client) {
@@ -570,7 +189,7 @@ async function customise(client) {
 						label: "Start from minimal styles",
 						hint: "for those who want to build their own variant from ground up.",
 						value: {
-							target: ["fumadocs/ui/layouts/docs-min"],
+							target: ["layouts/docs-min"],
 							replace: [["fumadocs-ui/layouts/docs", "@/components/layout/docs"], ["fumadocs-ui/layouts/docs/page", "@/components/layout/docs/page"]]
 						}
 					},
@@ -618,7 +237,192 @@ function printNext(...maps) {
 		...maps.map(([from, to]) => picocolors.greenBright(`"${from}" -> "${to}"`))
 	].join("\n"));
 }
+//#endregion
+//#region src/commands/export-epub.ts
+const execAsync = promisify(exec);
+async function readPackageJson(cwd) {
+	try {
+		const raw = await fs.readFile(path.join(cwd, "package.json"), "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+/** Path of pre-rendered EPUB, choose one according to your React framework. Next.js fetches from the running server instead. */
+const EPUB_BUILD_PATHS = {
+	next: "",
+	"tanstack-start": ".output/public/export/epub",
+	"tanstack-start-spa": "dist/client/export/epub",
+	"react-router": "build/client/export/epub",
+	"react-router-spa": "build/client/export/epub",
+	waku: "dist/public/export/epub"
+};
+const API_ROUTE_TEMPLATE = `import { source } from '@/lib/source';
+import { exportEpub } from 'fumadocs-epub';
 
+export const revalidate = false;
+
+export async function GET(request: Request): Promise<Response> {
+  // Require EXPORT_SECRET to prevent unauthenticated abuse. Pass via Authorization: Bearer <secret>
+  const secret = process.env.EXPORT_SECRET;
+  if (!secret) {
+    return new Response('EXPORT_SECRET is not configured. Set it in your environment to protect this endpoint.', { status: 503 });
+  }
+  const authHeader = request.headers.get('authorization');
+  const token = authHeader?.replace(/^Bearer\\s+/i, '') ?? '';
+  if (token !== secret) {
+    return new Response('Unauthorized', { status: authHeader ? 403 : 401 });
+  }
+  const buffer = await exportEpub({
+    source,
+    title: 'Documentation',
+    author: 'Your Team',
+    description: 'Exported documentation',
+    cover: '/cover.png',
+  });
+  return new Response(new Uint8Array(buffer), {
+    headers: {
+      'Content-Type': 'application/epub+zip',
+      'Content-Disposition': 'attachment; filename="docs.epub"',
+    },
+  });
+}
+`;
+async function findAppDir(cwd) {
+	for (const appPath of ["app", "src/app"]) {
+		const fullPath = path.join(cwd, appPath);
+		if (await exists(fullPath)) return fullPath;
+	}
+	return null;
+}
+async function scaffoldEpubRoute(cwd) {
+	const appDir = await findAppDir(cwd);
+	if (!appDir) {
+		console.error(picocolors.red("Could not find app directory (app/ or src/app/)"));
+		return false;
+	}
+	const routePath = path.join(appDir, "export", "epub", "route.ts");
+	if (await exists(routePath)) {
+		console.log(picocolors.yellow("EPUB route already exists at"), routePath);
+		return true;
+	}
+	await fs.mkdir(path.dirname(routePath), { recursive: true });
+	await fs.writeFile(routePath, API_ROUTE_TEMPLATE);
+	console.log(picocolors.green("Created EPUB route at"), routePath);
+	return true;
+}
+async function exportEpub(options) {
+	const cwd = process.cwd();
+	const outputPath = path.resolve(cwd, options.output ?? "docs.epub");
+	const framework = options.framework;
+	const spin = spinner();
+	const buildPath = EPUB_BUILD_PATHS[framework];
+	if (!(framework in EPUB_BUILD_PATHS)) {
+		const valid = Object.keys(EPUB_BUILD_PATHS).join(", ");
+		console.error(picocolors.red(`Invalid --framework "${framework}". Must be one of: ${valid}`));
+		process.exit(1);
+	}
+	const pkg = await readPackageJson(cwd);
+	const hasNextConfig = await exists(path.join(cwd, "next.config.js")) || await exists(path.join(cwd, "next.config.ts")) || await exists(path.join(cwd, "next.config.mjs"));
+	const hasNextInPkg = !!(pkg ? {
+		...pkg.dependencies,
+		...pkg.devDependencies,
+		...pkg.peerDependencies
+	} : {})?.next;
+	const hasAppOrPages = await exists(path.join(cwd, "app")) || await exists(path.join(cwd, "pages")) || await exists(path.join(cwd, "src", "app")) || await exists(path.join(cwd, "src", "pages"));
+	if (!(hasNextConfig || hasNextInPkg && hasAppOrPages) && framework === "next") {
+		console.error(picocolors.red("Next.js project not found. Run this command from a Fumadocs Next.js project root."));
+		process.exit(1);
+	}
+	if (framework === "next") {
+		spin.start("Scaffolding EPUB route");
+		const scaffolded = await scaffoldEpubRoute(cwd);
+		spin.stop(scaffolded ? "EPUB route ready" : "Scaffolding failed");
+		if (!scaffolded) process.exit(1);
+	}
+	if (options.scaffoldOnly) {
+		console.log(picocolors.cyan("\nTo export:"));
+		console.log("  1. Add fumadocs-epub to your dependencies: pnpm add fumadocs-epub");
+		console.log("  2. Ensure includeProcessedMarkdown: true in your docs collection config");
+		if (framework === "next") {
+			console.log("  3. Set EXPORT_SECRET in your environment to protect the /export/epub endpoint");
+			console.log("  4. Run production build: pnpm build");
+			console.log("  5. Start the server (e.g. pnpm start) and keep it running");
+			console.log("  6. Run: fumadocs export epub --framework next");
+		} else {
+			console.log(`  3. Add a prerender route that outputs EPUB to ${buildPath}`);
+			console.log("  4. Run production build: pnpm build");
+			console.log(`  5. Run: fumadocs export epub --framework ${framework}`);
+		}
+		return;
+	}
+	if (!pkg) {
+		console.error(picocolors.red("Cannot read or parse package.json. Ensure it exists and is valid JSON."));
+		process.exit(1);
+	}
+	if (!{
+		...pkg.dependencies,
+		...pkg.devDependencies
+	}["fumadocs-epub"]) {
+		console.log(picocolors.yellow("\nInstalling fumadocs-epub..."));
+		const installCmd = `${process.env.npm_execpath?.includes("pnpm") ? "pnpm" : process.env.npm_execpath?.includes("bun") ? "bun" : "npm"} add fumadocs-epub`;
+		try {
+			await execAsync(installCmd, { cwd });
+		} catch (err) {
+			const stderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr) : "";
+			console.error(picocolors.red(`Failed to install fumadocs-epub. Command: ${installCmd}`));
+			if (stderr) console.error(stderr);
+			process.exit(1);
+		}
+	}
+	if (framework === "next") {
+		const secret = process.env.EXPORT_SECRET;
+		if (!secret) {
+			console.error(picocolors.red("EXPORT_SECRET is required for Next.js export. Set it in your environment."));
+			process.exit(1);
+		}
+		const port = process.env.PORT || "3000";
+		const url = `http://localhost:${port}/export/epub`;
+		spin.start("Fetching EPUB from server");
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 3e4);
+		try {
+			const res = await fetch(url, {
+				headers: { Authorization: `Bearer ${secret}` },
+				signal: controller.signal
+			});
+			if (!res.ok) {
+				if (res.status === 401 || res.status === 403) console.error(picocolors.red("Auth failed. Check that EXPORT_SECRET matches the value in your app."));
+				else console.error(picocolors.red(`Server returned ${res.status}. Ensure the app is running (e.g. pnpm start) on port ${port}.`));
+				process.exit(1);
+			}
+			const buffer = Buffer.from(await res.arrayBuffer());
+			await fs.mkdir(path.dirname(outputPath), { recursive: true });
+			await fs.writeFile(outputPath, buffer);
+			spin.stop(picocolors.green(`EPUB saved to ${outputPath}`));
+		} catch (err) {
+			if (err instanceof Error && err.name === "AbortError") console.error(picocolors.red("Request timed out after 30 seconds."));
+			else {
+				const msg = err instanceof Error ? err.message : String(err);
+				console.error(picocolors.red(`Could not fetch EPUB: ${msg}`));
+			}
+			console.error(picocolors.yellow(`Ensure the server is running (e.g. pnpm start) on port ${port}.`));
+			process.exit(1);
+		} finally {
+			clearTimeout(timeoutId);
+		}
+		return;
+	}
+	const fullBuildPath = path.join(cwd, buildPath);
+	if (!await exists(fullBuildPath)) {
+		console.error(picocolors.red(`EPUB not found at ${buildPath}. Run production build first (e.g. pnpm build).`));
+		process.exit(1);
+	}
+	spin.start("Copying EPUB");
+	await fs.mkdir(path.dirname(outputPath), { recursive: true });
+	await fs.copyFile(fullBuildPath, outputPath);
+	spin.stop(picocolors.green(`EPUB saved to ${outputPath}`));
+}
 //#endregion
 //#region src/index.ts
 const program = new Command().option("--config <string>");
@@ -636,6 +440,13 @@ const dirShortcuts = {
 program.command("add").description("add a new component to your docs").argument("[components...]", "components to download").option("--dir <string>", "the root url or directory to resolve registry").action(async (input, options) => {
 	await add(input, createClientFromDir(options.dir, await createOrLoadConfig(options.config)));
 });
+program.command("export").description("export documentation to various formats").command("epub").description("export documentation to EPUB format (run after production build)").requiredOption("--framework <name>", "React framework: next, tanstack-start, react-router, waku").option("--output <path>", "output file path", "docs.epub").option("--scaffold-only", "only scaffold the EPUB route, do not copy").action(async (options) => {
+	await exportEpub({
+		output: options.output,
+		framework: options.framework,
+		scaffoldOnly: options.scaffoldOnly
+	});
+});
 program.command("tree").argument("[json_or_args]", "JSON output of `tree` command or arguments for the `tree` command").argument("[output]", "output path of file").option("--js", "output as JavaScript file").option("--no-root", "remove the root node").option("--import-name <name>", "where to import components (JS only)").action(async (str, output, { js, root, importName }) => {
 	const jsExtensions = [
 		".js",
@@ -660,7 +471,7 @@ function createClientFromDir(dir = "https://fumadocs.dev/registry", config) {
 	return dir.startsWith("http://") || dir.startsWith("https://") ? new HttpRegistryClient(dir, config) : new LocalRegistryClient(dir, config);
 }
 program.parse();
-
 //#endregion
-export {  };
+export {};
+
 //# sourceMappingURL=index.js.map