@jayfong/x-server 2.119.0 → 3.1.1

package/lib/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+// \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+export { __require };

package/lib/cli/api_generator.d.mts

@@ -0,0 +1,75 @@
+import { XHandler } from "../core/types.mjs";
+import createDebug from "debug";
+import { ts } from "ts-morph";
+import { JSONSchema4 } from "json-schema";
+import { OpenAPIV3_1 } from "openapi-types";
+import { LiteralUnion } from "vtils/types";
+/** 注释 */
+type Comment = {
+  existing: boolean;
+  description: string;
+  tags: Map<LiteralUnion<'private', string>, string>;
+};
+/** 接口传输数据 */
+type ApiDto = {
+  name: string;
+  desc: string;
+  type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'file';
+  enum: any[];
+  required: boolean;
+  children: ApiDto[];
+};
+/** 接口数据 */
+type ApiData = {
+  category: string;
+  name: string;
+  desc: string;
+  path: string[];
+  handlerMethod: XHandler.Method;
+  method: string;
+  requestData: ApiDto;
+  responseData: ApiDto;
+  requestDataJsonSchema: JSONSchema4;
+  responseDataJsonSchema: JSONSchema4;
+};
+export type ApiGeneratorOptions = {
+  cwd?: string;
+  include?: string[];
+  exclude?: string[];
+  name?: string;
+};
+export declare class ApiGenerator {
+  private options;
+  private cwd;
+  constructor(options?: ApiGeneratorOptions);
+  debug: createDebug.Debugger;
+  categoryUrlRe: RegExp;
+  checker: ts.TypeChecker;
+  private resolveCategorySymbols;
+  start(): Promise<void>;
+  getComment(symbol?: ts.Symbol): Comment;
+  getApiDto({ type, keySymbol }: {
+    type: ts.Type;
+    keySymbol?: ts.Symbol;
+  }): ApiDto;
+  apiDataToJsonSchema(apiData: ApiDto, jsonSchema?: JSONSchema4): JSONSchema4;
+  apiDataToYApiData(handles: ApiData[]): {
+    name: string;
+    desc: string;
+    list: any;
+  }[];
+  apiDataToOpenAPI31Data(handles: ApiData[]): Omit<Omit<import("openapi-types").OpenAPIV3.Document<{}>, "paths" | "components">, "paths" | "components" | "info" | "servers" | "webhooks" | "jsonSchemaDialect"> & {
+    info: OpenAPIV3_1.InfoObject;
+    jsonSchemaDialect?: string;
+    servers?: OpenAPIV3_1.ServerObject[];
+  } & Pick<{
+    paths: OpenAPIV3_1.PathsObject<{}, {}>;
+    webhooks: Record<string, OpenAPIV3_1.PathItemObject | OpenAPIV3_1.ReferenceObject>;
+    components: OpenAPIV3_1.ComponentsObject;
+  }, "paths"> & Omit<Partial<{
+    paths: OpenAPIV3_1.PathsObject<{}, {}>;
+    webhooks: Record<string, OpenAPIV3_1.PathItemObject | OpenAPIV3_1.ReferenceObject>;
+    components: OpenAPIV3_1.ComponentsObject;
+  }>, "paths">;
+}
+export {};

package/lib/cli/api_generator.mjs

