nuxt-gin-tools 0.2.11 → 0.2.13

package/src/commands/builder.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const concurrently_1 = __importDefault(require("concurrently"));
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const cwd = process.cwd();
+function build() {
+    (0, fs_extra_1.ensureDirSync)((0, path_1.join)(cwd, "vue/.output"));
+    return (0, concurrently_1.default)([
+        {
+            command: "go build -o ./.build/.server/production.exe .",
+            name: "go",
+            prefixColor: "green",
+        },
+        {
+            command: "npx nuxt generate",
+            name: "nuxt",
+            prefixColor: "blue",
+        },
+    ]).result;
+}
+exports.default = build;

package/src/commands/cleanup.d.ts

@@ -0,0 +1,8 @@
+export declare function ifExistsRemove(relativePath: string): void;
+export declare function cleanUpNuxt(): Promise<import("concurrently").CloseEvent[]>;
+export declare function cleanUpBuild(): void;
+/**
+ * 清理构建目录和临时文件
+ */
+export declare function cleanUp(): Promise<void>;
+export default cleanUp;

package/src/commands/cleanup.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ifExistsRemove = ifExistsRemove;
+exports.cleanUpNuxt = cleanUpNuxt;
+exports.cleanUpBuild = cleanUpBuild;
+exports.cleanUp = cleanUp;
+const FS = __importStar(require("fs-extra"));
+const Path = __importStar(require("path"));
+const concurrently_1 = __importDefault(require("concurrently"));
+const chalk_1 = __importDefault(require("chalk"));
+const cwd = process.cwd();
+function ifExistsRemove(relativePath) {
+    const absolutePath = Path.resolve(cwd, relativePath);
+    if (FS.existsSync(absolutePath)) {
+        FS.removeSync(absolutePath);
+    }
+}
+function cleanUpNuxt() {
+    return (0, concurrently_1.default)([
+        {
+            command: "npx nuxt cleanup",
+        },
+    ]).result;
+}
+function cleanUpBuild() {
+    // 清理构建目录
+    ifExistsRemove(".build/production");
+    // 清理原始 dist 目录
+    ifExistsRemove("dist");
+    // 清理临时文件
+    ifExistsRemove(".build");
+    // 清理临时文件
+    ifExistsRemove("tmp");
+    // 清理 Vue 应用构建输出目录
+    ifExistsRemove("vue/.output");
+    // 清理 OpenAPI 生成的文件
+    ifExistsRemove(".openapi-generator");
+    // 清理go.sum
+    // ifExistsRemove("go.sum");
+}
+/**
+ * 清理构建目录和临时文件
+ */
+function cleanUp() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = cleanUpNuxt();
+        cleanUpBuild();
+        yield result;
+        console.log(chalk_1.default.bgGreen("----- 清理完成！-----"));
+    });
+}
+exports.default = cleanUp;

package/src/commands/dev-go.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 启动 Go 开发监听流程：执行 `go run main.go`，并在文件变更后自动重启。
+ *
+ * 该函数通常由 `develop()` 调用；执行后会持续监听，直到收到退出信号。
+ *
+ * @returns {Promise<void>} 仅在监听流程被中断并完成清理后返回。
+ */
+export declare function startGoDev(): Promise<void>;

package/src/commands/dev-go.js

