nuxt-gin-tools 0.2.11 → 0.2.12

package/commands/api-generate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 警告：本文件是API生成框架的一部分，请勿手动修改！
+ * 任何修改可能会被自动化流程覆盖。
+ * 如需调整生成逻辑，请修改相关配置文件或脚本。
+ */
+/**
+ * 主函数
+ * 协调执行所有任务：生成代码、删除路径、配置Vue API
+ */
+export declare function apiGenerate(): Promise<void>;
+export default apiGenerate;

package/commands/api-generate.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * 警告：本文件是API生成框架的一部分，请勿手动修改！
+ * 任何修改可能会被自动化流程覆盖。
+ * 如需调整生成逻辑，请修改相关配置文件或脚本。
+ */
+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.apiGenerate = apiGenerate;
+const chalk_1 = __importDefault(require("chalk"));
+const concurrently_1 = __importDefault(require("concurrently")); // 用于并发执行命令的工具
+const fs_extra_1 = __importDefault(require("fs-extra")); // 文件系统操作工具，提供更便捷的API
+const path_1 = __importDefault(require("path")); // 处理和转换文件路径的工具
+const cwd = process.cwd(); // 获取当前工作目录
+/**
+ * 要执行的命令列表
+ * 包含OpenAPI代码生成命令：
+ * 1. 生成Go Gin服务器代码
+ * 2. 生成TypeScript Axios客户端代码
+ */
+let commands = [
+    {
+        command: "openapi-generator-cli generate -i openapi.yaml -g go-gin-server -c node_modules/nuxt-gin-tools/src/go-gin-server.json -o .",
+        name: "go",
+        prefixColor: "green",
+    },
+    {
+        command: "openapi-generator-cli generate -i openapi.yaml -g typescript-axios -o vue/composables/api ",
+        name: "vue",
+        prefixColor: "blue",
+    },
+];
+/**
+ * 执行完成后需要删除的路径列表
+ */
+const pathsToDelete = ["api"];
+/**
+ * 设置Vue API客户端的基础URL
+ * 修改TypeScript axios生成的base.ts文件，将BASE_PATH设置为相对路径
+ * @returns {Promise<string>} 返回原始文件内容的Promise
+ */
+function setVueBaseUrl() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // 构建Vue API运行时配置文件的完整路径
+            const VUE_API_RUNTIME_PATH = path_1.default.join(cwd, "vue/composables/api/base.ts");
+            // 读取原始文件内容
+            const originalContent = yield fs_extra_1.default.readFile(VUE_API_RUNTIME_PATH, "utf-8");
+            // 使用正则表达式替换BASE_PATH常量，移除协议和域名部分，使其成为相对路径
+            // 匹配类似 "export const BASE_PATH = "https://example.com"" 这样的行
+            const updatedContent = originalContent.replace(/export\s+const\s+BASE_PATH = "https?:\/\/[^/]+/, `export const BASE_PATH = "`);
+            // 将修改后的内容写回文件
+            yield fs_extra_1.default.outputFile(VUE_API_RUNTIME_PATH, updatedContent, "utf-8");
+            console.log("成功更新Vue API基础URL为相对路径");
+            return;
+        }
+        catch (error) {
+            console.error("更新Vue API基础URL失败:", error);
+            throw error; // 将错误继续抛出，以便上层处理
+        }
+    });
+}
+function setGoRoutes() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const GO_API_RUNTIME_PATH = path_1.default.join(cwd, "server/api/routers.go");
+        const originalContent = yield fs_extra_1.default.readFile(GO_API_RUNTIME_PATH, "utf-8");
+        const updatedContent = originalContent.replace(/getRoutes/g, "GetRoutes");
+        // overwrite
+        yield fs_extra_1.default.outputFile(GO_API_RUNTIME_PATH, updatedContent, "utf-8");
+    });
+}
+/**
+ * 删除指定的路径
+ * 用于清理生成过程中产生的临时或不需要的文件和目录
+ */
+function removePaths() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // 遍历要删除的路径列表
+            for (const path of pathsToDelete) {
+                // 构建完整路径
+                const fullPath = path_1.default.join(cwd, path);
+                // 删除路径（文件或目录）
+                yield fs_extra_1.default.remove(fullPath);
+                console.log(`成功删除路径: ${fullPath}`);
+            }
+        }
+        catch (error) {
+            console.error("删除路径失败:", error);
+            throw error; // 将错误继续抛出
+        }
+    });
+}
+/**
+ * 主函数
+ * 协调执行所有任务：生成代码、删除路径、配置Vue API
+ */
+function apiGenerate() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // 输出开始信息
+            console.log(chalk_1.default.bgGreen("开始生成API代码..."));
+            // 并发执行命令列表中的所有命令，等待所有命令完成
+            yield (0, concurrently_1.default)(commands).result;
+            // 按顺序执行清理和配置任务
+            let tasks = [];
+            tasks.push(removePaths());
+            tasks.push(setVueBaseUrl());
+            tasks.push(setGoRoutes());
+            yield Promise.all(tasks);
+            console.log(chalk_1.default.bgGreen("API代码生成和配置完成!"));
+        }
+        catch (error) {
+            // 捕获并处理任何阶段发生的错误
+            console.error(chalk_1.default.red("执行过程中发生错误:"), error);
+            // 以错误码1退出进程，表示执行失败
+            process.exit(1);
+        }
+    });
+}
+// 执行主函数
+exports.default = apiGenerate;

package/commands/builder.d.ts

@@ -0,0 +1,2 @@
+export declare function build(): Promise<import("concurrently").CloseEvent[]>;
+export default build;

package/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/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/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/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/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("../src/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/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;