@hazejs/cli 0.0.0-stage → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,826 @@
+import { createRequire } from "node:module";
+import { defineCommand, runMain } from "citty";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import process from "node:process";
+import { createDevServer, loadHazeConfig } from "@hazejs/vite";
+import { consola } from "consola";
+import { colors } from "consola/utils";
+import { mkdir, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+// src/args.ts
+const rootArg = { root: {
+	type: "string",
+	description: "项目根目录",
+	default: "."
+} };
+const serverArgs = {
+	port: {
+		type: "string",
+		alias: "p",
+		description: "监听端口（默认读取 PORT 或 haze.config.ts）"
+	},
+	host: {
+		type: "string",
+		description: "监听地址"
+	}
+};
+function resolveRoot(root) {
+	return resolve(process.cwd(), root);
+}
+function parsePort(port) {
+	if (port === void 0) return void 0;
+	const value = Number(port);
+	if (!Number.isInteger(value) || value < 0) throw new Error(`Invalid port: ${port}`);
+	return value;
+}
+/** srvx 在监听所有地址时返回 `[::]` / `0.0.0.0`，展示为 localhost 便于点击 */
+function displayUrl(url) {
+	return url.replace(/\/\/(?:\[::\]|0\.0\.0\.0)/, "//localhost");
+}
+// src/resolve.ts
+/**
+* 从项目目录向上查找已安装包的 package.json。
+* 不使用 require.resolve('<pkg>/package.json')：部分包（如 drizzle-kit）未在 exports 中暴露它。
+*/
+function findPackage(root, pkg) {
+	for (let dir = root;; dir = dirname(dir)) {
+		const file = join(dir, "node_modules", pkg, "package.json");
+		if (existsSync(file)) return {
+			dir: dirname(file),
+			json: JSON.parse(readFileSync(file, "utf8"))
+		};
+		if (dirname(dir) === dir) return void 0;
+	}
+}
+/** 包的可执行文件路径 */
+function binOf(root, pkg, bin = pkg.split("/").pop()) {
+	const found = findPackage(root, pkg);
+	if (!found) throw new Error(`${pkg} is not installed. Run: pnpm add -D ${pkg}`);
+	const bins = found.json.bin;
+	const path = typeof bins === "string" ? bins : bins?.[bin];
+	if (!path) throw new Error(`${pkg} has no "${bin}" executable`);
+	return join(found.dir, path);
+}
+// src/commands/db.ts
+/** 启动（不监听端口的）开发服务器以读取配置；db:migrate / db:seed 也在应用的模块图中执行 */
+async function withApp$1(root, run) {
+	const { srcDir } = await loadHazeConfig(root);
+	const server = await createDevServer({
+		root,
+		listen: false
+	});
+	try {
+		if (!server.app) throw new Error("Application failed to start");
+		const database = server.app.config.get("database", void 0);
+		if (!database?.connections) throw new Error("config/database.ts is missing or invalid");
+		return await run(server, database, srcDir);
+	} finally {
+		await server.close();
+	}
+}
+function targetOf(database, srcDir, name = database.default) {
+	const config = database.connections[name];
+	if (!config) throw new Error(`Database connection "${name}" is not defined in config/database.ts`);
+	if (config.driver === "mongodb") throw new MongoConnectionError(name);
+	return {
+		name,
+		config,
+		dialect: config.driver === "mysql" ? "mysql" : [
+			"sqlite",
+			"turso",
+			"d1"
+		].includes(config.driver) ? "sqlite" : "postgresql",
+		schema: resolve(srcDir, config.schema ?? "database/schema"),
+		migrations: resolve(srcDir, config.migrations ?? (name === database.default ? "database/migrations" : `database/migrations/${name}`))
+	};
+}
+var MongoConnectionError = class extends Error {
+	constructor(name) {
+		super(`Connection "${name}" is MongoDB, which has no SQL schema or migrations`);
+	}
+};
+const connectionArg$1 = { connection: {
+	type: "string",
+	alias: "c",
+	description: "连接名（默认 config/database.ts 中的 default）"
+} };
+const generateCommand = defineCommand({
+	meta: {
+		name: "db:generate",
+		description: "根据 database/schema 的表结构变化生成迁移（drizzle-kit）"
+	},
+	args: {
+		...rootArg,
+		...connectionArg$1,
+		name: {
+			type: "string",
+			description: "迁移名称"
+		},
+		custom: {
+			type: "boolean",
+			description: "生成空白迁移，手写 SQL",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const root = resolveRoot(args.root);
+		const target = await withApp$1(root, async (_server, database, srcDir) => targetOf(database, srcDir, args.connection));
+		const kit = binOf(root, "drizzle-kit");
+		const kitArgs = [
+			"generate",
+			`--dialect=${target.dialect}`,
+			`--schema=${relative(root, target.schema)}/*.ts`,
+			`--out=${relative(root, target.migrations)}`,
+			...args.name ? [`--name=${args.name}`] : [],
+			...args.custom ? ["--custom"] : []
+		];
+		const code = await new Promise((done) => {
+			spawn(process.execPath, [kit, ...kitArgs], {
+				cwd: root,
+				stdio: "inherit"
+			}).on("close", (code) => done(code ?? 1));
+		});
+		process.exitCode = code;
+	}
+});
+const migrateCommand = defineCommand({
+	meta: {
+		name: "db:migrate",
+		description: "执行尚未运行的迁移"
+	},
+	args: {
+		...rootArg,
+		...connectionArg$1,
+		all: {
+			type: "boolean",
+			description: "对所有连接执行",
+			default: false
+		}
+	},
+	async run({ args }) {
+		await withApp$1(resolveRoot(args.root), async (server, _database, srcDir) => {
+			const results = await (await server.import("@hazejs/orm")).runMigrations({
+				srcDir,
+				connection: args.connection,
+				all: args.all
+			});
+			for (const result of results) if (result.skipped === "mongodb") consola.info(`[${result.connection}] MongoDB has no migrations, skipped`);
+			else if (result.skipped) consola.warn(`[${result.connection}] no migrations in ${result.folder}, run haze db:generate first`);
+			else consola.success(`[${result.connection}] migrated: ${result.applied} of ${result.total} applied (${result.folder})`);
+		});
+	}
+});
+const seedCommand = defineCommand({
+	meta: {
+		name: "db:seed",
+		description: "按文件名顺序执行 database/seeders 下的数据填充"
+	},
+	args: {
+		...rootArg,
+		file: {
+			type: "string",
+			description: "只执行指定文件（不含扩展名）"
+		}
+	},
+	async run({ args }) {
+		const root = resolveRoot(args.root);
+		await withApp$1(root, async (server, _database, srcDir) => {
+			const dir = join(srcDir, "database", "seeders");
+			const files = existsSync(dir) ? readdirSync(dir).filter((file) => /\.[cm]?[jt]s$/.test(file) && (!args.file || file.replace(/\.[^.]+$/, "") === args.file)).sort() : [];
+			if (!files.length) {
+				consola.warn(`No seeders found in ${relative(root, dir)}`);
+				return;
+			}
+			for (const file of files) {
+				const module = await server.import(join(dir, file));
+				if (typeof module.default !== "function") throw new TypeError(`${file} must export a default function`);
+				await module.default(server.app);
+				consola.success(`Seeded ${file}`);
+			}
+		});
+	}
+});
+// src/make/naming.ts
+/** `admin/user-profile`、`Admin/UserProfileController` → { dir: 'admin', name: 'UserProfile' } */
+function parseName(input, suffix = "") {
+	const segments = input.replace(/\\/g, "/").split("/").filter(Boolean);
+	const last = segments.pop();
+	if (!last) throw new Error("Name is required");
+	let name = pascalCase(last);
+	if (suffix && name.endsWith(suffix) && name !== suffix) name = name.slice(0, -suffix.length);
+	if (!/^[A-Z][A-Za-z0-9]*$/.test(name)) throw new Error(`Invalid name "${input}"`);
+	return {
+		dir: segments.map(kebabCase).join("/"),
+		name
+	};
+}
+function pascalCase(value) {
+	return value.replace(/[-_\s]+(.)?/g, (_, char) => (char ?? "").toUpperCase()).replace(/^./, (char) => char.toUpperCase());
+}
+function camelCase(value) {
+	const pascal = pascalCase(value);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function kebabCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+/** 简单的英文复数，用于路由路径提示 */
+function plural(value) {
+	if (/(?:[sxz]|ch|sh)$/.test(value)) return `${value}es`;
+	if (/[^aeiou]y$/.test(value)) return `${value.slice(0, -1)}ies`;
+	return `${value}s`;
+}
+// src/make/generator.ts
+/** 内置 stub 目录：构建产物（dist/）与源码（src/make/）位于不同深度，向上查找 */
+const STUBS_DIR = ["../stubs", "../../stubs"].map((path) => fileURLToPath(new URL(path, import.meta.url))).find((dir) => existsSync(dir));
+const KINDS = {
+	controller: {
+		description: "控制器",
+		suffix: "Controller",
+		dir: "app/controller",
+		base: "src",
+		file: "class",
+		stub: "controller",
+		hint: (v) => `在 route/*.ts 中注册：r.get('/${v.routePath}', [${v.className}, 'index'])`
+	},
+	service: {
+		description: "业务服务",
+		suffix: "Service",
+		dir: "app/service",
+		base: "src",
+		file: "class",
+		stub: "service"
+	},
+	repository: {
+		description: "数据访问层",
+		suffix: "Repository",
+		dir: "app/repository",
+		base: "src",
+		file: "class",
+		stub: "repository"
+	},
+	middleware: {
+		description: "中间件",
+		suffix: "",
+		dir: "app/middleware",
+		base: "src",
+		file: "class",
+		stub: "middleware",
+		hint: (v) => `在 config/middleware.ts 的 alias 中注册：${v.camelName}: ${v.className}`
+	},
+	interceptor: {
+		description: "出站拦截器",
+		suffix: "Interceptor",
+		dir: "app/interceptor",
+		base: "src",
+		file: "kebab",
+		flat: true,
+		stub: "interceptor",
+		hint: () => "app/interceptor 下的拦截器按文件名顺序自动加载"
+	},
+	provider: {
+		description: "服务提供者",
+		suffix: "Provider",
+		dir: "app/provider",
+		base: "src",
+		file: "class",
+		stub: "provider",
+		hint: () => "app/provider 下的提供者会被自动加载"
+	},
+	event: {
+		description: "事件",
+		suffix: "",
+		dir: "app/event",
+		base: "src",
+		file: "class",
+		flat: true,
+		stub: "event",
+		hint: (v) => `触发：await ${v.className}.emit({ ... })；监听：haze make:listener <Name>`
+	},
+	listener: {
+		description: "事件监听器",
+		suffix: "",
+		dir: "app/listener",
+		base: "src",
+		file: "class",
+		flat: true,
+		stub: "listener",
+		hint: () => "app/listener 下的监听器自动注册；把 import 的事件改为要监听的事件"
+	},
+	job: {
+		description: "队列任务",
+		suffix: "",
+		dir: "app/job",
+		base: "src",
+		file: "class",
+		flat: true,
+		stub: "job",
+		hint: (v) => `投递：await ${v.className}.dispatch({ ... })；消费：haze queue:work`
+	},
+	policy: {
+		description: "授权策略",
+		suffix: "Policy",
+		dir: "app/policy",
+		base: "src",
+		file: "class",
+		flat: true,
+		stub: "policy",
+		hint: (v) => `app/policy 下的策略自动注册：await ctx.authorize('update', ${v.camelName}) / .middleware('can:update,${v.name},id')`
+	},
+	validate: {
+		description: "请求校验",
+		suffix: "Schema",
+		dir: "app/validate",
+		base: "src",
+		file: "kebab",
+		stub: "validate"
+	},
+	test: {
+		description: "测试",
+		suffix: "Test",
+		dir: "tests",
+		base: "root",
+		file: "kebab",
+		ext: ".test.ts",
+		stub: "test",
+		hint: () => "运行：haze test"
+	},
+	config: {
+		description: "配置文件",
+		suffix: "Config",
+		dir: "config",
+		base: "src",
+		file: "camel",
+		flat: true,
+		stub: "config",
+		hint: (v) => `读取：config('${v.camelName}.enabled')`
+	},
+	route: {
+		description: "路由文件",
+		suffix: "Routes",
+		dir: "route",
+		base: "src",
+		file: "kebab",
+		flat: true,
+		stub: "route"
+	},
+	seeder: {
+		description: "数据填充",
+		suffix: "Seeder",
+		dir: "database/seeders",
+		base: "src",
+		file: "kebab",
+		flat: true,
+		stub: "seeder",
+		hint: () => "运行：haze db:seed"
+	}
+};
+async function make(options) {
+	const kind = KINDS[options.kind];
+	const { dir, name } = parseName(options.name, kind.suffix);
+	if (kind.flat && dir) throw new Error(`${kind.dir}/ 只自动加载第一层文件，${options.kind} 名称不能包含子目录：${options.name}`);
+	const vars = {
+		name,
+		className: name + (kind.file === "class" ? kind.suffix : ""),
+		camelName: camelCase(name),
+		kebabName: kebabCase(name),
+		envName: kebabCase(name).replace(/-/g, "_").toUpperCase(),
+		routePath: plural(kebabCase(name))
+	};
+	const fileName = kind.file === "class" ? vars.className : kind.file === "camel" ? vars.camelName : vars.kebabName;
+	const base = kind.base === "root" ? options.root : options.srcDir;
+	const kindDir = options.app && kind.base === "src" ? `app/${kebabCase(options.app)}/${kind.dir.replace(/^app\//, "")}` : kind.dir;
+	const file = join(base, kindDir, dir, fileName + (kind.ext ?? ".ts"));
+	if (existsSync(file) && !options.force) throw new Error(`${file} already exists. Use --force to overwrite.`);
+	const stubName = options.variant ?? kind.stub;
+	const { content, custom } = readStub(options.root, stubName);
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, render(content, vars));
+	return {
+		file,
+		stub: stubName,
+		custom,
+		hint: options.app ? kind.hint?.(vars)?.replace("route/*.ts", `app/${kebabCase(options.app)}/route/*.ts`) : kind.hint?.(vars)
+	};
+}
+/** 优先使用项目根目录 stubs/<name>.stub，便于团队定制 */
+function readStub(root, stubName) {
+	const custom = join(root, "stubs", `${stubName}.stub`);
+	if (existsSync(custom)) return {
+		content: readFileSync(custom, "utf8"),
+		custom: true
+	};
+	const builtin = join(STUBS_DIR, `${stubName}.stub`);
+	if (!existsSync(builtin)) throw new Error(`Stub "${stubName}" not found`);
+	return {
+		content: readFileSync(builtin, "utf8"),
+		custom: false
+	};
+}
+/** 生成模型（app/model）与对应的 drizzle 表结构（database/schema，已存在时跳过） */
+async function makeModel(options) {
+	const { dir, name } = parseName(options.name, "Model");
+	const tableName = options.table ?? plural(kebabCase(name)).replace(/-/g, "_");
+	const vars = {
+		name,
+		className: name,
+		tableName,
+		tableVar: camelCase(tableName),
+		softDelete: String(options.softDelete ?? false)
+	};
+	const modelDir = options.app ? `app/${kebabCase(options.app)}/model` : "app/model";
+	const model = join(options.srcDir, modelDir, dir, `${name}.ts`);
+	if (existsSync(model) && !options.force) throw new Error(`${model} already exists. Use --force to overwrite.`);
+	const mongo = options.dialect === "mongodb";
+	const schema = join(options.srcDir, "database/schema", `${tableName}.ts`);
+	const writeSchema = !mongo && !existsSync(schema);
+	await mkdir(dirname(model), { recursive: true });
+	await writeFile(model, render(readStub(options.root, mongo ? "model.mongodb" : "model").content, vars));
+	if (writeSchema) {
+		await mkdir(dirname(schema), { recursive: true });
+		await writeFile(schema, render(readStub(options.root, `schema.${options.dialect ?? "sqlite"}`).content, vars));
+	}
+	return {
+		model,
+		schema: writeSchema ? schema : void 0,
+		hint: mongo ? "MongoDB 无需迁移；索引可通过 (await Mongo.db()).collection(...).createIndex() 管理" : "修改表结构后运行：haze db:generate && haze db:migrate"
+	};
+}
+function render(content, vars) {
+	return content.replace(/\{\{\s*(\w+)\s*\}\}/g, (match, key) => vars[key] ?? match);
+}
+// src/commands/make.ts
+function makeCommand(kind) {
+	return defineCommand({
+		meta: {
+			name: `make:${kind}`,
+			description: `生成${KINDS[kind].description}`
+		},
+		args: {
+			name: {
+				type: "positional",
+				description: "名称，可带子目录，例如 admin/User",
+				required: true
+			},
+			...rootArg,
+			force: {
+				type: "boolean",
+				description: "文件已存在时覆盖",
+				default: false
+			},
+			app: {
+				type: "string",
+				alias: "a",
+				description: "多应用：生成到 app/<app>/ 下"
+			},
+			...kind === "controller" && { resource: {
+				type: "boolean",
+				alias: "r",
+				description: "生成 RESTful 资源控制器",
+				default: false
+			} }
+		},
+		async run({ args }) {
+			const root = resolveRoot(args.root);
+			const { srcDir } = await loadHazeConfig(root);
+			const result = await make({
+				root,
+				srcDir,
+				kind,
+				name: args.name,
+				force: args.force,
+				variant: variantOf(kind, root, args),
+				app: args.app
+			});
+			consola.success(`Created ${colors.cyan(relative(process.cwd(), result.file))}${result.custom ? colors.dim(` (stubs/${result.stub}.stub)`) : ""}`);
+			if (result.hint) consola.info(result.hint);
+		}
+	});
+}
+function variantOf(kind, root, args) {
+	if (kind === "controller" && args.resource) return "controller.resource";
+	if (kind === "validate" && usesOnly(root, "zod", "valibot")) return "validate.zod";
+}
+function usesOnly(root, wanted, other) {
+	const file = join(root, "package.json");
+	if (!existsSync(file)) return false;
+	const pkg = JSON.parse(readFileSync(file, "utf8"));
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	return wanted in deps && !(other in deps);
+}
+const makeCommands = Object.fromEntries(Object.keys(KINDS).map((kind) => [`make:${kind}`, makeCommand(kind)]));
+const makeModelCommand = defineCommand({
+	meta: {
+		name: "make:model",
+		description: "生成模型与 drizzle 表结构（database/schema）"
+	},
+	args: {
+		name: {
+			type: "positional",
+			description: "模型名，例如 User 或 OrderItem",
+			required: true
+		},
+		...rootArg,
+		table: {
+			type: "string",
+			description: "表名（默认为复数下划线形式，例如 order_items）"
+		},
+		dialect: {
+			type: "string",
+			description: "sqlite | postgres | mysql | mongodb（默认按已安装的驱动推断）"
+		},
+		softDelete: {
+			type: "boolean",
+			description: "启用软删除",
+			default: false
+		},
+		app: {
+			type: "string",
+			alias: "a",
+			description: "多应用：模型生成到 app/<app>/model"
+		},
+		force: {
+			type: "boolean",
+			description: "文件已存在时覆盖",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const root = resolveRoot(args.root);
+		const { srcDir } = await loadHazeConfig(root);
+		const dialect = args.dialect ?? detectDialect(root);
+		if (![
+			"sqlite",
+			"postgres",
+			"mysql",
+			"mongodb"
+		].includes(dialect)) throw new Error(`Unknown dialect "${dialect}"`);
+		const result = await makeModel({
+			root,
+			srcDir,
+			name: args.name,
+			table: args.table,
+			dialect,
+			softDelete: args.softDelete,
+			app: args.app,
+			force: args.force
+		});
+		consola.success(`Created ${colors.cyan(relative(process.cwd(), result.model))}`);
+		if (result.schema) consola.success(`Created ${colors.cyan(relative(process.cwd(), result.schema))} ${colors.dim(`(${dialect})`)}`);
+		consola.info(result.hint);
+	}
+});
+function detectDialect(root) {
+	if (usesOnly(root, "mongodb", "@libsql/client") && usesOnly(root, "mongodb", "mysql2") && usesOnly(root, "mongodb", "postgres")) return "mongodb";
+	if (usesOnly(root, "mysql2", "@libsql/client")) return "mysql";
+	if (usesOnly(root, "postgres", "@libsql/client") || usesOnly(root, "@electric-sql/pglite", "@libsql/client")) return "postgres";
+	return "sqlite";
+}
+// src/commands/worker.ts
+/** 在应用的模块图中运行（不监听端口）；keepAlive 时保持运行，文件变化后应用热替换 */
+async function withApp(root, run, keepAlive = false) {
+	const server = await createDevServer({
+		root,
+		listen: false
+	});
+	if (!server.app) {
+		await server.close();
+		throw new Error("Application failed to start");
+	}
+	const core = await server.import("@hazejs/core");
+	try {
+		return await run(server, core);
+	} finally {
+		if (!keepAlive) await server.close();
+	}
+}
+/** 等待 Ctrl+C / SIGTERM，然后执行清理 */
+function untilSignal(cleanup) {
+	return new Promise((resolve) => {
+		const stop = async () => {
+			consola.info("Stopping…");
+			await cleanup();
+			resolve();
+		};
+		process.once("SIGINT", stop);
+		process.once("SIGTERM", stop);
+	});
+}
+const connectionArg = { connection: {
+	type: "string",
+	description: "队列连接（默认 config/queue.ts 的 default）"
+} };
+const queueWorkCommand = defineCommand({
+	meta: {
+		name: "queue:work",
+		description: "消费队列任务（任务代码修改后自动生效）"
+	},
+	args: {
+		...rootArg,
+		...connectionArg,
+		queue: {
+			type: "string",
+			alias: "q",
+			description: "队列名，逗号分隔（按优先级），默认 default"
+		},
+		concurrency: {
+			type: "string",
+			alias: "c",
+			description: "并发数，默认 1",
+			default: "1"
+		}
+	},
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			const manager = () => server.app.make(core.QueueManager);
+			const queues = args.queue?.split(",").map((name) => name.trim()).filter(Boolean) ?? ["default"];
+			const worker = await manager().work({
+				connection: args.connection,
+				queues,
+				concurrency: Number(args.concurrency),
+				resolve: manager
+			});
+			consola.success(`Processing ${queues.join(", ")} (${manager().config.connections[args.connection ?? manager().config.default]?.driver} connection, concurrency ${args.concurrency})`);
+			await untilSignal(async () => {
+				await worker.stop();
+				await server.close();
+			});
+		}, true);
+	}
+});
+const queueFailedCommand = defineCommand({
+	meta: {
+		name: "queue:failed",
+		description: "列出失败的任务"
+	},
+	args: {
+		...rootArg,
+		...connectionArg
+	},
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			const failed = await server.app.make(core.QueueManager).failed(args.connection);
+			if (!failed.length) {
+				consola.info("No failed jobs");
+				return;
+			}
+			for (const job of failed) console.log(`${job.id}  ${job.job}  [${job.queue}]  ${new Date(job.failedAt).toISOString()}  attempts=${job.attempts}\n  ${job.error.split("\n")[0]}`);
+		});
+	}
+});
+const queueRetryCommand = defineCommand({
+	meta: {
+		name: "queue:retry",
+		description: "重新投递失败的任务（不传 id 为全部）"
+	},
+	args: {
+		...rootArg,
+		...connectionArg,
+		id: {
+			type: "positional",
+			required: false,
+			description: "任务 ID"
+		}
+	},
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			const count = await server.app.make(core.QueueManager).retry(args.id, args.connection);
+			consola.success(`Retried ${count} job(s)`);
+		});
+	}
+});
+const queueForgetCommand = defineCommand({
+	meta: {
+		name: "queue:forget",
+		description: "删除一个失败的任务"
+	},
+	args: {
+		...rootArg,
+		...connectionArg,
+		id: {
+			type: "positional",
+			required: true,
+			description: "任务 ID"
+		}
+	},
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			if (await server.app.make(core.QueueManager).forget(args.id, args.connection)) consola.success(`Removed ${args.id}`);
+			else consola.warn(`No failed job ${args.id}`);
+		});
+	}
+});
+const queueFlushCommand = defineCommand({
+	meta: {
+		name: "queue:flush",
+		description: "清空失败的任务"
+	},
+	args: {
+		...rootArg,
+		...connectionArg
+	},
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			consola.success(`Removed ${await server.app.make(core.QueueManager).flush(args.connection)} failed job(s)`);
+		});
+	}
+});
+const scheduleListCommand = defineCommand({
+	meta: {
+		name: "schedule:list",
+		description: "列出定时任务与下次执行时间"
+	},
+	args: rootArg,
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			const scheduler = server.app.make(core.Scheduler);
+			const tasks = scheduler.tasks();
+			if (!tasks.length) {
+				consola.info("No scheduled tasks (schedule/*.ts)");
+				return;
+			}
+			const width = Math.max(...tasks.map((task) => task.name.length));
+			for (const task of tasks) {
+				const flags = [task.runsOnOneServer && "onOneServer", task.preventsOverlap && "withoutOverlapping"].filter(Boolean).join(", ");
+				const timezone = task.timezoneName ?? scheduler.config.timezone ?? "UTC";
+				console.log(`${task.name.padEnd(width)}  ${task.expression.padEnd(15)}  ${timezone.padEnd(15)}  next ${task.nextRun(/* @__PURE__ */ new Date(), scheduler.config.timezone)?.toISOString() ?? "-"}${flags ? `  (${flags})` : ""}`);
+			}
+		});
+	}
+});
+const scheduleRunCommand = defineCommand({
+	meta: {
+		name: "schedule:run",
+		description: "执行当前分钟到期的定时任务（配合系统 cron 每分钟调用）"
+	},
+	args: rootArg,
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			const runs = await server.app.make(core.Scheduler).runDue();
+			if (!runs.length) consola.info("No scheduled tasks are due");
+			for (const run of runs) consola[run.status === "failed" ? "error" : run.status === "ok" ? "success" : "info"](`${run.name}: ${run.status}${run.reason ? ` (${run.reason})` : ""}`);
+			if (runs.some((run) => run.status === "failed")) process.exitCode = 1;
+		});
+	}
+});
+const scheduleWorkCommand = defineCommand({
+	meta: {
+		name: "schedule:work",
+		description: "常驻执行定时任务（每分钟整点检查）"
+	},
+	args: rootArg,
+	async run({ args }) {
+		await withApp(resolveRoot(args.root), async (server, core) => {
+			const controller = new AbortController();
+			consola.success(`Scheduler started (${server.app.make(core.Scheduler).tasks().length} task(s))`);
+			const loop = (async () => {
+				while (!controller.signal.aborted) await server.app.make(core.Scheduler).work(AbortSignal.any([controller.signal, AbortSignal.timeout(61e3)]));
+			})();
+			await untilSignal(async () => {
+				controller.abort();
+				await loop;
+				await server.close();
+			});
+		}, true);
+	}
+});
+// src/index.ts
+const { version } = createRequire(import.meta.url)("../package.json");
+const main = defineCommand({
+	meta: {
+		name: "hazejs",
+		version,
+		description: "hazejs Node 服务端框架命令行"
+	},
+	subCommands: {
+		"dev": () => import("./dev-B4V8ouF6.mjs").then((m) => m.default),
+		"build": () => import("./build-1rAV1kEg.mjs").then((m) => m.default),
+		"start": () => import("./start-DYW9Ar9y.mjs").then((m) => m.default),
+		"preview": () => import("./preview-B6OYX5qM.mjs").then((m) => m.default),
+		"key:generate": () => import("./key-CmUJM4SG.mjs").then((m) => m.default),
+		"test": () => import("./test-CUMzRaAD.mjs").then((m) => m.default),
+		"route:list": () => import("./routes-DF0y4tVg.mjs").then((m) => m.default),
+		"typegen": () => import("./typegen-BljZvG5y.mjs").then((m) => m.default),
+		"stub:publish": () => import("./stub-publish-BvtOsp9D.mjs").then((m) => m.default),
+		...makeCommands,
+		"make:model": makeModelCommand,
+		"db:generate": generateCommand,
+		"db:migrate": migrateCommand,
+		"db:seed": seedCommand,
+		"queue:work": queueWorkCommand,
+		"queue:failed": queueFailedCommand,
+		"queue:retry": queueRetryCommand,
+		"queue:forget": queueForgetCommand,
+		"queue:flush": queueFlushCommand,
+		"schedule:list": scheduleListCommand,
+		"schedule:run": scheduleRunCommand,
+		"schedule:work": scheduleWorkCommand
+	}
+});
+runMain(main);
+export { resolveRoot as a, parsePort as i, binOf as n, rootArg as o, displayUrl as r, serverArgs as s, STUBS_DIR as t };