@@ -0,0 +1,306 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startGoDev = startGoDev;
+const child_process_1 = require("child_process");
+const chokidar_1 = __importDefault(require("chokidar"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const utils_1 = require("../utils");
+const cwd = process.cwd();
+const RESTART_DEBOUNCE_MS = 150;
+const SHUTDOWN_TIMEOUT_MS = 2000;
+const LOG_TAG = "go-watch";
+const GO_WATCH_PREFIX = chalk_1.default.bgMagenta.white(`[${LOG_TAG}]`);
+const serverConfigPath = (0, path_1.join)(cwd, "server.config.json");
+const ginPort = getGinPort();
+function getGinPort() {
+    if (!(0, fs_extra_1.existsSync)(serverConfigPath)) {
+        return null;
+    }
+    try {
+        const serverConfig = (0, fs_extra_1.readJSONSync)(serverConfigPath);
+        if (Number.isInteger(serverConfig.ginPort) && serverConfig.ginPort > 0) {
+            return serverConfig.ginPort;
+        }
+    }
+    catch (_a) {
+        // best effort
+    }
+    return null;
+}
+function killGinPortIfNeeded() {
+    if (!ginPort) {
+        return;
+    }
+    (0, utils_1.killPort)(ginPort, { logPrefix: LOG_TAG, portLabel: "ginPort" });
+}
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function toProjectRelative(filePath) {
+    const abs = (0, path_1.isAbsolute)(filePath) ? filePath : (0, path_1.resolve)(cwd, filePath);
+    return normalizePath((0, path_1.relative)(cwd, abs));
+}
+function toStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function toStringValue(value) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    return value.trim();
+}
+function loadWatchConfig() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const defaultConfig = {
+        includeExt: new Set(["go"]),
+        includeDir: [],
+        includeFile: new Set(),
+        excludeDir: [".git", "node_modules", "vendor", "vue"],
+        excludeFile: new Set(),
+        excludeRegex: [/_test\.go$/],
+        tmpDir: ".build/.server",
+        testDataDir: "testdata",
+    };
+    const candidates = [
+        process.env.NUXT_GIN_WATCH_CONFIG,
+        (0, path_1.join)(cwd, "node_modules/nuxt-gin-tools/.go-watch.json"),
+        (0, path_1.join)(cwd, ".go-watch.json"),
+        (0, path_1.join)(__dirname, "..", ".go-watch.json"),
+        (0, path_1.join)(__dirname, "..", "..", ".go-watch.json"),
+    ].filter((item) => Boolean(item));
+    const configPath = candidates.find((item) => (0, fs_extra_1.existsSync)(item));
+    if (!configPath) {
+        return defaultConfig;
+    }
+    let parsedConfig = {};
+    try {
+        parsedConfig = JSON.parse((0, fs_extra_1.readFileSync)(configPath, "utf-8"));
+    }
+    catch (_j) {
+        console.warn(`${GO_WATCH_PREFIX} invalid watch config JSON, fallback to defaults: ${configPath}`);
+        return defaultConfig;
+    }
+    const includeExt = toStringArray((_a = parsedConfig.includeExt) !== null && _a !== void 0 ? _a : parsedConfig.include_ext)
+        .map((item) => item.replace(/^\./, ""))
+        .filter((item) => /^[a-zA-Z0-9]+$/.test(item));
+    const includeDir = toStringArray((_b = parsedConfig.includeDir) !== null && _b !== void 0 ? _b : parsedConfig.include_dir)
+        .map((item) => normalizePath(item))
+        .filter(Boolean);
+    const includeFile = toStringArray((_c = parsedConfig.includeFile) !== null && _c !== void 0 ? _c : parsedConfig.include_file)
+        .map((item) => normalizePath(item))
+        .filter(Boolean);
+    const excludeDir = toStringArray((_d = parsedConfig.excludeDir) !== null && _d !== void 0 ? _d : parsedConfig.exclude_dir)
+        .map((item) => normalizePath(item))
+        .filter(Boolean);
+    const excludeFile = toStringArray((_e = parsedConfig.excludeFile) !== null && _e !== void 0 ? _e : parsedConfig.exclude_file)
+        .map((item) => normalizePath(item))
+        .filter(Boolean);
+    const excludeRegex = toStringArray((_f = parsedConfig.excludeRegex) !== null && _f !== void 0 ? _f : parsedConfig.exclude_regex)
+        .map((item) => {
+        try {
+            return new RegExp(item);
+        }
+        catch (_a) {
+            return null;
+        }
+    })
+        .filter((item) => item instanceof RegExp);
+    const tmpDir = normalizePath(toStringValue((_g = parsedConfig.tmpDir) !== null && _g !== void 0 ? _g : parsedConfig.tmp_dir) || defaultConfig.tmpDir);
+    const testdataDir = normalizePath(toStringValue((_h = parsedConfig.testDataDir) !== null && _h !== void 0 ? _h : parsedConfig.testdata_dir) ||
+        defaultConfig.testDataDir);
+    return {
+        includeExt: new Set(includeExt.length ? includeExt : [...defaultConfig.includeExt]),
+        includeDir,
+        includeFile: new Set(includeFile),
+        excludeDir: [...new Set([...defaultConfig.excludeDir, ...excludeDir, tmpDir, testdataDir])],
+        excludeFile: new Set(excludeFile),
+        excludeRegex: excludeRegex.length ? excludeRegex : defaultConfig.excludeRegex,
+        tmpDir,
+        testDataDir: testdataDir,
+    };
+}
+function pathInDir(relPath, dir) {
+    const normalizedDir = normalizePath(dir).replace(/\/+$/, "");
+    return relPath === normalizedDir || relPath.startsWith(`${normalizedDir}/`);
+}
+function shouldIgnore(relPath, config) {
+    if (!relPath || relPath === ".") {
+        return false;
+    }
+    if (config.excludeFile.has(relPath)) {
+        return true;
+    }
+    if (config.excludeDir.some((dir) => pathInDir(relPath, dir))) {
+        return true;
+    }
+    return config.excludeRegex.some((reg) => reg.test(relPath));
+}
+function shouldTrigger(relPath, config) {
+    if (shouldIgnore(relPath, config)) {
+        return false;
+    }
+    const ext = (0, path_1.extname)(relPath).replace(/^\./, "");
+    const inIncludedFile = config.includeFile.has(relPath);
+    if (config.includeDir.length > 0) {
+        const inIncludedDir = config.includeDir.some((dir) => pathInDir(relPath, dir));
+        if (!inIncludedDir && !inIncludedFile) {
+            return false;
+        }
+    }
+    if (inIncludedFile) {
+        return true;
+    }
+    if (!ext) {
+        return false;
+    }
+    return config.includeExt.has(ext);
+}
+function quote(arg) {
+    if (/\s/.test(arg)) {
+        return `"${arg.replace(/"/g, '\\"')}"`;
+    }
+    return arg;
+}
+function runGoProcess() {
+    const command = `go run ${quote("main.go")}`;
+    killGinPortIfNeeded();
+    console.log(`${GO_WATCH_PREFIX} start: ${command}`);
+    return (0, child_process_1.spawn)(command, {
+        cwd,
+        shell: true,
+        stdio: "inherit",
+    });
+}
+function stopGoProcess(proc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!proc || proc.killed || proc.exitCode !== null) {
+            return;
+        }
+        yield new Promise((resolveStop) => {
+            let finished = false;
+            const done = () => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                resolveStop();
+            };
+            const timer = setTimeout(() => {
+                try {
+                    proc.kill("SIGKILL");
+                }
+                catch (_a) {
+                    // best effort
+                }
+                done();
+            }, SHUTDOWN_TIMEOUT_MS);
+            proc.once("exit", () => {
+                clearTimeout(timer);
+                done();
+            });
+            try {
+                proc.kill("SIGTERM");
+            }
+            catch (_a) {
+                clearTimeout(timer);
+                done();
+            }
+        });
+    });
+}
+/**
+ * 启动 Go 开发监听流程：执行 `go run main.go`，并在文件变更后自动重启。
+ *
+ * 该函数通常由 `develop()` 调用；执行后会持续监听，直到收到退出信号。
+ *
+ * @returns {Promise<void>} 仅在监听流程被中断并完成清理后返回。
+ */
+function startGoDev() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const watchConfig = loadWatchConfig();
+        const watchRoots = watchConfig.includeDir.length
+            ? watchConfig.includeDir.map((dir) => (0, path_1.join)(cwd, dir))
+            : [cwd];
+        console.log(`${GO_WATCH_PREFIX} watching: ${watchRoots.map((item) => toProjectRelative(item)).join(", ")}`);
+        let restarting = false;
+        let goProc = runGoProcess();
+        let restartTimer = null;
+        const watcher = chokidar_1.default.watch(watchRoots, {
+            ignoreInitial: true,
+            ignored: (pathName) => shouldIgnore(toProjectRelative(pathName), watchConfig),
+            awaitWriteFinish: {
+                stabilityThreshold: 120,
+                pollInterval: 20,
+            },
+        });
+        const triggerRestart = (eventName, changedPath) => {
+            const relPath = toProjectRelative(changedPath);
+            if (!shouldTrigger(relPath, watchConfig)) {
+                return;
+            }
+            if (restartTimer) {
+                clearTimeout(restartTimer);
+            }
+            restartTimer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                if (restarting) {
+                    return;
+                }
+                restarting = true;
+                console.log(`${GO_WATCH_PREFIX} ${eventName}: ${relPath}, restarting...`);
+                yield stopGoProcess(goProc);
+                goProc = runGoProcess();
+                restarting = false;
+            }), RESTART_DEBOUNCE_MS);
+        };
+        watcher
+            .on("add", (filePath) => triggerRestart("add", filePath))
+            .on("change", (filePath) => triggerRestart("change", filePath))
+            .on("unlink", (filePath) => triggerRestart("unlink", filePath))
+            .on("error", (error) => {
+            console.error(`${GO_WATCH_PREFIX} watcher error: ${String(error)}`);
+        });
+        const shutdown = () => __awaiter(this, void 0, void 0, function* () {
+            if (restartTimer) {
+                clearTimeout(restartTimer);
+                restartTimer = null;
+            }
+            yield watcher.close();
+            yield stopGoProcess(goProc);
+        });
+        process.on("SIGINT", () => __awaiter(this, void 0, void 0, function* () {
+            yield shutdown();
+            process.exit(0);
+        }));
+        process.on("SIGTERM", () => __awaiter(this, void 0, void 0, function* () {
+            yield shutdown();
+            process.exit(0);
+        }));
+    });
+}
+if (require.main === module) {
+    // 兼容直接执行该文件（例如 node src/dev-go.js）。
+    startGoDev().catch((error) => {
+        console.error(`${GO_WATCH_PREFIX} failed to start: ${String(error)}`);
+        process.exit(1);
+    });
+}

