@ubean/cli 0.1.2 → 0.1.4

package/dist/cli.js

@@ -0,0 +1,2272 @@
+import { S as createFsOps, a as scaffold, i as recoverScaffold, n as listScaffoldableFiles, r as pageCommand, t as deleteScaffold, v as renderTemplate } from "./page-Cmp7s9l2.js";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { extname, normalize } from "node:path";
+import { consola } from "consola";
+import { defineCommand, runMain } from "citty";
+import { readFile, rm, stat } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { buildProduction } from "@ubean/build/production";
+import { generateOpenApiTypesFromServer, generateTypes } from "@ubean/codegen";
+import { loadUbeanConfig, resolvePrerenderConfig } from "@ubean/config";
+import { prerender } from "@ubean/prerender";
+import { NODE_REQUIREMENTS, createCapabilitySet, diagnoseCapabilities, registerBuiltinPresets, resolvePresetByName } from "@ubean/preset";
+import { scanProject } from "@ubean/routing";
+import { basename, join as join$1, resolve as resolve$1 } from "pathe";
+import { createUbeanApp } from "@ubean/app";
+import { createDevRunner, createDevWatcher, logDiagnostics } from "@ubean/dev-server";
+import { bold, cyan, dim, green } from "kolorist";
+import { execSync, spawn } from "node:child_process";
+import { BUILTIN_MODULES, isBuiltinDisabled } from "@ubean/modules";
+import { createServer } from "node:http";
+import { findAvailablePort, waitForPort } from "@ubean/utils";
+//#region src/config.ts
+const logger$8 = consola.withTag("ubean-cli");
+const CONFIG_TEMPLATE = `import { defineConfig } from 'ubean';
+
+export default defineConfig({
+  srcDir: 'src',
+  preset: '{{preset}}'
+});
+`;
+const CONFIG_EXAMPLE_FULL = `import { defineConfig } from 'ubean';
+
+export default defineConfig({
+  // Source directory
+  srcDir: 'src',
+
+  // Preset: 'standard' | 'node' | 'cloudflare'
+  preset: 'standard',
+
+  // Dev server options
+  dev: {
+    port: 9527,
+    host: 'localhost',
+    open: false
+  },
+
+  // Build options
+  build: {
+    outDir: 'dist'
+  },
+
+  // View transitions
+  viewTransitions: {
+    enabled: true
+  },
+
+  // DevTools
+  devtools: {
+    enabled: true
+  }
+});
+`;
+async function findConfigFile(fs) {
+	for (const name of [
+		"ubean.config.ts",
+		"ubean.config.js",
+		"ubean.config.mjs",
+		"ubean.config.mts"
+	]) if (await fs.exists(name)) return name;
+	return null;
+}
+const configCommand = {
+	meta: {
+		name: "config",
+		description: "Manage ubean configuration"
+	},
+	subCommands: {
+		init: {
+			meta: {
+				name: "init",
+				description: "Create a default ubean.config.ts file"
+			},
+			args: {
+				preset: {
+					type: "string",
+					description: "Preset to use (standard, node, cloudflare)",
+					default: "standard"
+				},
+				force: {
+					type: "boolean",
+					description: "Overwrite existing config file",
+					default: false,
+					alias: "f"
+				},
+				dry: {
+					type: "boolean",
+					description: "Show what would be created",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const fs = createFsOps(process.cwd());
+				const preset = args.preset;
+				const existing = await findConfigFile(fs);
+				if (existing && !args.force) {
+					logger$8.warn(`Config file already exists: ${existing} (use --force to overwrite)`);
+					return;
+				}
+				const content = renderTemplate(CONFIG_TEMPLATE, { variables: { preset } });
+				if (args.dry) {
+					logger$8.success("[dry-run] Would create ubean.config.ts");
+					logger$8.log(`\n${content}`);
+					return;
+				}
+				await fs.writeFile("ubean.config.ts", content);
+				logger$8.success("Created ubean.config.ts");
+			}
+		},
+		show: {
+			meta: {
+				name: "show",
+				description: "Show current configuration file location and content"
+			},
+			async run() {
+				const fs = createFsOps(process.cwd());
+				const configFile = await findConfigFile(fs);
+				if (!configFile) {
+					logger$8.warn("No ubean config file found. Run `ubean config init` to create one.");
+					return;
+				}
+				logger$8.info(`Config file: ${configFile}`);
+				logger$8.log("");
+				const content = await fs.readFile(configFile);
+				logger$8.log(content);
+			}
+		},
+		example: {
+			meta: {
+				name: "example",
+				description: "Show a full example configuration with all options"
+			},
+			async run() {
+				logger$8.log(CONFIG_EXAMPLE_FULL);
+			}
+		},
+		path: {
+			meta: {
+				name: "path",
+				description: "Print resolved config file path"
+			},
+			async run() {
+				const fs = createFsOps(process.cwd());
+				const configFile = await findConfigFile(fs);
+				if (!configFile) {
+					logger$8.error("No config file found");
+					process.exit(1);
+				}
+				logger$8.log(fs.resolve(configFile));
+			}
+		}
+	}
+};
+//#endregion
+//#region src/build.ts
+const logger$7 = consola.withTag("ubean-cli");
+/**
+* Creates a fetcher that invokes the built SSR entry to render real HTML.
+* Inspired by void's Node prerender runner: import the built `entry.mjs`,
+* call its `createFetchHandler()` to obtain a `fetch(req)` function, then
+* drive it with synthetic `http://localhost<path>` requests.
+*
+* If the SSR entry cannot be loaded (e.g. missing dependencies), returns
+* `undefined` so the caller falls back to the existing placeholder behavior.
+*/
+async function createSsrFetcher(cwd, manifest) {
+	try {
+		const mod = await import(pathToFileURL(resolve$1(cwd, manifest.serverDir, "entry.mjs")).href);
+		const createFetchHandler = mod.default ?? mod.createFetchHandler;
+		if (typeof createFetchHandler !== "function") {
+			logger$7.warn("SSR entry does not export createFetchHandler; falling back to placeholder prerender.");
+			return;
+		}
+		const fetch = await createFetchHandler();
+		if (typeof fetch !== "function") {
+			logger$7.warn("SSR entry did not return a fetch handler; falling back to placeholder prerender.");
+			return;
+		}
+		return async (url) => {
+			const req = new Request(`http://localhost${url || "/"}`, { headers: { "x-ubean-prerender": "1" } });
+			const res = await fetch(req);
+			return {
+				html: typeof res.text === "function" ? await res.text() : String(res.body ?? ""),
+				statusCode: res.status ?? 200
+			};
+		};
+	} catch (err) {
+		logger$7.warn(`Failed to load SSR entry for prerender: ${err instanceof Error ? err.message : String(err)}. Falling back to placeholder prerender.`);
+		return;
+	}
+}
+const buildCommand = {
+	meta: {
+		name: "build",
+		description: "Build the ubean application for production"
+	},
+	args: {
+		preset: {
+			type: "string",
+			description: "Deployment preset (node, bun, deno, cloudflare, vercel, netlify, standard)"
+		},
+		mode: {
+			type: "string",
+			description: "App mode (fullstack, spa, ssg, backend). Overrides ubean.config.ts mode"
+		},
+		ssr: {
+			type: "boolean",
+			description: "Enable SSR in fullstack mode (only effective with --mode fullstack). Use --no-ssr to disable"
+		},
+		ssg: {
+			type: "boolean",
+			description: "Shortcut for --mode ssg",
+			default: false
+		},
+		minify: {
+			type: "boolean",
+			description: "Minify output",
+			default: true
+		},
+		sourcemap: {
+			type: "boolean",
+			description: "Generate sourcemaps",
+			default: false
+		},
+		prerender: {
+			type: "boolean",
+			description: "Pre-render static pages (SSG)"
+		},
+		cwd: {
+			type: "string",
+			description: "Project root directory",
+			default: "."
+		}
+	},
+	async run({ args }) {
+		const cwd = resolve$1(args.cwd || process.cwd());
+		logger$7.start("Building ubean application...");
+		try {
+			registerBuiltinPresets();
+			const config = await loadUbeanConfig(cwd);
+			if (args.ssg) config.mode = "ssg";
+			else if (args.mode) config.mode = args.mode;
+			if (config.mode === "fullstack" && args.ssr !== void 0) config.ssr = args.ssr;
+			if (config.mode === "ssg") {
+				if (!config.prerender.all && config.prerender.include.length === 0) config.prerender = resolvePrerenderConfig({ all: true });
+			} else if (config.mode === "spa" || config.mode === "backend") config.prerender = resolvePrerenderConfig();
+			else if (config.mode === "fullstack" && !config.ssr) config.prerender = resolvePrerenderConfig();
+			if (args.prerender === true) {
+				if (!config.prerender.enabled) config.prerender = resolvePrerenderConfig({ all: true });
+			} else if (args.prerender === false) config.prerender = resolvePrerenderConfig();
+			const preset = resolvePresetByName(args.preset || config.build.preset);
+			logger$7.info(`Using preset: ${preset.name}`);
+			logger$7.info(`App mode: ${config.mode}${config.mode === "fullstack" ? ` (ssr=${config.ssr})` : ""}`);
+			logger$7.info("Scanning project...");
+			const result = await scanProject({
+				cwd,
+				srcDir: config.srcDir,
+				dirs: config.dir,
+				ignore: config.scanOptions?.ignore
+			});
+			logger$7.info(`Found ${result.apiRoutes.length} API routes, ${result.pages.length} pages, ${result.layouts.length} layouts`);
+			logger$7.info("Generating types...");
+			await generateTypes(result, {
+				cwd,
+				srcDir: config.srcDir,
+				buildDir: ".ubean",
+				dirs: config.dir,
+				imports: config.imports,
+				components: config.components,
+				composablesDirs: config.imports.dirs,
+				componentsDirs: config.components.dirs
+			});
+			const resolvedPreset = preset;
+			if (resolvedPreset.hooks?.["build:before"]) await resolvedPreset.hooks["build:before"]({
+				cwd,
+				outputDir: config.build.outputDir,
+				preset: resolvedPreset,
+				config
+			});
+			logger$7.info("Building with Vite...");
+			const manifest = await buildProduction({
+				cwd,
+				config,
+				preset: resolvedPreset,
+				scanResult: result,
+				minify: args.minify,
+				sourcemap: args.sourcemap
+			});
+			if (config.prerender.enabled) {
+				logger$7.info("Prerendering static pages...");
+				const fetcher = await createSsrFetcher(cwd, manifest);
+				await prerender({
+					cwd,
+					outputDir: config.build.outputDir,
+					pages: result.pages,
+					prerender: config.prerender,
+					fetcher
+				});
+			}
+			if (config.mode === "ssg") {
+				const serverDir = join$1(cwd, config.build.outputDir, "server");
+				if (existsSync(serverDir)) {
+					logger$7.info("Cleaning temporary SSR bundle (SSG mode)...");
+					await rm(serverDir, {
+						recursive: true,
+						force: true
+					});
+				}
+			}
+			if (resolvedPreset.hooks?.["build:after"]) await resolvedPreset.hooks["build:after"]({
+				cwd,
+				outputDir: config.build.outputDir,
+				preset: resolvedPreset,
+				config,
+				manifest
+			});
+			logger$7.success(`Build complete for preset "${resolvedPreset.name}"!`);
+			logger$7.info(`  Output directory: ${resolve$1(cwd, config.build.outputDir)}`);
+			if (manifest.entry) logger$7.info(`  Server entry: ${manifest.entry}`);
+			logger$7.info(`  Client assets: ${manifest.assets.length} files`);
+		} catch (err) {
+			logger$7.error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		}
+		process.exit(0);
+	}
+};
+//#endregion
+//#region src/dev.ts
+const logger$6 = consola.withTag("ubean-cli");
+/**
+* Best-effort loader for the optional `@ubean/devtools` peer dependency.
+*
+* `getCustomTabs()` returns user-registered DevTools tabs (registered via
+* `defineDevToolsTab`). `@ubean/devtools` is an optional peer dep — when not
+* installed, fall back to an empty list. Future versions of `@ubean/devtools`
+* may expose `getCustomTabs` from its main entry; we try dynamic import on
+* startup and replace the placeholder if the export is available.
+*/
+let _customTabsGetter = () => [];
+import("@ubean/devtools").then((mod) => {
+	if (mod && typeof mod.getCustomTabs === "function") _customTabsGetter = mod.getCustomTabs;
+}).catch(() => {});
+function getCustomTabs() {
+	return _customTabsGetter();
+}
+const devCommand = {
+	meta: {
+		name: "dev",
+		description: "Start the ubean development server"
+	},
+	args: {
+		port: {
+			type: "string",
+			description: "Port to listen on",
+			default: "9527"
+		},
+		host: {
+			type: "string",
+			description: "Host to listen on",
+			default: "localhost"
+		},
+		strictPort: {
+			type: "boolean",
+			description: "Exit if the port is already in use, instead of auto-incrementing",
+			default: false
+		},
+		open: {
+			type: "boolean",
+			description: "Open browser on startup",
+			default: false
+		},
+		cwd: {
+			type: "string",
+			description: "Project root directory",
+			default: "."
+		}
+	},
+	async run({ args }) {
+		const cwd = resolve$1(args.cwd || process.cwd());
+		logger$6.start("Starting ubean dev server...");
+		registerBuiltinPresets();
+		const config = await loadUbeanConfig(cwd);
+		const port = Number(args.port) || config.dev.port;
+		const host = args.host || config.dev.host;
+		logger$6.info(`Root directory: ${config.rootDir}`);
+		logger$6.info(`Source directory: ${config.srcDir}`);
+		const preset = resolvePresetByName(config.build.preset);
+		logger$6.info(`Preset: ${preset.name}`);
+		const capabilities = createCapabilitySet(preset.capabilities || {});
+		logger$6.info("Running capability diagnostics...");
+		const diagnostics = diagnoseCapabilities(preset.name, preset.capabilities || {}, NODE_REQUIREMENTS);
+		logDiagnostics(diagnostics);
+		if (!diagnostics.valid) logger$6.warn("Some capability requirements are not met. Dev server may not function correctly.");
+		let { app: currentApp, layouts: currentLayouts, scanResult: currentScanResult } = await buildApp(cwd, config);
+		let rescanInProgress = false;
+		async function rescan() {
+			if (rescanInProgress) return;
+			rescanInProgress = true;
+			try {
+				const { app: newApp, layouts: newLayouts, scanResult } = await buildApp(cwd, config);
+				currentApp = newApp;
+				currentLayouts = newLayouts;
+				currentScanResult = scanResult;
+				runner.updateApp(currentApp, currentLayouts);
+				await runner.reload();
+			} catch (err) {
+				logger$6.error(`Rescan failed: ${err instanceof Error ? err.message : String(err)}`);
+			} finally {
+				rescanInProgress = false;
+			}
+		}
+		const runner = await createDevRunner({
+			cwd,
+			srcDir: config.srcDir,
+			port,
+			host,
+			strictPort: args.strictPort,
+			preset,
+			config,
+			capabilities,
+			app: currentApp,
+			layouts: currentLayouts,
+			devtools: {
+				getScanResult: () => currentScanResult,
+				getConfigMeta: () => ({
+					preset: config.build.preset,
+					rootDir: config.rootDir,
+					srcDir: config.srcDir,
+					openAPI: {
+						enabled: true,
+						scalarPath: "/_scalar",
+						openAPIPath: "/_openapi.json"
+					},
+					dir: config.dir
+				}),
+				getCustomTabs: () => getCustomTabs(),
+				triggerRescan: () => rescan()
+			},
+			onListen({ url }) {
+				const label = (text) => dim(text);
+				const lines = [
+					`${green(bold("🚀 ubean dev server ready"))}\n`,
+					`  → ${label("Local:")}      ${cyan(url)}`,
+					`  → ${label("Scalar UI:")}  ${cyan(`${url}/_scalar`)}`,
+					`  → ${label("OpenAPI:")}    ${cyan(`${url}/_openapi.json`)}`
+				];
+				if (config.devtools.enabled) lines.push(`  → ${label("DevTools:")}   ${cyan(`${url}${config.devtools.route}`)}`);
+				lines.push(`  → ${dim("Press Ctrl+C to stop")}`);
+				logger$6.box(lines.join("\n"));
+				generateOpenApiTypesFromServer(url, { outDir: resolve$1(cwd, ".ubean") }).then((filePath) => {
+					logger$6.success(`OpenAPI types generated: ${filePath}`);
+				}).catch((err) => {
+					logger$6.warn(`Failed to generate OpenAPI types: ${err instanceof Error ? err.message : String(err)}`);
+				});
+			},
+			onBeforeReload() {
+				logger$6.info("Reloading...");
+			},
+			onAfterReload() {
+				logger$6.success("Reloaded");
+			}
+		});
+		try {
+			await runner.start();
+		} catch (err) {
+			logger$6.error(err?.message || String(err));
+			process.exit(1);
+		}
+		const watcher = createDevWatcher({
+			cwd,
+			dirs: [
+				"api",
+				"pages",
+				"middleware",
+				"layouts",
+				"plugins",
+				"app",
+				"routes"
+			].map((d) => `${config.srcDir}/${d}`),
+			ignore: [
+				"**/node_modules/**",
+				"**/.git/**",
+				"**/.ubean/**"
+			],
+			debounceMs: 150,
+			async onChange(events) {
+				const relevantEvents = events.filter((e) => /\.(ts|js|vue|mjs|cjs|json)$/.test(e.relativePath) && !e.relativePath.includes(".bak"));
+				if (relevantEvents.length === 0) return;
+				logger$6.info(`File change detected: ${relevantEvents[0].relativePath}`);
+				await rescan();
+			}
+		});
+		watcher.start();
+		const cleanup = async () => {
+			logger$6.info("\nShutting down...");
+			watcher.stop();
+			await runner.stop();
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+	}
+};
+async function buildApp(cwd, config) {
+	logger$6.info("Scanning project files...");
+	const result = await scanProject({
+		cwd,
+		srcDir: config.srcDir,
+		dirs: config.dir,
+		ignore: config.scanOptions?.ignore
+	});
+	logger$6.info(`Found ${result.apiRoutes.length} API routes, ${result.pages.length} pages, ${result.layouts.length} layouts, ${result.middlewares.length} middlewares, ${result.plugins.length} plugins`);
+	logger$6.info("Generating type definitions...");
+	await generateTypes(result, {
+		cwd,
+		srcDir: config.srcDir,
+		buildDir: ".ubean",
+		dirs: config.dir,
+		imports: config.imports,
+		components: config.components,
+		composablesDirs: config.imports.dirs,
+		componentsDirs: config.components.dirs
+	});
+	const app = createUbeanApp({
+		rootDir: cwd,
+		routes: result.apiRoutes,
+		middleware: result.middlewares,
+		pages: result.pages,
+		crons: result.crons,
+		routeRules: config.routeRules || {},
+		publicDir: config.dir.public,
+		openAPI: {
+			title: "UBEAN Dev API",
+			scalarPath: "/_scalar",
+			openAPIPath: "/_openapi.json"
+		},
+		i18nConfig: config.i18n
+	});
+	app.hooks.hook("request:start", (c) => {
+		logger$6.log(`${c.req.method} ${c.req.path}`);
+	});
+	return {
+		app,
+		layouts: result.layouts,
+		scanResult: result
+	};
+}
+//#endregion
+//#region src/devtools.ts
+const logger$5 = consola.withTag("ubean-cli");
+const devtoolsCommand = {
+	meta: {
+		name: "devtools",
+		description: "Manage DevTools configuration and information"
+	},
+	subCommands: {
+		info: {
+			meta: {
+				name: "info",
+				description: "Show DevTools information"
+			},
+			async run() {
+				logger$5.info("DevTools Information");
+				logger$5.log("");
+				logger$5.log("  DevTools is built into ubean and available in dev mode.");
+				logger$5.log("");
+				logger$5.log("  Access:");
+				logger$5.log("    - Start dev server: pnpm dev");
+				logger$5.log("    - Open DevTools: Press Shift+Alt+D in the browser, or visit /__ubean/devtools/");
+				logger$5.log("");
+				logger$5.log("  Configuration (ubean.config.ts):");
+				logger$5.log("    devtools: {");
+				logger$5.log("      enabled: true,     // Enable/disable DevTools (dev only)");
+				logger$5.log("    }");
+				logger$5.log("");
+				logger$5.log("  Features:");
+				logger$5.log("    - Routes: View all registered routes and their handlers");
+				logger$5.log("    - Pages: Inspect page components and layouts");
+				logger$5.log("    - APIs: Browse API routes with OpenAPI integration");
+				logger$5.log("    - Middleware: View registered middleware");
+				logger$5.log("    - Crons: See scheduled tasks and their status");
+				logger$5.log("    - Config: View resolved configuration");
+				logger$5.log("    - Plugins: Browse installed plugins and their tabs");
+				logger$5.log("    - CRUD: Create/delete pages, APIs, layouts, middleware, crons");
+			}
+		},
+		path: {
+			meta: {
+				name: "path",
+				description: "Print the DevTools URL path"
+			},
+			args: { port: {
+				type: "string",
+				description: "Dev server port",
+				default: "9527"
+			} },
+			async run({ args }) {
+				const port = args.port;
+				logger$5.log(`http://localhost:${port}/__ubean/devtools/`);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/env.ts
+const logger$4 = consola.withTag("ubean-cli");
+function parseEnvContent(content) {
+	const vars = [];
+	const lines = content.split("\n");
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = trimmed.slice(0, eqIndex).trim();
+		let value = trimmed.slice(eqIndex + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		const isPublic = key.startsWith("UBEAN_PUBLIC_") || key.startsWith("VITE_") || key.startsWith("PUBLIC_");
+		vars.push({
+			key,
+			value,
+			public: isPublic
+		});
+	}
+	return vars;
+}
+function serializeEnvVars(vars) {
+	return `${vars.map((v) => `${v.key}=${v.value}`).join("\n")}\n`;
+}
+async function readEnvFile(fs, file) {
+	try {
+		return parseEnvContent(await fs.readFile(file));
+	} catch {
+		return [];
+	}
+}
+async function writeEnvFile(fs, file, vars, dry = false) {
+	if (dry) return true;
+	const content = serializeEnvVars(vars);
+	await fs.writeFile(file, content);
+	return true;
+}
+const envCommand = {
+	meta: {
+		name: "env",
+		description: "Manage environment variables"
+	},
+	subCommands: {
+		add: {
+			meta: {
+				name: "add",
+				description: "Add or update an environment variable"
+			},
+			args: {
+				key: {
+					type: "positional",
+					description: "Variable name (e.g., DATABASE_URL, UBEAN_PUBLIC_API_URL)"
+				},
+				value: {
+					type: "positional",
+					description: "Variable value"
+				},
+				file: {
+					type: "string",
+					description: "Environment file",
+					default: ".env"
+				},
+				public: {
+					type: "boolean",
+					description: "Mark as public (prefix with UBEAN_PUBLIC_)",
+					default: false
+				},
+				force: {
+					type: "boolean",
+					description: "Overwrite existing variable without confirmation",
+					default: false,
+					alias: "f"
+				},
+				dry: {
+					type: "boolean",
+					description: "Show what would be changed",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const fs = createFsOps(process.cwd());
+				const file = args.file;
+				let key = args.key;
+				const value = args.value;
+				if (args.public && !key.startsWith("UBEAN_PUBLIC_") && !key.startsWith("VITE_") && !key.startsWith("PUBLIC_")) key = `UBEAN_PUBLIC_${key}`;
+				const vars = await readEnvFile(fs, file);
+				const existing = vars.find((v) => v.key === key);
+				if (existing && !args.force) {
+					logger$4.warn(`Variable ${key} already exists in ${file} (use --force to overwrite)`);
+					logger$4.info(`  Current value: ${existing.value}`);
+					return;
+				}
+				if (existing) existing.value = value;
+				else vars.push({
+					key,
+					value,
+					public: key.startsWith("UBEAN_PUBLIC_") || key.startsWith("VITE_")
+				});
+				await writeEnvFile(fs, file, vars, args.dry);
+				if (args.dry) logger$4.success(`[dry-run] Would ${existing ? "update" : "add"} ${key}=${value} in ${file}`);
+				else logger$4.success(`${existing ? "Updated" : "Added"} ${key} in ${file}`);
+				if (key.startsWith("UBEAN_PUBLIC_") || key.startsWith("VITE_") || key.startsWith("PUBLIC_")) logger$4.info(`  Note: ${key} is exposed to client-side code`);
+			}
+		},
+		remove: {
+			meta: {
+				name: "remove",
+				description: "Remove an environment variable"
+			},
+			args: {
+				key: {
+					type: "positional",
+					description: "Variable name to remove"
+				},
+				file: {
+					type: "string",
+					description: "Environment file",
+					default: ".env"
+				},
+				dry: {
+					type: "boolean",
+					description: "Show what would be removed",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const fs = createFsOps(process.cwd());
+				const file = args.file;
+				const key = args.key;
+				const vars = await readEnvFile(fs, file);
+				const index = vars.findIndex((v) => v.key === key);
+				if (index === -1) {
+					logger$4.warn(`Variable ${key} not found in ${file}`);
+					return;
+				}
+				vars.splice(index, 1);
+				if (args.dry) logger$4.success(`[dry-run] Would remove ${key} from ${file}`);
+				else {
+					await writeEnvFile(fs, file, vars);
+					logger$4.success(`Removed ${key} from ${file}`);
+				}
+			}
+		},
+		list: {
+			meta: {
+				name: "list",
+				description: "List environment variables"
+			},
+			args: {
+				file: {
+					type: "string",
+					description: "Environment file",
+					default: ".env"
+				},
+				public: {
+					type: "boolean",
+					description: "Show only public variables",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const fs = createFsOps(process.cwd());
+				const file = args.file;
+				if (!await fs.exists(file)) {
+					logger$4.info(`${file} does not exist`);
+					return;
+				}
+				const vars = await readEnvFile(fs, file);
+				const filtered = args.public ? vars.filter((v) => v.public) : vars;
+				if (filtered.length === 0) {
+					logger$4.info(`No variables found in ${file}${args.public ? " (public only)" : ""}`);
+					return;
+				}
+				logger$4.info(`Variables in ${file} (${filtered.length}):`);
+				for (const v of filtered) {
+					const suffix = v.public ? " [public]" : "";
+					logger$4.log(`  ${v.key}=${v.value}${suffix}`);
+				}
+				const publicCount = vars.filter((v) => v.public).length;
+				const privateCount = vars.length - publicCount;
+				logger$4.info(`\n  ${publicCount} public, ${privateCount} private`);
+			}
+		},
+		init: {
+			meta: {
+				name: "init",
+				description: "Create .env and .env.example files from template"
+			},
+			args: {
+				force: {
+					type: "boolean",
+					description: "Overwrite existing files",
+					default: false,
+					alias: "f"
+				},
+				dry: {
+					type: "boolean",
+					description: "Show what would be created",
+					default: false
+				}
+			},
+			async run({ args }) {
+				const fs = createFsOps(process.cwd());
+				for (const [file, content] of [[".env", `# ubean environment variables
+# Server-only variables (never exposed to client)
+DATABASE_URL=
+SESSION_SECRET=
+
+# Public variables (exposed to client - prefix with UBEAN_PUBLIC_)
+# UBEAN_PUBLIC_API_URL=/api
+`], [".env.example", `# Example environment variables
+DATABASE_URL=your-database-url
+SESSION_SECRET=your-session-secret
+# UBEAN_PUBLIC_API_URL=/api
+`]]) {
+					if (await fs.exists(file) && !args.force) {
+						logger$4.warn(`Skipping ${file} (already exists, use --force to overwrite)`);
+						continue;
+					}
+					if (args.dry) logger$4.success(`[dry-run] Would create ${file}`);
+					else {
+						await fs.writeFile(file, content);
+						logger$4.success(`Created ${file}`);
+					}
+				}
+				logger$4.info("\nTip: Add .env to .gitignore (but commit .env.example)");
+			}
+		}
+	}
+};
+//#endregion
+//#region src/init.ts
+const logger$3 = consola.withTag("ubean-cli");
+const TEMPLATES = [
+	{
+		value: "minimal",
+		label: "Minimal (just a hello world page)"
+	},
+	{
+		value: "starter",
+		label: "Starter (recommended, includes pages/api/layouts)"
+	},
+	{
+		value: "blog",
+		label: "Blog (markdown-based blog structure)"
+	}
+];
+const PRESETS = [
+	{
+		value: "standard",
+		label: "Standard (Node.js/Bun compatible)"
+	},
+	{
+		value: "node",
+		label: "Node.js"
+	},
+	{
+		value: "cloudflare",
+		label: "Cloudflare Workers"
+	}
+];
+const PACKAGE_MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+async function prompt(question, defaultValue) {
+	const rl = (await import("node:readline")).createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolvePromise) => {
+		const suffix = defaultValue ? ` (${defaultValue})` : "";
+		rl.question(`${question}${suffix}: `, (answer) => {
+			rl.close();
+			resolvePromise(answer.trim() || defaultValue || "");
+		});
+	});
+}
+async function select(question, options, defaultValue) {
+	const rl = (await import("node:readline")).createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	console.log(`\n${question}`);
+	options.forEach((opt, i) => {
+		const marker = opt.value === defaultValue ? " (default)" : "";
+		console.log(`  ${i + 1}. ${opt.label}${marker} [${opt.value}]`);
+	});
+	return new Promise((resolvePromise) => {
+		rl.question("> ", (answer) => {
+			rl.close();
+			const idx = parseInt(answer, 10) - 1;
+			if (!answer.trim() && defaultValue) resolvePromise(defaultValue);
+			else if (idx >= 0 && idx < options.length) resolvePromise(options[idx].value);
+			else {
+				const found = options.find((o) => o.value === answer.trim());
+				resolvePromise(found ? found.value : defaultValue || options[0].value);
+			}
+		});
+	});
+}
+async function confirm(question, defaultValue = true) {
+	const rl = (await import("node:readline")).createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	const suffix = defaultValue ? " (Y/n)" : " (y/N)";
+	return new Promise((resolvePromise) => {
+		rl.question(`${question}${suffix}: `, (answer) => {
+			rl.close();
+			const a = answer.trim().toLowerCase();
+			if (!a) resolvePromise(defaultValue);
+			else resolvePromise(a === "y" || a === "yes");
+		});
+	});
+}
+function isNonInteractive() {
+	return !process.stdin.isTTY || process.env.CI !== void 0 || process.env.NONINTERACTIVE !== void 0;
+}
+const PACKAGE_JSON_TEMPLATE = `{
+  "name": "{{name}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "ubean dev",
+    "build": "ubean build",
+    "preview": "ubean preview",
+    "prepare": "ubean prepare",
+    "typecheck": "vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "ubean": "latest",
+    "vue": "^3.5.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "vue-tsc": "^2.1.0"
+  }
+}
+`;
+const TSCONFIG_TEMPLATE = `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "jsx": "preserve",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": ["ubean/client"]
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue", ".ubean/**/*.d.ts"],
+  "exclude": ["node_modules", "dist"]
+}
+`;
+const UBEAN_CONFIG_TEMPLATE = `import { defineConfig } from 'ubean';
+
+export default defineConfig({
+  srcDir: 'src',
+  preset: '{{preset}}'
+});
+`;
+const APP_VUE_TEMPLATE = `<template>
+  <div id="app">
+    <RouterView />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { RouterView } from 'vue-router';
+<\/script>
+
+<style>
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+}
+
+#app {
+  min-height: 100vh;
+}
+</style>
+`;
+const INDEX_PAGE_TEMPLATE = `<template>
+  <div class="home-page">
+    <h1>Welcome to ubean</h1>
+    <p>Your Vue meta framework is ready! 🚀</p>
+    <div class="links">
+      <RouterLink to="/about">About</RouterLink>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { RouterLink } from 'vue-router';
+
+definePage({
+  meta: {
+    title: 'Home'
+  }
+});
+<\/script>
+
+<style scoped>
+.home-page {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  padding: 2rem;
+  text-align: center;
+}
+
+h1 {
+  font-size: 3rem;
+  margin-bottom: 1rem;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+p {
+  color: #666;
+  font-size: 1.2rem;
+  margin-bottom: 2rem;
+}
+
+.links {
+  display: flex;
+  gap: 1rem;
+}
+
+a {
+  padding: 0.75rem 1.5rem;
+  border-radius: 8px;
+  background: #667eea;
+  color: white;
+  text-decoration: none;
+  font-weight: 500;
+  transition: all 0.2s;
+}
+
+a:hover {
+  background: #5a67d8;
+  transform: translateY(-1px);
+}
+</style>
+`;
+const ABOUT_PAGE_TEMPLATE = `<template>
+  <div class="about-page">
+    <h1>About</h1>
+    <p>This page is built with ubean.</p>
+    <RouterLink to="/">Back to Home</RouterLink>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { RouterLink } from 'vue-router';
+
+definePage({
+  meta: {
+    title: 'About'
+  }
+});
+<\/script>
+
+<style scoped>
+.about-page {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 3rem 2rem;
+}
+
+h1 {
+  margin-bottom: 1rem;
+  color: #333;
+}
+
+p {
+  color: #666;
+  line-height: 1.6;
+  margin-bottom: 2rem;
+}
+
+a {
+  color: #667eea;
+  text-decoration: none;
+}
+
+a:hover {
+  text-decoration: underline;
+}
+</style>
+`;
+const HELLO_API_TEMPLATE = `import { defineHandler } from 'ubean';
+
+export const GET = defineHandler(c => {
+  return c.json({
+    message: 'Hello from ubean API!',
+    timestamp: Date.now()
+  });
+});
+`;
+/**
+* 类型化请求客户端模板 - 浏览器端
+*
+* 启动 dev server 后,ubean 会自动生成 .ubean/openapi.d.ts(包含项目所有 API 的 paths 类型)。
+* 本文件将 paths 类型绑定到 createTypedClient,使浏览器端请求的路径、参数、请求体和返回值都获得类型安全。
+*
+* 使用方式:
+*   import { api } from '../request/client';
+*   const user = await api.get('/api/users/{id}', { params: { path: { id: 1 } } });
+*/
+const REQUEST_CLIENT_TEMPLATE = `import { createRequest } from '@soybeanjs/fetch';
+import { createTypedClient, toFlatTypedClient } from '@soybeanjs/fetch/openapi';
+import type { paths } from '../../.ubean/openapi';
+
+/**
+ * 底层 HTTP 请求实例(@soybeanjs/fetch 封装)。
+ *
+ * api 和 flatApi 共用同一份 RequestInstance,共享 baseURL/timeout/headers/state 等。
+ * 调整配置时只需修改此处一处。
+ */
+const request = createRequest({
+  // baseURL: '/api',  // 按需设置 API 基础路径
+  // timeout: 10000,
+});
+
+/**
+ * 浏览器端类型化 HTTP 客户端(抛异常模式)
+ *
+ * 路径、参数、请求体和返回值类型均从 OpenAPI schema 自动推断。
+ * 启动 dev server 后类型会自动更新(.ubean/openapi.d.ts)。
+ *
+ * 支持通过 responseType 配置不同的返回类型:
+ * - 'json' (默认): 返回解析后的 JSON 数据
+ * - 'blob': 返回 { file: Blob; filename: string; contentType: string }
+ * - 'text': 返回 string
+ * - 'arraybuffer': 返回 { file: ArrayBuffer; filename: string; contentType: string }
+ *
+ * @example
+ * import { api } from '../request/client';
+ *
+ * // JSON 请求(默认)
+ * const user = await api.get('/api/users/{id}', { pathParams: { id: 1 } });
+ *
+ * // 文件下载
+ * const file = await api.get('/api/export', { responseType: 'blob' });
+ * // file: { file: Blob; filename: string; contentType: string }
+ *
+ * // 文本
+ * const text = await api.get('/api/readme', { responseType: 'text' });
+ * // text: string
+ */
+export const api = createTypedClient<paths>(request);
+
+/**
+ * 扁平模式类型化 HTTP 客户端(不抛异常,通过返回值判断)
+ *
+ * toFlatTypedClient 接收同一个 RequestInstance,内部通过 withResponse + try/catch
+ * 实现扁平化返回,与 api 共享 state/cache/auth。
+ *
+ * 返回 { data, error, response } — 成功时 error 为 null,失败时 data 为 null。
+ * 接口与 api 一致,同样支持 responseType。
+ *
+ * @example
+ * import { flatApi } from '../request/client';
+ *
+ * const { data, error } = await flatApi.get('/api/users/{id}', {
+ *   pathParams: { id: 1 }
+ * });
+ * if (error) {
+ *   console.error('Failed:', error.message);
+ * } else {
+ *   console.log('User:', data);
+ * }
+ */
+export const flatApi = toFlatTypedClient<paths>(request);
+`;
+/**
+* 类型化请求客户端模板 - server 端内部调度
+*
+* 在 API 路由或 useData 的 fetcher 中使用,自动转发 cookie/authorization 等请求头。
+* 与 client.ts 接口一致,但内部通过 createInternalAdapter + @soybeanjs/fetch 发起请求(进程内调度)。
+*
+* 使用方式:
+*   import { createServerApi } from '../request/internal';
+*   export const GET = defineHandler(async (c) => {
+*     const api = createServerApi(c);
+*     const user = await api.get('/api/users/{id}', { pathParams: { id: 1 } });
+*     return c.json(user);
+*   });
+*/
+const REQUEST_INTERNAL_TEMPLATE = `import { createInternalAdapter } from 'ubean';
+import { createRequest } from '@soybeanjs/fetch';
+import { createTypedClient } from '@soybeanjs/fetch/openapi';
+import type { paths } from '../../.ubean/openapi';
+
+/**
+ * server 端类型化内部 fetch
+ *
+ * 在 API 路由或 useData 的 fetcher 中使用,自动转发 cookie/authorization 等请求头。
+ * 与 client.ts 的 api 接口一致,但通过进程内调度发起请求(不发起新的网络请求)。
+ *
+ * @example
+ * // src/routes/api/posts.ts
+ * import { defineHandler } from 'ubean';
+ * import { createServerApi } from '../request/internal';
+ *
+ * export const GET = defineHandler(async (c) => {
+ *   const api = createServerApi(c);
+ *   const user = await api.get('/api/users/{id}', { pathParams: { id: 1 } });
+ *   return c.json(user);
+ * });
+ *
+ * @example
+ * // 在 useData 中使用
+ * import { useData, defineHandler } from 'ubean';
+ * import { createServerApi } from '../request/internal';
+ *
+ * export const GET = defineHandler(async (c) => {
+ *   const api = createServerApi(c);
+ *   const result = await useData({
+ *     fetcher: async () => api.get('/api/users/{id}', { pathParams: { id: 1 } })
+ *   });
+ *   return c.json(result.data);
+ * });
+ */
+export function createServerApi(context: Parameters<typeof createInternalAdapter>[0]) {
+  const adapter = createInternalAdapter(context);
+  const request = createRequest(
+    { retry: { retries: 0 }, adapter },
+    { isBackendSuccess: () => true, transform: response => response.data }
+  );
+  return createTypedClient<paths>(request);
+}
+`;
+const DEFAULT_LAYOUT_TEMPLATE = `<template>
+  <slot />
+</template>
+
+<script setup lang="ts">
+<\/script>
+
+<style>
+body {
+  line-height: 1.5;
+}
+</style>
+`;
+const GITIGNORE_TEMPLATE = `node_modules
+dist
+.ubean
+.DS_Store
+*.log
+.env
+.env.local
+.env.*.local
+`;
+const FAVICON_SVG_TEMPLATE = `<svg width="100%" height="100%" version="1.1" viewBox="0 0 1000 1000" xmlns="http://www.w3.org/2000/svg"
+  xmlns:xlink="http://www.w3.org/1999/xlink">
+  <g>
+    <path
+      d="M 200,866 C 100,866 50,779.4 100,692.8 L 200,519.6 C 220,485 240,490 265,499.6 S 360,542.68 360,542.68 C 480.5,601 498,642.5 500,720 C 498,811 462,856 420,866"
+      fill="url(#LinearGradient)" fill-rule="nonzero" opacity="1" stroke="none" />
+    <path
+      d="M 420,866 C 455,861 478,846 500,827 C 614,696 615,597 500,517 C 394,444 333,374 380,207.82 L 260,415.67 C 240.22,450 254.37,465.1 275.28,481.79 S 360,542.68 360,542.68 C 480.5,601 498,642.5 500,720 C 498,811 462,856 420,866"
+      fill="url(#LinearGradient_2)" fill-rule="nonzero" opacity="1" stroke="none" />
+    <path d="M 500,517 C 394,444 333,374 380,207.82 L 400,173.2 C 367,295 421,350 603,428 C 572,440 524,474 500,517"
+      fill="url(#LinearGradient_3)" fill-rule="nonzero" opacity="1" stroke="none" />
+    <path d="M 500,827 L 660,660 C 738,589 710,482 603,428 C 572,440 524,474 500,517 C 615,597 614,696 500,827"
+      fill="url(#LinearGradient_4)" fill-rule="nonzero" opacity="1" stroke="none" />
+    <path d="M 400,173.2 C 367,295 421,350 603,428 C 690,389, 750,445 788,500 L 600,173.2 C 550,86.6 450,86.6 400,173.2"
+      fill="url(#LinearGradient_5)" fill-rule="nonzero" opacity="1" stroke="none" />
+    <path
+      d="M 500,827 L 660,660 C 738,589 710,482 603,428 C 690,389, 750,445 788,500 C 816,554 797,606 750,640 L 500,827"
+      fill="url(#LinearGradient_6)" fill-rule="nonzero" opacity="1" stroke="none" />
+    <path
+      d="M 788,500 C 816,554 797,606 750,640 L 500,827 C 497,851 513,862 540,866 L 800,866 C 900,866 950,779.4 900,692.8 L 788,500"
+      fill="url(#LinearGradient_7)" fill-rule="nonzero" opacity="1" stroke="none" />
+    <g transform="translate(140, 650) scale(0.18)">
+  <path d="M539.04,146.5c-77.37,32.74-126.47,114.53-123.22,198,.61,150.92,169.47,210.6,214.99,341.13,39.71,96.62-16.62,230.68-122.31,253.16-374.89-83.15-390.44-785.49,30.54-792.29ZM564.61,948.5c68.1-32.18,118.51-95.45,132.49-169.97,41.81-214.6-158.22-254.7-215.15-413.02-31.14-86.21,21.33-198.66,114.56-214.57,129.21,21.58,214.93,148.7,230.96,272.19,7.94,38.53,21.57,75.37,34.41,112.43,75.75,198.26-76.06,438.99-297.26,412.94Z" fill="#ffffff" fill-rule="evenodd"/>
+</g>
+  </g>
+  <defs>
+    <linearGradient gradientTransform="matrix(104.391 -73.3432 73.3432 104.391 277.441 710.122)"
+      gradientUnits="userSpaceOnUse" id="LinearGradient" x1="0" x2="1" y1="0" y2="0">
+      <stop offset="0" stop-color="#373ebf" />
+      <stop offset="1" stop-color="#5058e6" />
+    </linearGradient>
+    <linearGradient gradientTransform="matrix(-173.747 557.324 -557.324 -173.747 508.829 258.172)"
+      gradientUnits="userSpaceOnUse" id="LinearGradient_2" x1="0" x2="1" y1="0" y2="0">
+      <stop offset="0" stop-color="#c2d6ff" />
+      <stop offset="1" stop-color="#646cff" />
+    </linearGradient>
+    <linearGradient gradientTransform="matrix(157.951 295.666 -295.666 157.951 382.944 193.642)"
+      gradientUnits="userSpaceOnUse" id="LinearGradient_3" x1="0" x2="1" y1="0" y2="0">
+      <stop offset="0" stop-color="#5058e6" />
+      <stop offset="1" stop-color="#373ebf" />
+    </linearGradient>
+    <linearGradient gradientTransform="matrix(-44.3023 219.578 -219.578 -44.3023 619.69 469.652)"
+      gradientUnits="userSpaceOnUse" id="LinearGradient_4" x1="0" x2="1" y1="0" y2="0">
+      <stop offset="0" stop-color="#91a7ff" />
+      <stop offset="1" stop-color="#5058e6" />
+    </linearGradient>
+    <linearGradient gradientTransform="matrix(125.52 334.256 -334.256 125.52 539.723 235.139)"
+      gradientUnits="userSpaceOnUse" id="LinearGradient_5" x1="0" x2="1" y1="0" y2="0">
+      <stop offset="0" stop-color="#646cff" />
+      <stop offset="1" stop-color="#c2d6ff" />
+    </linearGradient>
+    <linearGradient gradientTransform="matrix(-241.23 357.206 -357.206 -241.23 754.054 449.312)"
+      gradientUnits="userSpaceOnUse" id="LinearGradient_6" x1="0" x2="1" y1="0" y2="0">
+      <stop offset="0" stop-color="#c2d6ff" />
+      <stop offset="1" stop-color="#646cff" />
+    </linearGradient>
+    <linearGradient gradientTransform="matrix(125.978 210.065 -210.065 125.978 596.433 613.665)"
+      gradientUnits="userSpaceOnUse" id="LinearGradient_7" x1="0" x2="1" y1="0" y2="0">
+      <stop offset="0" stop-color="#373ebf" />
+      <stop offset="1" stop-color="#5058e6" />
+    </linearGradient>
+  </defs>
+</svg>
+`;
+const README_TEMPLATE = `# {{name}}
+
+A Vue meta-framework project powered by ubean.
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+{{pm}} install
+
+# Start dev server
+{{pm}} dev
+
+# Build for production
+{{pm}} build
+
+# Preview production build
+{{pm}} preview
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+├── src/
+│   ├── pages/          # File-based routing
+│   ├── layouts/        # Layout components
+│   ├── routes/         # API routes
+│   ├── components/     # Vue components
+│   ├── composables/    # Auto-imported composables
+│   ├── plugins/        # App plugins
+│   ├── middleware/     # Request middleware
+│   ├── crons/          # Scheduled tasks
+│   ├── queues/         # Background jobs
+│   ├── request/        # Typed HTTP client & internal fetch
+│   └── app.vue         # Root app component
+├── public/             # Static assets
+└── ubean.config.ts     # ubean configuration
+\`\`\`
+`;
+const BLOG_INDEX_TEMPLATE = `<template>
+  <div class="blog-page">
+    <h1>Blog</h1>
+    <div class="posts">
+      <article v-for="post in posts" :key="post.slug" class="post-card">
+        <h2><RouterLink :to="'/blog/' + post.slug">{{ post.title }}</RouterLink></h2>
+        <p class="date">{{ post.date }}</p>
+        <p class="excerpt">{{ post.excerpt }}</p>
+      </article>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { RouterLink } from 'vue-router';
+import { useData } from 'ubean';
+
+definePage({
+  meta: {
+    title: 'Blog'
+  }
+});
+
+const { data: posts } = await useData('posts', () => {
+  return [
+    { slug: 'hello-world', title: 'Hello World', date: '2024-01-15', excerpt: 'Welcome to my blog!' }
+  ];
+});
+<\/script>
+
+<style scoped>
+.blog-page {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 3rem 2rem;
+}
+
+h1 {
+  margin-bottom: 2rem;
+}
+
+.posts {
+  display: flex;
+  flex-direction: column;
+  gap: 2rem;
+}
+
+.post-card {
+  padding: 1.5rem;
+  border-radius: 8px;
+  border: 1px solid #eee;
+}
+
+h2 {
+  font-size: 1.5rem;
+  margin-bottom: 0.5rem;
+}
+
+h2 a {
+  color: #333;
+  text-decoration: none;
+}
+
+h2 a:hover {
+  color: #667eea;
+}
+
+.date {
+  color: #999;
+  font-size: 0.9rem;
+  margin-bottom: 0.5rem;
+}
+
+.excerpt {
+  color: #666;
+}
+</style>
+`;
+const BLOG_POST_MD_TEMPLATE = `---
+title: Hello World
+date: 2024-01-15
+description: Welcome to my ubean blog!
+---
+
+# Hello World
+
+Welcome to my new blog built with **ubean**!
+
+This is a markdown blog post.
+
+## Features
+
+- File-based routing
+- Markdown support
+- Auto-imports
+- API routes
+- And much more!
+`;
+async function scaffoldProject(options) {
+	const targetDir = resolve$1(options.cwd, options.dir);
+	const fs = createFsOps(targetDir);
+	const projectName = options.name || (options.dir === "." ? basename(options.cwd) : basename(options.dir));
+	const pm = options.packageManager || "npm";
+	const nonInteractive = options.nonInteractive || isNonInteractive();
+	if (await fs.exists(".") && !options.force) {
+		if ((await fs.readDir(".").catch(() => [])).filter((f) => !f.startsWith(".") && f !== "node_modules").length > 0) {
+			if (nonInteractive) throw new Error(`Directory ${targetDir} is not empty. Use --force to overwrite.`);
+			if (!await confirm(`Directory ${targetDir} is not empty. Continue anyway?`, false)) {
+				console.log("Aborted.");
+				return;
+			}
+		}
+	}
+	await fs.ensureDir("src");
+	await fs.ensureDir("src/pages");
+	await fs.ensureDir("src/layouts");
+	await fs.ensureDir("src/routes");
+	await fs.ensureDir("src/components");
+	await fs.ensureDir("src/composables");
+	await fs.ensureDir("src/plugins");
+	await fs.ensureDir("src/request");
+	await fs.ensureDir("public");
+	await fs.writeFile("package.json", renderTemplate(PACKAGE_JSON_TEMPLATE, { variables: { name: projectName } }));
+	await fs.writeFile("public/favicon.svg", FAVICON_SVG_TEMPLATE);
+	await fs.writeFile("tsconfig.json", TSCONFIG_TEMPLATE);
+	await fs.writeFile("ubean.config.ts", renderTemplate(UBEAN_CONFIG_TEMPLATE, { variables: { preset: options.preset || "standard" } }));
+	await fs.writeFile(".gitignore", GITIGNORE_TEMPLATE);
+	await fs.writeFile("README.md", renderTemplate(README_TEMPLATE, { variables: {
+		name: projectName,
+		pm
+	} }));
+	await fs.writeFile("src/app.vue", APP_VUE_TEMPLATE);
+	await fs.writeFile("src/layouts/default.vue", DEFAULT_LAYOUT_TEMPLATE);
+	await fs.writeFile("src/request/client.ts", REQUEST_CLIENT_TEMPLATE);
+	await fs.writeFile("src/request/internal.ts", REQUEST_INTERNAL_TEMPLATE);
+	if (options.template === "minimal") await fs.writeFile("src/pages/index.vue", INDEX_PAGE_TEMPLATE);
+	else if (options.template === "blog") {
+		await fs.writeFile("src/pages/index.vue", INDEX_PAGE_TEMPLATE);
+		await fs.writeFile("src/pages/about.vue", ABOUT_PAGE_TEMPLATE);
+		await fs.ensureDir("src/pages/blog");
+		await fs.writeFile("src/pages/blog/index.vue", BLOG_INDEX_TEMPLATE);
+		await fs.writeFile("src/pages/blog/hello-world.md", BLOG_POST_MD_TEMPLATE);
+		await fs.writeFile("src/routes/hello.get.ts", HELLO_API_TEMPLATE);
+	} else {
+		await fs.writeFile("src/pages/index.vue", INDEX_PAGE_TEMPLATE);
+		await fs.writeFile("src/pages/about.vue", ABOUT_PAGE_TEMPLATE);
+		await fs.writeFile("src/routes/hello.get.ts", HELLO_API_TEMPLATE);
+	}
+	if (options.git) try {
+		const { execSync } = await import("node:child_process");
+		execSync("git init", {
+			cwd: targetDir,
+			stdio: "ignore"
+		});
+	} catch {}
+	console.log("\n✨ ubean project created successfully!\n");
+	console.log(`Project: ${projectName}`);
+	console.log(`Location: ${targetDir}`);
+	console.log(`Preset: ${options.preset || "standard"}`);
+	console.log(`Template: ${options.template || "starter"}`);
+	console.log("\nNext steps:");
+	if (options.dir !== ".") console.log(`  cd ${options.dir}`);
+	console.log(`  ${pm} install`);
+	console.log(`  ${pm} dev`);
+	console.log("");
+}
+const initCommand = {
+	meta: {
+		name: "init",
+		description: "Initialize a new ubean project"
+	},
+	args: {
+		dir: {
+			type: "positional",
+			description: "Directory to initialize",
+			default: "."
+		},
+		force: {
+			type: "boolean",
+			description: "Overwrite existing files",
+			default: false,
+			alias: "f"
+		},
+		name: {
+			type: "string",
+			description: "Project name"
+		},
+		template: {
+			type: "string",
+			description: "Project template (minimal/starter/blog)"
+		},
+		preset: {
+			type: "string",
+			description: "Target preset (standard/node/cloudflare)"
+		},
+		packageManager: {
+			type: "string",
+			description: "Package manager (npm/pnpm/yarn/bun)",
+			alias: "pm"
+		},
+		git: {
+			type: "boolean",
+			description: "Initialize git repository"
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip prompts and use defaults",
+			default: false,
+			alias: "y"
+		}
+	},
+	async run({ args, data }) {
+		const cwd = data?.cwd || process.cwd();
+		const nonInteractive = isNonInteractive() || args.yes;
+		let template = args.template;
+		let preset = args.preset;
+		let packageManager = args.packageManager;
+		let git = args.git;
+		let name = args.name;
+		logger$3.info("🚀 ubean project initializer");
+		if (!nonInteractive) {
+			name = name || await prompt("Project name", args.dir === "." ? basename(cwd) : args.dir);
+			template = template || await select("Select a template:", TEMPLATES, "starter");
+			preset = preset || await select("Select a preset:", PRESETS, "standard");
+			packageManager = packageManager || await prompt("Package manager (npm/pnpm/yarn/bun)", "npm");
+			if (git === void 0) git = await confirm("Initialize git repository?", true);
+		}
+		const options = {
+			cwd,
+			dir: args.dir,
+			force: args.force,
+			template: template || "starter",
+			preset: preset || "standard",
+			packageManager: packageManager || "npm",
+			git: git !== false,
+			name,
+			nonInteractive
+		};
+		if (!PACKAGE_MANAGERS.includes(options.packageManager)) options.packageManager = "npm";
+		await scaffoldProject(options);
+	}
+};
+//#endregion
+//#region src/prepare.ts
+const logger$2 = consola.withTag("ubean-cli");
+async function ensureBuildDir(cwd, buildDir) {
+	const fullPath = join$1(cwd, buildDir);
+	if (!existsSync(fullPath)) mkdirSync(fullPath, { recursive: true });
+}
+/**
+* Detects the package manager used in the project by inspecting lockfiles.
+* Priority: pnpm > yarn > bun > npm (npm as default fallback).
+*/
+function detectPackageManager(cwd) {
+	if (existsSync(join$1(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join$1(cwd, "yarn.lock"))) return "yarn";
+	if (existsSync(join$1(cwd, "bun.lockb")) || existsSync(join$1(cwd, "bun.lock"))) return "bun";
+	return "npm";
+}
+/**
+* Builds the install command args for a given package manager and package list.
+* Examples:
+*   pnpm → ['add', '@ubean/ui@^0.1.3']
+*   npm  → ['install', '@ubean/ui@^0.1.3']
+*/
+function buildInstallCommand(pm, packages) {
+	switch (pm) {
+		case "pnpm": return {
+			cmd: "pnpm",
+			args: ["add", ...packages]
+		};
+		case "yarn": return {
+			cmd: "yarn",
+			args: ["add", ...packages]
+		};
+		case "bun": return {
+			cmd: "bun",
+			args: ["add", ...packages]
+		};
+		default: return {
+			cmd: "npm",
+			args: ["install", ...packages]
+		};
+	}
+}
+/**
+* Extracts the bare package name from a module path.
+*   '@ubean/ui/vite'      → '@ubean/ui'
+*   '@ubean/electron/vite' → '@ubean/electron'
+*/
+function extractPackageName(modulePath) {
+	if (modulePath.startsWith("@")) return modulePath.split("/").slice(0, 2).join("/");
+	return modulePath.split("/")[0];
+}
+/**
+* Reads the `ubean` package version from the project's package.json so we can
+* install matching versions of `@ubean/*` extension packages.
+* Returns `null` if ubean isn't declared or version can't be parsed.
+*/
+function getUbeanVersion(cwd) {
+	try {
+		const pkgPath = join$1(cwd, "package.json");
+		if (!existsSync(pkgPath)) return null;
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		const spec = pkg.dependencies?.ubean || pkg.devDependencies?.ubean;
+		if (!spec) return null;
+		const match = spec.match(/\d+\.\d+\.\d+/);
+		return match ? match[0] : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Probes whether a module is importable (i.e., installed in node_modules).
+* Uses dynamic import — same mechanism as `loadBuiltinModule` so detection
+* behavior matches what the runtime will actually encounter.
+*/
+async function isModuleInstalled(modulePath) {
+	try {
+		await import(
+			/* @vite-ignore */
+			modulePath
+);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Detects built-in modules enabled in config but not installed, and
+* auto-installs them using the project's package manager.
+*
+* Behavior:
+* - When `autoInstall` is `false`, only prints warnings with install commands.
+* - When `autoInstall` is `true` and a package.json exists, runs the install.
+* - Version pinning: installs `@ubean/<pkg>@^<ubean-version>` to keep in sync.
+* - Failures fall back to warnings (non-fatal — prepare should still proceed).
+*/
+async function ensureBuiltinModules(cwd, config, autoInstall) {
+	const missing = [];
+	for (const builtin of BUILTIN_MODULES) {
+		const configValue = config[builtin.key];
+		if (isBuiltinDisabled(configValue)) continue;
+		const packageName = extractPackageName(builtin.modulePath);
+		if (!await isModuleInstalled(builtin.modulePath)) missing.push({
+			key: builtin.key,
+			packageName
+		});
+	}
+	if (missing.length === 0) return;
+	const pm = detectPackageManager(cwd);
+	const ubeanVersion = getUbeanVersion(cwd);
+	const packagesToInstall = missing.map((m) => ubeanVersion ? `${m.packageName}@^${ubeanVersion}` : m.packageName);
+	if (!autoInstall || !existsSync(join$1(cwd, "package.json"))) {
+		for (const m of missing) {
+			const versionSuffix = ubeanVersion ? `@^${ubeanVersion}` : "";
+			logger$2.warn(`Built-in module "${m.key}" is enabled but \`${m.packageName}\` is not installed. Run: ${pm} add ${m.packageName}${versionSuffix}`);
+		}
+		return;
+	}
+	logger$2.info(`Auto-installing missing built-in module packages: ${packagesToInstall.join(", ")}`);
+	logger$2.info(`Using package manager: ${pm}`);
+	const { cmd, args } = buildInstallCommand(pm, packagesToInstall);
+	try {
+		execSync([cmd, ...args].join(" "), {
+			cwd,
+			stdio: "inherit",
+			env: { ...process.env }
+		});
+		logger$2.success(`Installed: ${packagesToInstall.join(", ")}`);
+	} catch (err) {
+		logger$2.error(`Failed to auto-install packages: ${err instanceof Error ? err.message : String(err)}`);
+		for (const m of missing) {
+			const versionSuffix = ubeanVersion ? `@^${ubeanVersion}` : "";
+			logger$2.warn(`Please install manually: ${pm} add ${m.packageName}${versionSuffix}`);
+		}
+	}
+}
+const prepareCommand = {
+	meta: {
+		name: "prepare",
+		description: "Generate type definitions and prepare the project (runs automatically before dev/build)"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Project root directory",
+			default: "."
+		},
+		install: {
+			type: "boolean",
+			description: "Auto-install missing built-in module packages (use --no-install to skip)",
+			default: true
+		}
+	},
+	async run({ args }) {
+		const cwd = resolve$1(args.cwd || process.cwd());
+		logger$2.start(`Preparing ubean project at ${cwd}...`);
+		const config = await loadUbeanConfig(cwd);
+		await ensureBuiltinModules(cwd, config, args.install !== false);
+		const typesDir = ".ubean";
+		await ensureBuildDir(cwd, typesDir);
+		logger$2.info("Scanning project files...");
+		const result = await scanProject({
+			cwd,
+			srcDir: config.srcDir,
+			dirs: config.dir,
+			ignore: config.scanOptions?.ignore
+		});
+		logger$2.info(`Found ${result.apiRoutes.length} API routes, ${result.pages.length} pages, ${result.layouts.length} layouts, ${result.middlewares.length} middlewares`);
+		logger$2.info("Generating type definitions...");
+		const codegenResult = await generateTypes(result, {
+			cwd,
+			srcDir: config.srcDir,
+			buildDir: typesDir,
+			dirs: config.dir,
+			imports: config.imports,
+			components: config.components,
+			composablesDirs: config.imports.dirs,
+			componentsDirs: config.components.dirs
+		});
+		for (const file of codegenResult.generated) logger$2.success(`Generated ${file.replace(`${cwd}/`, "")}`);
+		logger$2.success("Prepare complete!");
+	}
+};
+//#endregion
+//#region src/preview.ts
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".wasm": "application/wasm",
+	".txt": "text/plain; charset=utf-8",
+	".map": "application/json; charset=utf-8"
+};
+/**
+* 启动静态文件服务器,用于 spa / ssg 模式预览。
+*
+* - ssg 模式:优先查找 `<path>/index.html` 或 `<path>.html`,找不到时返回 404
+* - spa 模式:所有非文件路由回退到 `index.html`(客户端路由接管)
+*
+* 使用 Node 内置 `http` + `fs`,避免引入 `sirv` 等依赖。
+*/
+function startStaticServer(opts) {
+	const { root, port, host, mode } = opts;
+	const spaFallback = mode === "spa";
+	return createServer(async (req, res) => {
+		try {
+			const url = new URL(req.url || "/", `http://${host}`);
+			let pathname = normalize(decodeURIComponent(url.pathname));
+			if (pathname.includes("..")) {
+				res.statusCode = 400;
+				res.end("Bad Request");
+				return;
+			}
+			let filePath = join$1(root, pathname);
+			let fileExists = existsSync(filePath) && (await stat(filePath)).isFile();
+			if (!fileExists && existsSync(filePath) && (await stat(filePath)).isDirectory()) {
+				const indexPath = join$1(filePath, "index.html");
+				if (existsSync(indexPath)) {
+					filePath = indexPath;
+					fileExists = true;
+				}
+			}
+			if (!fileExists && mode === "ssg") {
+				const indexPath = join$1(filePath, "index.html");
+				if (existsSync(indexPath) && (await stat(indexPath)).isFile()) {
+					filePath = indexPath;
+					fileExists = true;
+				}
+			}
+			if (!fileExists && mode === "ssg") {
+				const htmlPath = `${filePath}.html`;
+				if (existsSync(htmlPath) && (await stat(htmlPath)).isFile()) {
+					filePath = htmlPath;
+					fileExists = true;
+				}
+			}
+			if (!fileExists && spaFallback) {
+				const fallbackPath = join$1(root, "index.html");
+				if (existsSync(fallbackPath)) {
+					filePath = fallbackPath;
+					fileExists = true;
+				}
+			}
+			if (!fileExists) {
+				res.statusCode = 404;
+				res.setHeader("Content-Type", "text/plain; charset=utf-8");
+				res.end("Not Found");
+				return;
+			}
+			const ext = extname(filePath).toLowerCase();
+			const contentType = MIME_TYPES[ext] || "application/octet-stream";
+			const body = await readFile(filePath);
+			res.statusCode = 200;
+			res.setHeader("Content-Type", contentType);
+			res.setHeader("Content-Length", body.length);
+			res.end(body);
+		} catch (err) {
+			res.statusCode = 500;
+			res.setHeader("Content-Type", "text/plain; charset=utf-8");
+			res.end(err instanceof Error ? err.message : String(err));
+		}
+	}).listen(port, host);
+}
+const logger$1 = consola.withTag("ubean-cli");
+const previewCommand = {
+	meta: {
+		name: "preview",
+		description: "Preview the production build locally"
+	},
+	args: {
+		port: {
+			type: "string",
+			description: "Port to listen on"
+		},
+		host: {
+			type: "string",
+			description: "Host to listen on"
+		},
+		strictPort: {
+			type: "boolean",
+			description: "Exit if the port is already in use, instead of auto-incrementing",
+			default: false
+		},
+		cwd: {
+			type: "string",
+			description: "Project root directory",
+			default: "."
+		}
+	},
+	async run({ args }) {
+		const cwd = resolve$1(args.cwd || process.cwd());
+		logger$1.start("Starting ubean preview server...");
+		registerBuiltinPresets();
+		const config = await loadUbeanConfig(cwd);
+		const preset = resolvePresetByName(config.build.preset);
+		logger$1.info(`Preset: ${preset.name}`);
+		const outputDir = config.build.outputDir || "dist";
+		const mode = config.mode;
+		const host = args.host || config.preview.host;
+		const strictPort = args.strictPort ?? config.preview.strictPort;
+		const requestedPort = Number(args.port) || config.preview.port;
+		let actualPort;
+		try {
+			actualPort = await findAvailablePort(requestedPort, {
+				host,
+				strictPort
+			});
+		} catch (err) {
+			if (err?.code === "EADDRINUSE") logger$1.error(`Port ${requestedPort} is already in use${host ? ` on ${host}` : ""}. Try a different port or remove the --strictPort flag.`);
+			else logger$1.error(`Failed to resolve a port: ${err?.message || String(err)}`);
+			process.exit(1);
+		}
+		if (actualPort !== requestedPort) logger$1.warn(`Port ${requestedPort} is in use, trying ${actualPort} instead.`);
+		const label = (text) => dim(text);
+		const printBanner = (port, modeLabel) => {
+			const bannerUrl = `http://${host}:${port}`;
+			logger$1.box(`${green(bold("🚀 ubean preview server ready"))}\n\n  → ${label("Local:")}      ${cyan(bannerUrl)}\n  → ${label("Mode:")}       ${dim(modeLabel)}\n  → ${label("Preset:")}     ${cyan(preset.name)}\n  → ${dim("Press Ctrl+C to stop")}`);
+		};
+		if (mode === "spa" || mode === "ssg") {
+			const staticRoot = join$1(cwd, outputDir, "public");
+			if (!existsSync(staticRoot)) {
+				logger$1.error(`Build output not found: ${staticRoot}`);
+				logger$1.info("Run `ubean build` first to create a production build.");
+				process.exit(1);
+			}
+			const server = startStaticServer({
+				root: staticRoot,
+				port: actualPort,
+				host,
+				mode
+			});
+			printBanner(actualPort, `static (${mode})`);
+			const cleanup = () => {
+				server.close(() => process.exit(0));
+				setTimeout(() => process.exit(0), 1e3).unref();
+			};
+			process.on("SIGINT", cleanup);
+			process.on("SIGTERM", cleanup);
+			server.on("error", (err) => {
+				logger$1.error(`Preview server error: ${err.message || err}`);
+				process.exit(1);
+			});
+			return;
+		}
+		const presetName = preset.name;
+		let serverFile;
+		if (presetName === "node" || presetName === "bun" || presetName === "deno") serverFile = "server.mjs";
+		else if (presetName === "cloudflare") {
+			logger$1.error("Cloudflare preset preview is not supported yet. Use `wrangler dev` instead.");
+			process.exit(1);
+		} else {
+			serverFile = "handler.mjs";
+			logger$1.warn(`Preset "${presetName}" uses a fetch handler entry. Preview may not work as a standalone server.`);
+		}
+		const serverPath = join$1(cwd, outputDir, "server", serverFile);
+		if (!existsSync(serverPath)) {
+			logger$1.error(`Build output not found: ${serverPath}`);
+			logger$1.info("Run `ubean build` first to create a production build.");
+			process.exit(1);
+		}
+		const { child, exited } = spawnPreviewServer({
+			serverPath,
+			cwd,
+			port: actualPort,
+			host,
+			strictPort
+		});
+		try {
+			await waitForPort(actualPort, {
+				host,
+				retries: 40,
+				delay: 250
+			});
+		} catch {
+			if (exited.value) logger$1.error(`Preview server exited before becoming ready on port ${actualPort}.`);
+			else logger$1.warn(`Preview server on port ${actualPort} is not responding yet, the banner may be premature.`);
+		}
+		printBanner(actualPort, "production");
+		const cleanup = () => {
+			child.kill("SIGTERM");
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+		child.on("exit", (code) => {
+			if (code !== 0 && code !== null) logger$1.error(`Preview server exited with code ${code}`);
+			process.exit(code ?? 0);
+		});
+	}
+};
+function spawnPreviewServer(opts) {
+	const exited = { value: false };
+	const child = spawn("node", [opts.serverPath], {
+		cwd: opts.cwd,
+		env: {
+			...process.env,
+			PORT: String(opts.port),
+			HOST: opts.host
+		},
+		stdio: [
+			"inherit",
+			"inherit",
+			"pipe"
+		]
+	});
+	let addrInUseReported = false;
+	child.stderr?.on("data", (chunk) => {
+		const text = chunk.toString();
+		process.stderr.write(text);
+		if (!addrInUseReported && /EADDRINUSE/.test(text)) {
+			addrInUseReported = true;
+			logger$1.error(`Port ${opts.port} is already in use${opts.host ? ` on ${opts.host}` : ""}. Try a different port${opts.strictPort ? " or remove the --strictPort flag" : ""}.`);
+		}
+	});
+	child.on("exit", () => {
+		exited.value = true;
+	});
+	return {
+		child,
+		exited
+	};
+}
+//#endregion
+//#region src/scaffold-commands.ts
+const logger = consola.withTag("ubean-cli");
+const COMMAND_META = {
+	api: {
+		name: "api",
+		description: "Scaffold API routes",
+		pathLabel: "API route path",
+		pathExample: "users/[id]"
+	},
+	layout: {
+		name: "layout",
+		description: "Scaffold layout components",
+		pathLabel: "Layout path",
+		pathExample: "admin"
+	},
+	middleware: {
+		name: "middleware",
+		description: "Scaffold middleware",
+		pathLabel: "Middleware path",
+		pathExample: "auth"
+	},
+	cron: {
+		name: "cron",
+		description: "Scaffold scheduled cron tasks",
+		pathLabel: "Cron task path",
+		pathExample: "daily-cleanup"
+	},
+	plugin: {
+		name: "plugin",
+		description: "Scaffold ubean plugins",
+		pathLabel: "Plugin path",
+		pathExample: "my-plugin"
+	}
+};
+function createScaffoldCommand(type) {
+	const meta = COMMAND_META[type];
+	return {
+		meta: {
+			name: meta.name,
+			description: meta.description
+		},
+		subCommands: {
+			add: {
+				meta: {
+					name: "add",
+					description: `Add a new ${type}`
+				},
+				args: {
+					path: {
+						type: "positional",
+						description: `${meta.pathLabel} (e.g., ${meta.pathExample})`
+					},
+					...type === "api" ? { method: {
+						type: "string",
+						description: "HTTP method for API routes (GET, POST, PUT, PATCH, DELETE)",
+						default: "GET"
+					} } : {},
+					...type === "cron" ? { schedule: {
+						type: "string",
+						description: "Cron schedule expression (e.g., \"0 0 * * *\" for daily at midnight)",
+						default: "* * * * *"
+					} } : {},
+					force: {
+						type: "boolean",
+						description: "Overwrite existing files (creates .bak backup)",
+						default: false,
+						alias: "f"
+					},
+					dry: {
+						type: "boolean",
+						description: "Show what would be created without writing files",
+						default: false
+					}
+				},
+				async run({ args }) {
+					const result = await scaffold({
+						cwd: process.cwd(),
+						type,
+						path: args.path,
+						method: args.method,
+						schedule: args.schedule,
+						force: args.force,
+						dry: args.dry
+					});
+					for (const file of result.created) logger.success(`${args.dry ? "[dry-run] Would create" : "Created"} ${file}`);
+					for (const file of result.skipped) logger.warn(`Skipped ${file} (already exists, use --force to overwrite)`);
+					for (const err of result.errors) logger.error(err);
+				}
+			},
+			delete: {
+				meta: {
+					name: "delete",
+					description: `Delete a ${type} (creates backup by default)`
+				},
+				args: {
+					path: {
+						type: "positional",
+						description: `${meta.pathLabel} to delete`
+					},
+					force: {
+						type: "boolean",
+						description: "Delete permanently without creating backup",
+						default: false,
+						alias: "f"
+					},
+					dry: {
+						type: "boolean",
+						description: "Show what would be deleted",
+						default: false
+					}
+				},
+				async run({ args }) {
+					const result = await deleteScaffold({
+						cwd: process.cwd(),
+						type,
+						path: args.path,
+						force: args.force,
+						dry: args.dry
+					});
+					for (const file of result.deleted) logger.success(`${args.dry ? "[dry-run] Would delete" : args.force ? "Deleted" : "Deleted (backup created)"} ${file}`);
+					for (const err of result.errors) logger.error(err);
+				}
+			},
+			recovery: {
+				meta: {
+					name: "recovery",
+					description: `Recover a deleted ${type} from .bak backup`
+				},
+				args: {
+					path: {
+						type: "positional",
+						description: `${meta.pathLabel} to recover`
+					},
+					dry: {
+						type: "boolean",
+						description: "Check if recovery is possible",
+						default: false
+					}
+				},
+				async run({ args }) {
+					const result = await recoverScaffold({
+						cwd: process.cwd(),
+						type,
+						path: args.path,
+						dry: args.dry
+					});
+					for (const file of result.restored) logger.success(`${args.dry ? "[dry-run] Backup exists for" : "Recovered"} ${file}`);
+					for (const err of result.errors) logger.error(err);
+				}
+			},
+			list: {
+				meta: {
+					name: "list",
+					description: `List existing ${type} files`
+				},
+				async run() {
+					const files = await listScaffoldableFiles(process.cwd(), type);
+					if (files.length === 0) {
+						logger.info(`No ${type} files found`);
+						return;
+					}
+					logger.info(`Found ${files.length} ${type}(s):`);
+					for (const file of files) logger.log(`  ${file}`);
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/cli.ts
+/**
+* @ubean/cli — CLI 入口(运行时调用 `runMain`)
+*
+* 此文件仅由 `bin/ubean-next.mjs` 导入,不应被库代码 import
+* (会产生启动 CLI 的副作用)。
+*
+* 库代码请从 `@ubean/cli`(主入口)导入 scaffold / fs-ops / templates。
+*/
+runMain(defineCommand({
+	meta: {
+		name: "ubean",
+		version: "0.0.1",
+		description: "Vue meta framework built on Vite-Plus with Hono"
+	},
+	subCommands: {
+		dev: devCommand,
+		build: buildCommand,
+		prepare: prepareCommand,
+		preview: previewCommand,
+		init: initCommand,
+		page: pageCommand,
+		env: envCommand,
+		config: configCommand,
+		devtools: devtoolsCommand,
+		api: createScaffoldCommand("api"),
+		layout: createScaffoldCommand("layout"),
+		middleware: createScaffoldCommand("middleware"),
+		cron: createScaffoldCommand("cron"),
+		plugin: createScaffoldCommand("plugin")
+	}
+}));
+//#endregion
+export {};