@@ -0,0 +1,334 @@
+import { HandlerMethodToHttpMethod } from "../core/http_method.mjs";
+import { castArray, ii, pascalCase } from "vtils";
+import path from "node:path";
+import fs from "fs-extra";
+import createDebug from "debug";
+import mo, { ts } from "ts-morph";
+// src/cli/api_generator.ts
+var ApiGenerator = class {
+	options;
+	cwd;
+	constructor(options = {}) {
+		this.options = options;
+		this.cwd = this.options.cwd || process.cwd();
+	}
+	debug = createDebug("api");
+	categoryUrlRe = /^.+\/src\/handlers\/(?:index\.ts|(.*)\/index\.ts|(.*)\.ts)$/;
+	checker;
+	resolveCategorySymbols(program, checker, entrySourceFile, sourcePath) {
+		const moduleSymbol = checker.getSymbolAtLocation(entrySourceFile);
+		const directCategorySymbols = checker.getExportsOfModule(moduleSymbol).filter((categorySymbol) => {
+			return checker.getTypeOfSymbol(categorySymbol).getProperties().length > 0;
+		});
+		if (directCategorySymbols.length > 0) return directCategorySymbols;
+		const resolvedSymbols = [];
+		for (const statement of entrySourceFile.statements) {
+			if (!ts.isExportDeclaration(statement) || !statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+			const targetPath = path.resolve(path.dirname(sourcePath), statement.moduleSpecifier.text);
+			const resolvedSourceFile = [
+				targetPath,
+				`${targetPath}.ts`,
+				`${targetPath}.tsx`,
+				`${targetPath}/index.ts`,
+				`${targetPath}/index.tsx`
+			].map((candidatePath) => program.getSourceFile(candidatePath)).find(Boolean);
+			if (!resolvedSourceFile) continue;
+			const resolvedSymbol = checker.getSymbolAtLocation(resolvedSourceFile);
+			if (!resolvedSymbol) continue;
+			if (checker.getTypeOfSymbol(resolvedSymbol).getProperties().length > 0) resolvedSymbols.push(resolvedSymbol);
+		}
+		return resolvedSymbols;
+	}
+	async start() {
+		this.debug("启动项目...");
+		const tsConfigPath = path.join(this.cwd, "tsconfig.json");
+		const handlersPath = path.join(this.cwd, "node_modules/@a/x/handlers.ts");
+		const entryFile = path.join(this.cwd, "src/generated/handlers.ts");
+		const moProject = new mo.Project({ tsConfigFilePath: tsConfigPath });
+		moProject.createSourceFile(entryFile, await fs.readFile(handlersPath, "utf-8"));
+		const program = moProject.getProgram().compilerObject;
+		const checker = program.getTypeChecker();
+		this.checker = checker;
+		const entrySourceFile = program.getSourceFile(entryFile);
+		const categorySymbols = this.resolveCategorySymbols(program, checker, entrySourceFile, handlersPath);
+		const apiData = [];
+		for (const categorySymbol of categorySymbols) {
+			const handlerSymbols = checker.getTypeOfSymbol(categorySymbol).getProperties();
+			if (!handlerSymbols.length) continue;
+			const categorySourceFilePath = handlerSymbols[0].getDeclarations()[0].getSourceFile().fileName;
+			if (/@dev[/.]/.test(categorySourceFilePath)) continue;
+			if (this.options.include?.length) {
+				if (this.options.include.every((item) => !categorySourceFilePath.includes(item))) continue;
+			}
+			if (this.options.exclude?.length) {
+				if (this.options.exclude.some((item) => categorySourceFilePath.includes(item))) continue;
+			}
+			const categoryUrlMatch = categorySourceFilePath.match(this.categoryUrlRe);
+			let categoryUrl = categoryUrlMatch[1] ?? categoryUrlMatch[2] ?? "";
+			categoryUrl = categoryUrl === "" ? "/" : `/${categoryUrl}/`;
+			for (const handlerSymbol of handlerSymbols) {
+				let handlerPath = [handlerSymbol.getName()];
+				const handlerNode = handlerSymbol.getDeclarations()[0];
+				if (ts.isVariableDeclaration(handlerNode) && handlerNode.initializer && ts.isCallExpression(handlerNode.initializer) && ts.isObjectLiteralExpression(handlerNode.initializer.arguments[0])) {
+					const requestPathNode = handlerNode.initializer.arguments[0].properties.find((item) => item.name?.getText() === "requestPath");
+					if (requestPathNode && ts.isPropertyAssignment(requestPathNode)) {
+						const customHandlerPath = ts.isStringLiteral(requestPathNode.initializer) ? requestPathNode.initializer.text : ts.isArrayLiteralExpression(requestPathNode.initializer) ? requestPathNode.initializer.elements.filter((item) => ts.isStringLiteral(item)).map((item) => item.text) : "";
+						if (customHandlerPath.length) handlerPath = castArray(customHandlerPath);
+					}
+				}
+				const handlerUrl = handlerPath.map((path) => `${categoryUrl}${path}`);
+				const handlerComment = this.getComment(handlerSymbol);
+				if (handlerComment.tags.has("private")) {
+					this.debug("跳过生成接口: %s", `${handlerUrl}`);
+					continue;
+				}
+				this.debug("生成接口: %s ...", handlerUrl);
+				const handlerType = checker.getTypeAtLocation(handlerNode);
+				const [requestType, responseType, methodType] = checker.getTypeArguments(handlerType);
+				const handlerCategory = pascalCase(categoryUrl) || "Index";
+				const handlerDescription = handlerComment.description || handlerUrl.join(", ");
+				const handlerMethod = methodType.value;
+				const httpMethod = HandlerMethodToHttpMethod[handlerMethod];
+				const requestData = this.getApiDto({ type: requestType });
+				const responseData = this.getApiDto({ type: responseType });
+				const requestDataJsonSchema = this.apiDataToJsonSchema(requestData);
+				const responseDataJsonSchema = this.apiDataToJsonSchema(responseData);
+				const handlerDescriptionDividerIndex = handlerDescription.indexOf("\n\n");
+				const apiName = handlerDescriptionDividerIndex === -1 ? handlerDescription : handlerDescription.substring(0, handlerDescriptionDividerIndex);
+				const apiDesc = handlerDescriptionDividerIndex === -1 ? "" : handlerDescription.substring(handlerDescriptionDividerIndex + 2);
+				apiData.push({
+					category: handlerCategory,
+					name: apiName,
+					desc: apiDesc,
+					path: handlerUrl,
+					handlerMethod,
+					method: httpMethod,
+					requestData,
+					responseData,
+					requestDataJsonSchema,
+					responseDataJsonSchema
+				});
+			}
+		}
+		this.debug("写入文件...");
+		const prefix = this.options.name ? `${this.options.name}_` : "";
+		await Promise.all([
+			fs.outputJSON(path.join(this.cwd, `temp/${prefix}api.json`), apiData, { spaces: 2 }),
+			fs.outputJSON(path.join(this.cwd, `temp/${prefix}yapi.json`), this.apiDataToYApiData(apiData), { spaces: 2 }),
+			fs.outputJSON(path.join(this.cwd, `temp/${prefix}openapi31.json`), this.apiDataToOpenAPI31Data(apiData), { spaces: 2 })
+		]);
+	}
+	getComment(symbol) {
+		if (!symbol) return {
+			existing: false,
+			description: "",
+			tags: /* @__PURE__ */ new Map()
+		};
+		const description = ts.displayPartsToString(symbol.getDocumentationComment(this.checker)).trim();
+		const tags = symbol.getJsDocTags().map((item) => {
+			return {
+				label: item.name,
+				value: ts.displayPartsToString(item.text).trim()
+			};
+		});
+		return {
+			existing: !!description,
+			description,
+			tags: tags.reduce((res, item) => {
+				res.set(item.label, item.value);
+				return res;
+			}, /* @__PURE__ */ new Map())
+		};
+	}
+	getApiDto({ type, keySymbol = type.symbol || type.aliasSymbol }) {
+		const hasTypeFlag = (flag, _type = type) => (_type.flags & flag) === flag;
+		let valueSymbol = type.symbol || type.aliasSymbol;
+		const keySymbolName = keySymbol?.getName() || "";
+		let valueSymbolName = valueSymbol?.getName() || "";
+		const comment = this.getComment(keySymbol);
+		let isRequired = keySymbol ? !(keySymbol.getFlags() & ts.SymbolFlags.Optional) : false;
+		const apiName = keySymbolName || "__type";
+		if (valueSymbolName === "Decimal") return {
+			name: apiName,
+			desc: comment.description,
+			required: isRequired,
+			type: "number",
+			enum: [],
+			children: []
+		};
+		if (valueSymbolName === "SocketStream") return {
+			name: "ws",
+			desc: comment.description,
+			required: isRequired,
+			type: "object",
+			enum: [],
+			children: []
+		};
+		if (valueSymbolName === "MultipartFile") return {
+			name: "file",
+			desc: comment.description,
+			required: isRequired,
+			type: "file",
+			enum: [],
+			children: []
+		};
+		if (valueSymbolName === "Buffer") return {
+			name: "buffer",
+			desc: comment.description,
+			required: isRequired,
+			type: "object",
+			enum: [],
+			children: []
+		};
+		const rawUnionTypes = type.isUnion() && type.types || [];
+		const unionTypes = rawUnionTypes.filter((item) => !hasTypeFlag(ts.TypeFlags.Null, item) && !hasTypeFlag(ts.TypeFlags.Undefined, item));
+		const isUnion = !!unionTypes.length;
+		if (isUnion) {
+			if (unionTypes.length !== rawUnionTypes.length) isRequired = false;
+			type = unionTypes[0];
+			valueSymbol = type.symbol || type.aliasSymbol;
+			valueSymbolName = this.checker.getBaseTypeOfLiteralType(type).getSymbol()?.getName() || "";
+		}
+		const isIntersection = type.isIntersection();
+		const intersectionTypes = isIntersection && type.types || [];
+		const isDate = valueSymbolName === "Date";
+		const isRegExp = valueSymbolName === "RegExp";
+		const isBigIntLiteral = hasTypeFlag(ts.TypeFlags.BigIntLiteral);
+		const isBigInt = hasTypeFlag(ts.TypeFlags.BigInt) || isBigIntLiteral;
+		const isArray = valueSymbolName === "Array" || valueSymbolName === "ReadonlyArray";
+		const isStringLiteral = hasTypeFlag(ts.TypeFlags.StringLiteral);
+		const isString = hasTypeFlag(ts.TypeFlags.String) || isStringLiteral || isBigInt || isDate || isRegExp;
+		const isNumberLiteral = hasTypeFlag(ts.TypeFlags.NumberLiteral);
+		const isNumber = hasTypeFlag(ts.TypeFlags.Number) || isNumberLiteral;
+		const isBoolean = hasTypeFlag(ts.TypeFlags.Boolean) || hasTypeFlag(ts.TypeFlags.BooleanLiteral);
+		const isLiteral = isStringLiteral || isNumberLiteral || isBigIntLiteral;
+		const isObject = !isArray && !isString && !isNumber && !isBoolean && hasTypeFlag(ts.TypeFlags.Object) || isIntersection;
+		return {
+			name: apiName,
+			desc: keySymbol && this.getComment(keySymbol).description || "",
+			enum: (isUnion ? unionTypes.map((item) => item.value) : isLiteral ? [type.value] : []).filter((v) => v != null),
+			type: isArray ? "array" : isString ? "string" : isNumber ? "number" : isBoolean ? "boolean" : "object",
+			required: isRequired,
+			children: isArray ? [this.getApiDto({ type: this.checker.getTypeArguments(type)[0] })] : isObject ? ii(() => {
+				return this.checker.getAllPossiblePropertiesOfTypes(intersectionTypes.length ? intersectionTypes : [type]).map((childSymbol) => {
+					const childType = this.checker.getTypeOfSymbol(childSymbol);
+					return this.getApiDto({
+						type: childType,
+						keySymbol: childSymbol
+					});
+				});
+			}) : []
+		};
+	}
+	apiDataToJsonSchema(apiData, jsonSchema = {}) {
+		jsonSchema.description = apiData.desc;
+		if (apiData.type === "object") {
+			jsonSchema.type = "object";
+			jsonSchema.properties = apiData.children.reduce((res, item) => {
+				res[item.name] = this.apiDataToJsonSchema(item);
+				return res;
+			}, {});
+			jsonSchema.required = apiData.children.filter((item) => item.required).map((item) => item.name);
+		} else if (apiData.type === "array") {
+			jsonSchema.type = "array";
+			jsonSchema.items = apiData.children.map((item) => this.apiDataToJsonSchema(item))[0];
+		} else {
+			jsonSchema.type = apiData.type;
+			if (apiData.enum.length) jsonSchema.enum = apiData.enum;
+		}
+		return jsonSchema;
+	}
+	apiDataToYApiData(handles) {
+		const data = {};
+		for (const handle of handles) for (const path of handle.path) {
+			data[handle.category] = data[handle.category] || [];
+			data[handle.category].push(handle.handlerMethod === "GET" ? {
+				method: handle.method.toUpperCase(),
+				title: handle.name,
+				markdown: handle.desc,
+				path,
+				res_body_type: "json",
+				req_body_is_json_schema: false,
+				res_body_is_json_schema: true,
+				req_params: [],
+				req_query: handle.requestData.children.map((item) => ({
+					required: item.required ? 1 : 0,
+					name: item.name,
+					desc: item.desc,
+					type: "string"
+				})),
+				req_headers: [],
+				req_body_form: [],
+				res_body: JSON.stringify(handle.responseDataJsonSchema)
+			} : handle.handlerMethod === "FILE" ? {
+				method: handle.method.toUpperCase(),
+				title: handle.name,
+				markdown: handle.desc,
+				path,
+				req_body_type: "form",
+				res_body_type: "json",
+				req_body_is_json_schema: false,
+				res_body_is_json_schema: true,
+				req_params: [],
+				req_query: [],
+				req_headers: [],
+				req_body_form: handle.requestData.children.map((item) => ({
+					required: item.required ? 1 : 0,
+					name: item.name,
+					desc: item.desc,
+					type: item.type === "file" ? "file" : "text"
+				})),
+				res_body: JSON.stringify(handle.responseDataJsonSchema)
+			} : {
+				method: handle.method.toUpperCase(),
+				title: handle.name,
+				markdown: handle.desc,
+				path,
+				req_body_type: "json",
+				res_body_type: "json",
+				req_body_is_json_schema: true,
+				res_body_is_json_schema: true,
+				req_params: [],
+				req_query: [],
+				req_headers: [],
+				req_body_form: [],
+				req_body_other: JSON.stringify(handle.requestDataJsonSchema),
+				res_body: JSON.stringify(handle.responseDataJsonSchema)
+			});
+		}
+		return Object.keys(data).map((cat) => ({
+			name: cat,
+			desc: cat,
+			list: data[cat]
+		}));
+	}
+	apiDataToOpenAPI31Data(handles) {
+		const data = {
+			openapi: "3.1.0",
+			info: {
+				title: `${process.env.APP_NAME}`,
+				version: "1.0.0"
+			},
+			paths: {},
+			servers: [{
+				url: `${process.env.APP_URL}`.replace(/\/+$/, ""),
+				description: "生产"
+			}, {
+				url: `http://127.0.0.1:${process.env.APP_PORT}`,
+				description: "本地"
+			}]
+		};
+		for (const handle of handles) for (const path of handle.path) data.paths[path] = { [handle.method.toLowerCase()]: {
+			tags: [handle.category],
+			summary: handle.name,
+			description: handle.desc,
+			requestBody: { content: { "application/json": { schema: handle.requestDataJsonSchema } } },
+			responses: { "200": {
+				description: "success",
+				content: { "application/json": { schema: handle.responseDataJsonSchema } }
+			} }
+		} };
+		return data;
+	}
+};
+export { ApiGenerator };

package/lib/cli/build_util.d.mts

@@ -0,0 +1,15 @@
+export interface BuildOptions {
+  appId: string;
+  cwd: string;
+  inlineEnvs?: Record<string, any>;
+  minify?: boolean;
+  channel?: string;
+  excludeFiles?: string[];
+  noEmptyDistDir?: boolean;
+  pm2MaxMemoryRestart?: string;
+  pm2CronRestart?: string;
+  pm2NodeArgs?: string | string[];
+}
+export declare class BuildUtil {
+  static build(options: BuildOptions): Promise<void>;
+}

package/lib/cli/build_util.mjs

@@ -0,0 +1,101 @@
+import { dedent, omitStrict } from "vtils";
+import path from "node:path";
+import fs from "fs-extra";
+import compressing from "compressing";
+import * as esbuild from "esbuild";
+import macrosPlugin from "unplugin-macros/esbuild";
+// src/cli/build_util.ts
+var BuildUtil = class {
+	static async build(options) {
+		const mainFile = path.join(options.cwd, "src/main.ts");
+		const pkgFile = path.join(options.cwd, "package.json");
+		const pkgContent = await fs.readJson(pkgFile);
+		pkgContent.name = options.appId;
+		const distDir = path.join(options.cwd, options.channel ? `dist/${options.channel}` : "dist");
+		const tempDir = path.join(options.cwd, options.channel ? `temp/${options.channel}` : "temp");
+		const distMainFile = path.join(distDir, "main.js");
+		const distPkgFile = path.join(distDir, "package.json");
+		const distNvmrcFile = path.join(distDir, ".nvmrc");
+		const distNpmrcFile = path.join(distDir, ".npmrc");
+		const distPnpmWorkspaceFile = path.join(distDir, "pnpm-workspace.yaml");
+		const distPnpmLockFile = path.join(distDir, "pnpm-lock.yaml");
+		const distPm2File = path.join(distDir, "pm2.config.js");
+		const distBundleFile = path.join(tempDir, `app.${pkgContent.version}.tgz`);
+		await fs.ensureDir(distDir);
+		await fs.ensureDir(tempDir);
+		if (!options.noEmptyDistDir) await fs.emptyDir(distDir);
+		await esbuild.build({
+			entryPoints: [mainFile],
+			bundle: true,
+			outfile: distMainFile,
+			platform: "node",
+			mainFields: ["module", "main"],
+			target: `node${process.version.slice(1)}`,
+			minify: options.minify ?? false,
+			format: "esm",
+			sourcemap: false,
+			treeShaking: true,
+			banner: { js: [...Object.keys(options.inlineEnvs || {}).map((key) => `process.env[${JSON.stringify(key)}]=${JSON.stringify(options.inlineEnvs[key])};`), `process.env["X_SERVER_ENVS"]=${JSON.stringify(JSON.stringify(options.inlineEnvs || {}))};`].join("\n") },
+			plugins: [{
+				name: "custom",
+				async setup(build) {
+					build.onLoad({ filter: /@dev[/.]/ }, async () => {
+						return {
+							contents: "module.exports = {}",
+							loader: "js"
+						};
+					});
+					if (options.excludeFiles?.length) {
+						const excludeRegExps = options.excludeFiles.map((item) => new RegExp(item));
+						build.onLoad({ filter: /\.ts$/ }, async (args) => {
+							if (excludeRegExps.some((re) => re.test(args.path))) return {
+								contents: "module.exports = {}",
+								loader: "js"
+							};
+						});
+					}
+				}
+			}, macrosPlugin()],
+			loader: { ".css": "empty" }
+		});
+		const prismaSchemaFile = path.join(options.cwd, "src/db/schema.prisma");
+		if (await fs.pathExists(prismaSchemaFile)) {
+			const distPrismaSchemaFile = path.join(distDir, path.basename(prismaSchemaFile));
+			await fs.copyFile(prismaSchemaFile, distPrismaSchemaFile);
+			const multipleSchemaDir = path.join(options.cwd, "src/db/schema");
+			if (await fs.pathExists(multipleSchemaDir)) {
+				const distMultipleSchemaDir = path.join(distDir, path.basename(multipleSchemaDir));
+				await fs.copy(multipleSchemaDir, distMultipleSchemaDir);
+			}
+		}
+		await fs.writeJson(distPkgFile, omitStrict(pkgContent, ["devDependencies", "scripts"]), { spaces: 2 });
+		const nvmrcFile = path.join(options.cwd, ".nvmrc");
+		const hasNvmrc = await fs.pathExists(nvmrcFile);
+		await fs.writeFile(distNvmrcFile, hasNvmrc ? await fs.readFile(nvmrcFile) : process.version.slice(1).split(".")[0]);
+		const npmrcFile = path.join(options.cwd, ".npmrc");
+		if (await fs.pathExists(npmrcFile)) await fs.copyFile(npmrcFile, distNpmrcFile);
+		const pnpmWorkspaceFile = path.join(options.cwd, "pnpm-workspace.yaml");
+		if (await fs.pathExists(pnpmWorkspaceFile)) await fs.copyFile(pnpmWorkspaceFile, distPnpmWorkspaceFile);
+		const pnpmLockFile = path.join(options.cwd, "pnpm-lock.yaml");
+		if (await fs.pathExists(pnpmLockFile)) await fs.copyFile(pnpmLockFile, distPnpmLockFile);
+		await fs.writeFile(distPm2File, dedent`
+        module.exports = {
+          apps: [
+            {
+              name: ${JSON.stringify(pkgContent.name)},
+              script: './main.js',
+              interpreter: 'node',
+              interpreter_args: ${JSON.stringify(options.pm2NodeArgs || [])},
+              env: {
+                PATH: \`\${require('child_process').execSync('fnm exec which node').toString().trim().replace(/\\/node$/, '')}:\${process.env.PATH}\`,
+              },
+              ${options.pm2MaxMemoryRestart ? `max_memory_restart: '${options.pm2MaxMemoryRestart}',` : ""}
+              ${options.pm2CronRestart ? `cron_restart: '${options.pm2CronRestart}',` : ""}
+            },
+          ],
+        }
+      `);
+		await compressing.tgz.compressDir(distDir, distBundleFile);
+	}
+};
+export { BuildUtil };

package/lib/cli/cli.d.mts

@@ -0,0 +1 @@
+export {}