package/src/commands/develop.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 启动本地开发环境。
+ *
+ * 行为包括：按配置执行预清理、释放开发端口、并行启动 Nuxt 与 Go 监听流程。
+ *
+ * @returns {Promise<void>} 仅在开发进程退出或出现异常时返回。
+ */
+export declare function develop(): Promise<void>;
+/**
+ * 仅启动 Nuxt 开发服务（带 nuxt 标签输出）。
+ *
+ * @returns {Promise<void>} 仅在开发进程退出或出现异常时返回。
+ */
+export declare function developNuxt(): Promise<void>;
+/**
+ * 仅启动 Go 开发监听流程。
+ *
+ * @returns {Promise<void>} 仅在开发进程退出或出现异常时返回。
+ */
+export declare function developGo(): Promise<void>;
+export default develop;

package/src/commands/develop.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.develop = develop;
+exports.developNuxt = developNuxt;
+exports.developGo = developGo;
+const concurrently_1 = __importDefault(require("concurrently"));
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const cleanup_1 = __importDefault(require("./cleanup"));
+const postinstall_1 = __importDefault(require("./postinstall"));
+const dev_go_1 = require("./dev-go");
+const utils_1 = require("../utils");
+const cwd = process.cwd();
+const serverConfig = (0, fs_extra_1.readJSONSync)((0, path_1.join)(cwd, "server.config.json"));
+function prepareDevelop() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cleanupBeforeDevelop = serverConfig.cleanupBeforeDevelop === true;
+        if (cleanupBeforeDevelop) {
+            yield (0, cleanup_1.default)();
+            yield (0, postinstall_1.default)();
+            return;
+        }
+        if (!(0, fs_extra_1.existsSync)((0, path_1.join)(cwd, "vue/.nuxt")) || !(0, fs_extra_1.existsSync)((0, path_1.join)(cwd, "go.sum"))) {
+            yield (0, cleanup_1.default)();
+            yield (0, postinstall_1.default)();
+        }
+    });
+}
+function runNuxtDev() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, concurrently_1.default)([
+            {
+                command: `npx nuxt dev --port=${serverConfig.nuxtPort} --host`,
+                name: "nuxt",
+                prefixColor: "blue",
+            },
+        ]).result;
+    });
+}
+function runGoDev() {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, fs_extra_1.ensureDirSync)((0, path_1.join)(cwd, ".build/.server"));
+        yield (0, dev_go_1.startGoDev)();
+    });
+}
+/**
+ * 启动本地开发环境。
+ *
+ * 行为包括：按配置执行预清理、释放开发端口、并行启动 Nuxt 与 Go 监听流程。
+ *
+ * @returns {Promise<void>} 仅在开发进程退出或出现异常时返回。
+ */
+function develop() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const killPortBeforeDevelop = serverConfig.killPortBeforeDevelop !== false;
+        yield prepareDevelop();
+        // 在开发前确保占用端口被释放
+        if (killPortBeforeDevelop) {
+            (0, utils_1.killPorts)([serverConfig.ginPort, serverConfig.nuxtPort]);
+        }
+        yield Promise.all([runGoDev(), runNuxtDev()]);
+    });
+}
+/**
+ * 仅启动 Nuxt 开发服务（带 nuxt 标签输出）。
+ *
+ * @returns {Promise<void>} 仅在开发进程退出或出现异常时返回。
+ */
+function developNuxt() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const killPortBeforeDevelop = serverConfig.killPortBeforeDevelop !== false;
+        yield prepareDevelop();
+        if (killPortBeforeDevelop) {
+            (0, utils_1.killPorts)([serverConfig.nuxtPort]);
+        }
+        yield runNuxtDev();
+    });
+}
+/**
+ * 仅启动 Go 开发监听流程。
+ *
+ * @returns {Promise<void>} 仅在开发进程退出或出现异常时返回。
+ */
+function developGo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const killPortBeforeDevelop = serverConfig.killPortBeforeDevelop !== false;
+        yield prepareDevelop();
+        if (killPortBeforeDevelop) {
+            (0, utils_1.killPorts)([serverConfig.ginPort]);
+        }
+        yield runGoDev();
+    });
+}
+exports.default = develop;

package/src/commands/pack.d.ts

@@ -0,0 +1,82 @@
+export interface PackConfig {
+    /**
+     * 额外需要打包的文件映射
+     * key: 源文件路径（相对于项目根目录或绝对路径）
+     * value: 打包后对应位置（相对于服务器构建目录或绝对路径）
+     */
+    extraFiles?: Record<string, string>;
+    /**
+     * 额外需要打包的文件 Glob（相对于项目根目录）
+     */
+    extraFilesGlobs?: string[];
+    /**
+     * 排除文件/目录 Glob（相对于项目根目录）
+     */
+    exclude?: string[];
+    /**
+     * 打包输出 zip 名称（相对于默认 zip 目录）
+     */
+    zipName?: string;
+    /**
+     * 打包输出 zip 路径（相对于项目根目录或绝对路径）
+     */
+    zipPath?: string;
+    /**
+     * 服务器构建输出目录（相对于项目根目录或绝对路径）
+     */
+    serverPath?: string;
+    /**
+     * 打包前钩子
+     */
+    beforePack?: () => Promise<void> | void;
+    /**
+     * 打包后钩子
+     */
+    afterPack?: (zipPath: string) => Promise<void> | void;
+    /**
+     * 是否清理 dist
+     */
+    cleanDist?: boolean;
+    /**
+     * 是否写入启动脚本和 package.json
+     */
+    writeScripts?: boolean;
+    /**
+     * 写入/覆盖 package.json 内容
+     */
+    packageJson?: Record<string, unknown>;
+    /**
+     * 复制时是否覆盖同名文件
+     */
+    overwrite?: boolean;
+}
+/**
+ * 生成相对于服务器构建目录的绝对路径
+ * @param relativePath - 相对路径
+ * @returns 解析后的绝对路径
+ */
+export declare function builtPath(relativePath: string): string;
+export declare const ZIP_PATH: string;
+export declare const SERVER_PATH: string;
+export declare const ORIGINAL_DIST_PATH: string;
+export declare const PACK_CONFIG_PATH: string;
+export declare const SERVER_EXECUTABLE: string;
+export declare const PACKAGE_JSON_CONTENT: {
+    private: boolean;
+    scripts: {
+        start: string;
+    };
+};
+export declare const FILES_TO_COPY: {
+    [k: string]: string;
+};
+/**
+ * 构建并打包项目的主函数
+ * 1. 执行项目构建
+ * 2. 复制生成的文件
+ * 3. 写入启动脚本
+ * 4. 打包文件为 7z 格式
+ * 5. 清理原始 dist 目录
+ */
+export declare function buildAndPack(config?: PackConfig): Promise<void>;
+export default buildAndPack;