nuxt-gin-tools 0.2.22 → 0.3.0

package/src/services/pack-service.js

@@ -0,0 +1,372 @@
+"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.FILES_TO_COPY = exports.PACKAGE_JSON_CONTENT = exports.SERVER_EXECUTABLE = exports.BUILD_EXECUTABLE = exports.LEGACY_PACK_CONFIG_MJS_PATH = exports.LEGACY_PACK_CONFIG_CJS_PATH = exports.LEGACY_PACK_CONFIG_JS_PATH = exports.LEGACY_PACK_CONFIG_TS_PATH = exports.LEGACY_PACK_CONFIG_PATH = exports.ORIGINAL_DIST_PATH = exports.SERVER_PATH = exports.ZIP_PATH = void 0;
+exports.builtPath = builtPath;
+exports.buildAndPack = buildAndPack;
+const build_service_1 = __importDefault(require("./build-service"));
+const Zip = __importStar(require("7zip-min"));
+const FS = __importStar(require("fs-extra"));
+const Path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const nuxt_gin_1 = require("../nuxt-gin");
+const terminal_ui_1 = require("../cli/terminal-ui");
+const { createJiti } = require("jiti");
+function builtPath(relativePath) {
+    return Path.resolve(exports.SERVER_PATH, relativePath);
+}
+exports.ZIP_PATH = Path.resolve(process.cwd(), ".build/production/server.7z");
+exports.SERVER_PATH = Path.resolve(process.cwd(), ".build/production/server");
+exports.ORIGINAL_DIST_PATH = Path.resolve(process.cwd(), "dist");
+exports.LEGACY_PACK_CONFIG_PATH = Path.resolve(process.cwd(), "pack.config.json");
+exports.LEGACY_PACK_CONFIG_TS_PATH = Path.resolve(process.cwd(), "pack.config.ts");
+exports.LEGACY_PACK_CONFIG_JS_PATH = Path.resolve(process.cwd(), "pack.config.js");
+exports.LEGACY_PACK_CONFIG_CJS_PATH = Path.resolve(process.cwd(), "pack.config.cjs");
+exports.LEGACY_PACK_CONFIG_MJS_PATH = Path.resolve(process.cwd(), "pack.config.mjs");
+exports.BUILD_EXECUTABLE = os.platform() === "win32" ? "production.exe" : "production";
+exports.SERVER_EXECUTABLE = os.platform() === "win32" ? "server-production.exe" : "server-production";
+exports.PACKAGE_JSON_CONTENT = {
+    private: true,
+    scripts: {
+        start: `./${exports.SERVER_EXECUTABLE}`,
+    },
+};
+const DEFAULT_FILES_TO_COPY = {
+    "vue/.output": "vue/.output",
+    [`.build/.server/${exports.BUILD_EXECUTABLE}`]: exports.SERVER_EXECUTABLE,
+};
+exports.FILES_TO_COPY = Object.fromEntries(Object.entries(DEFAULT_FILES_TO_COPY).map(([src, dest]) => [src, builtPath(dest)]));
+function warnPackConfig(message) {
+    (0, terminal_ui_1.printCommandWarn)(`[pack] ${message}`);
+}
+function errorPackConfig(message) {
+    throw new Error(`[nuxt-gin-tools][pack] ${message}`);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateStringArray(fieldName, value, issues) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        issues.push({ level: "error", message: `${fieldName} must be an array of strings` });
+        return;
+    }
+    for (const item of value) {
+        if (typeof item !== "string") {
+            issues.push({ level: "error", message: `${fieldName} must contain only strings` });
+            return;
+        }
+    }
+}
+function validateStringRecord(fieldName, value, issues) {
+    if (value === undefined) {
+        return;
+    }
+    if (!isPlainObject(value)) {
+        issues.push({ level: "error", message: `${fieldName} must be an object of string to string` });
+        return;
+    }
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof key !== "string" || typeof item !== "string") {
+            issues.push({ level: "error", message: `${fieldName} must be an object of string to string` });
+            return;
+        }
+    }
+}
+function validatePackConfig(config, sourcePath) {
+    if (!isPlainObject(config)) {
+        errorPackConfig(`${Path.basename(sourcePath)} must export an object`);
+    }
+    const issues = [];
+    const typedConfig = config;
+    const stringFields = ["binaryName", "zipName", "zipPath", "serverPath"];
+    for (const field of stringFields) {
+        const value = typedConfig[field];
+        if (value !== undefined && typeof value !== "string") {
+            issues.push({ level: "error", message: `${field} must be a string` });
+        }
+    }
+    const booleanFields = [
+        "skipGo",
+        "skipNuxt",
+        "skipBuild",
+        "skipZip",
+        "cleanDist",
+        "writeScripts",
+        "overwrite",
+    ];
+    for (const field of booleanFields) {
+        const value = typedConfig[field];
+        if (value !== undefined && typeof value !== "boolean") {
+            issues.push({ level: "error", message: `${field} must be a boolean` });
+        }
+    }
+    validateStringArray("extraFilesGlobs", typedConfig.extraFilesGlobs, issues);
+    validateStringArray("exclude", typedConfig.exclude, issues);
+    validateStringRecord("extraFiles", typedConfig.extraFiles, issues);
+    if (typedConfig.packageJson !== undefined && !isPlainObject(typedConfig.packageJson)) {
+        issues.push({ level: "error", message: `packageJson must be an object` });
+    }
+    if (typedConfig.beforePack !== undefined && typeof typedConfig.beforePack !== "function") {
+        issues.push({ level: "error", message: `beforePack must be a function` });
+    }
+    if (typedConfig.afterPack !== undefined && typeof typedConfig.afterPack !== "function") {
+        issues.push({ level: "error", message: `afterPack must be a function` });
+    }
+    if (typedConfig.zipName !== undefined && typedConfig.zipPath !== undefined) {
+        issues.push({ level: "warn", message: `zipPath and zipName are both set; zipPath takes precedence` });
+    }
+    if (typedConfig.skipGo === true && typedConfig.skipNuxt === true) {
+        issues.push({ level: "warn", message: `skipGo and skipNuxt are both true; build step will be skipped` });
+    }
+    if (typedConfig.skipBuild === true && typedConfig.skipZip === true) {
+        issues.push({ level: "warn", message: `skipBuild and skipZip are both true; only bundle assembly will run` });
+    }
+    for (const issue of issues) {
+        if (issue.level === "warn") {
+            warnPackConfig(`${Path.basename(sourcePath)}: ${issue.message}`);
+        }
+    }
+    const errors = issues.filter((issue) => issue.level === "error");
+    if (errors.length > 0) {
+        errorPackConfig(`${Path.basename(sourcePath)} is invalid:\n- ${errors.map((item) => item.message).join("\n- ")}`);
+    }
+    return config;
+}
+function writeScriptFiles(serverPath, config) {
+    FS.outputFileSync(Path.resolve(serverPath, "start.bat"), `powershell -ExecutionPolicy ByPass -File ./start.ps1`);
+    FS.outputFileSync(Path.resolve(serverPath, "start.ps1"), `./${exports.SERVER_EXECUTABLE}`);
+    FS.outputFileSync(Path.resolve(serverPath, "start.sh"), `./${exports.SERVER_EXECUTABLE}`);
+    const mergedPackageJson = mergePackageJson(exports.PACKAGE_JSON_CONTENT, config === null || config === void 0 ? void 0 : config.packageJson);
+    FS.outputJSONSync(Path.resolve(serverPath, "package.json"), mergedPackageJson, { spaces: 2 });
+}
+function writeServerConfigFile(serverPath) {
+    const resolvedDest = Path.resolve(serverPath, "server.config.json");
+    const projectServerConfigPath = Path.resolve(process.cwd(), "server.config.json");
+    if (FS.existsSync(projectServerConfigPath)) {
+        FS.copySync(projectServerConfigPath, resolvedDest);
+        return;
+    }
+    throw new Error("server.config.json is required for packaging output");
+}
+function copyGeneratedFiles(serverPath, config) {
+    var _a;
+    const copyOptions = {
+        overwrite: (config === null || config === void 0 ? void 0 : config.overwrite) !== false,
+        errorOnExist: (config === null || config === void 0 ? void 0 : config.overwrite) === false,
+    };
+    for (const [src, dest] of Object.entries(DEFAULT_FILES_TO_COPY)) {
+        const resolvedDest = Path.resolve(serverPath, dest);
+        FS.copySync(Path.resolve(process.cwd(), src), resolvedDest, copyOptions);
+    }
+    if (config === null || config === void 0 ? void 0 : config.extraFiles) {
+        for (const [src, dest] of Object.entries(config.extraFiles)) {
+            const resolvedSrc = Path.resolve(process.cwd(), src);
+            const resolvedDest = Path.isAbsolute(dest) ? dest : Path.resolve(serverPath, dest);
+            FS.copySync(resolvedSrc, resolvedDest, copyOptions);
+        }
+    }
+    if ((_a = config === null || config === void 0 ? void 0 : config.extraFilesGlobs) === null || _a === void 0 ? void 0 : _a.length) {
+        const matchedFiles = fast_glob_1.default.sync(config.extraFilesGlobs, {
+            cwd: process.cwd(),
+            onlyFiles: true,
+            dot: true,
+            ignore: config.exclude,
+        });
+        for (const file of matchedFiles) {
+            const resolvedSrc = Path.resolve(process.cwd(), file);
+            const resolvedDest = Path.resolve(serverPath, file);
+            FS.copySync(resolvedSrc, resolvedDest, copyOptions);
+        }
+    }
+    writeServerConfigFile(serverPath);
+}
+function mergePackageJson(base, override) {
+    if (!override) {
+        return base;
+    }
+    const baseScripts = typeof base.scripts === "object" && base.scripts ? base.scripts : {};
+    const overrideScripts = typeof override.scripts === "object" && override.scripts ? override.scripts : {};
+    return Object.assign(Object.assign(Object.assign({}, base), override), { scripts: Object.assign(Object.assign({}, baseScripts), overrideScripts) });
+}
+function readPackConfigFromCwd() {
+    const candidates = [
+        exports.LEGACY_PACK_CONFIG_TS_PATH,
+        exports.LEGACY_PACK_CONFIG_JS_PATH,
+        exports.LEGACY_PACK_CONFIG_CJS_PATH,
+        exports.LEGACY_PACK_CONFIG_MJS_PATH,
+        exports.LEGACY_PACK_CONFIG_PATH,
+    ].filter((configPath) => FS.existsSync(configPath));
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    if (candidates.length > 1) {
+        warnPackConfig(`multiple legacy pack config files found (${candidates.map((item) => Path.basename(item)).join(", ")}); using ${Path.basename(candidates[0])}`);
+    }
+    const selectedPath = candidates[0];
+    let loadedConfig;
+    if (selectedPath.endsWith(".json")) {
+        loadedConfig = FS.readJSONSync(selectedPath);
+    }
+    else {
+        const jiti = createJiti(__filename, { moduleCache: false, interopDefault: true });
+        loadedConfig = jiti(selectedPath);
+    }
+    const normalizedConfig = isPlainObject(loadedConfig) && "default" in loadedConfig
+        ? loadedConfig.default
+        : loadedConfig;
+    return validatePackConfig(normalizedConfig, selectedPath);
+}
+function resolveServerPath(config) {
+    if (!(config === null || config === void 0 ? void 0 : config.serverPath)) {
+        return exports.SERVER_PATH;
+    }
+    return Path.isAbsolute(config.serverPath)
+        ? config.serverPath
+        : Path.resolve(process.cwd(), config.serverPath);
+}
+function resolveZipPath(config) {
+    if (config === null || config === void 0 ? void 0 : config.zipPath) {
+        return Path.isAbsolute(config.zipPath)
+            ? config.zipPath
+            : Path.resolve(process.cwd(), config.zipPath);
+    }
+    if (config === null || config === void 0 ? void 0 : config.zipName) {
+        return Path.resolve(Path.dirname(exports.ZIP_PATH), config.zipName);
+    }
+    return exports.ZIP_PATH;
+}
+function makeZip(serverPath, zipPath) {
+    return new Promise((resolve, reject) => {
+        Zip.pack(serverPath, zipPath, (error) => {
+            if (error) {
+                (0, terminal_ui_1.printCommandError)("打包失败", error);
+                reject(error);
+                return;
+            }
+            (0, terminal_ui_1.printCommandSuccess)("pack", `archive ready: ${zipPath}`);
+            resolve(zipPath);
+        });
+    });
+}
+function cleanUp(config) {
+    if ((config === null || config === void 0 ? void 0 : config.cleanDist) === false) {
+        return;
+    }
+    if (FS.existsSync(exports.ORIGINAL_DIST_PATH)) {
+        FS.removeSync(exports.ORIGINAL_DIST_PATH);
+    }
+}
+function buildAndPack(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        (0, terminal_ui_1.printCommandBanner)("build", "Build project artifacts and pack deployment bundle");
+        const projectConfig = (0, nuxt_gin_1.resolveNuxtGinProjectConfig)();
+        for (const warning of projectConfig.warnings) {
+            (0, terminal_ui_1.printCommandWarn)(`[config] ${warning}`);
+        }
+        const actions = [];
+        const legacyPackConfig = readPackConfigFromCwd();
+        if (!projectConfig.config.pack && legacyPackConfig) {
+            (0, terminal_ui_1.printCommandWarn)("[config] using legacy pack.config.* fallback; migrate to nuxt-gin.config.ts");
+        }
+        const resolvedConfig = (0, nuxt_gin_1.mergeDefined)((_a = projectConfig.config.pack) !== null && _a !== void 0 ? _a : legacyPackConfig, config);
+        if (!(0, nuxt_gin_1.readLegacyServerConfig)()) {
+            throw new Error("server.config.json is required in project root before running build");
+        }
+        const serverPath = resolveServerPath(resolvedConfig);
+        const zipPath = resolveZipPath(resolvedConfig);
+        if (!(resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.skipBuild)) {
+            yield (0, build_service_1.default)(resolvedConfig);
+            actions.push("built project artifacts");
+        }
+        else {
+            (0, terminal_ui_1.printCommandInfo)("build", "skipping build step");
+            actions.push("skipped build step");
+        }
+        if (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.beforePack) {
+            yield resolvedConfig.beforePack();
+            actions.push("ran beforePack hook");
+        }
+        copyGeneratedFiles(serverPath, resolvedConfig);
+        actions.push(`assembled bundle in ${serverPath}`);
+        if ((resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.writeScripts) !== false) {
+            writeScriptFiles(serverPath, resolvedConfig);
+            actions.push("wrote startup scripts and package.json");
+        }
+        else {
+            actions.push("skipped startup script generation");
+        }
+        if (!(resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.skipZip)) {
+            yield makeZip(serverPath, zipPath);
+            (0, terminal_ui_1.printCommandInfo)("pack", `7z archive: ${zipPath}`);
+            actions.push(`created 7z archive at ${zipPath}`);
+        }
+        else {
+            (0, terminal_ui_1.printCommandInfo)("pack", "skipping 7z archive step");
+            actions.push("skipped 7z archive step");
+        }
+        (0, terminal_ui_1.printCommandInfo)("pack", `bundle dir: ${serverPath}`);
+        if (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.afterPack) {
+            yield resolvedConfig.afterPack(zipPath);
+            actions.push("ran afterPack hook");
+        }
+        cleanUp(resolvedConfig);
+        if ((resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.cleanDist) === false) {
+            actions.push("kept dist directory by configuration");
+        }
+        else {
+            actions.push("cleaned dist directory");
+        }
+        (0, terminal_ui_1.printCommandSuccess)("build", "Build and pack completed");
+        (0, terminal_ui_1.printCommandSummary)("build", actions);
+    });
+}
+exports.default = buildAndPack;

package/src/system/ports.d.ts

@@ -0,0 +1,7 @@
+type KillPortOptions = {
+    logPrefix?: string;
+    portLabel?: string;
+};
+export declare function killPort(port: number, options?: KillPortOptions): void;
+export declare function killPorts(ports: Array<number | undefined>, options?: KillPortOptions): void;
+export {};

package/src/system/ports.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killPort = killPort;
+exports.killPorts = killPorts;
+const child_process_1 = require("child_process");
+const os_1 = __importDefault(require("os"));
+const terminal_ui_1 = require("../cli/terminal-ui");
+function isValidPort(port) {
+    return Number.isInteger(port) && port > 0;
+}
+function buildMessage(pid, port, platform, options) {
+    var _a;
+    const prefix = (options === null || options === void 0 ? void 0 : options.logPrefix) ? `[${options.logPrefix}] ` : "";
+    const label = (_a = options === null || options === void 0 ? void 0 : options.portLabel) !== null && _a !== void 0 ? _a : "port";
+    return `${prefix}killed process ${pid} on ${label} ${port} (${platform})`;
+}
+function killPortUnix(port, options) {
+    try {
+        const output = (0, child_process_1.execSync)(`lsof -ti tcp:${port}`, {
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .toString()
+            .trim();
+        if (!output) {
+            return;
+        }
+        const pids = output
+            .split("\n")
+            .map((pid) => Number(pid.trim()))
+            .filter((pid) => Number.isInteger(pid) && pid > 0);
+        for (const pid of pids) {
+            try {
+                process.kill(pid, "SIGKILL");
+                (0, terminal_ui_1.printCommandSuccess)("port", buildMessage(pid, port, "unix", options));
+            }
+            catch (_a) {
+                // Best-effort: if the process is already gone, ignore.
+            }
+        }
+    }
+    catch (_b) {
+        // Best-effort: lsof might be missing or no process is listening on the port.
+    }
+}
+function killPortWindows(port, options) {
+    try {
+        const output = (0, child_process_1.execSync)(`netstat -ano -p tcp`, {
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .toString()
+            .trim();
+        if (!output) {
+            return;
+        }
+        const pids = new Set();
+        for (const line of output.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith("TCP")) {
+                continue;
+            }
+            const parts = trimmed.split(/\s+/);
+            if (parts.length < 5) {
+                continue;
+            }
+            const localAddress = parts[1];
+            const pid = Number(parts[parts.length - 1]);
+            const match = localAddress.match(/:(\d+)$/);
+            if (!match) {
+                continue;
+            }
+            const localPort = Number(match[1]);
+            if (localPort === port && Number.isInteger(pid) && pid > 0) {
+                pids.add(pid);
+            }
+        }
+        for (const pid of pids) {
+            try {
+                (0, child_process_1.execSync)(`taskkill /PID ${pid} /F`, {
+                    stdio: ["ignore", "ignore", "ignore"],
+                });
+                (0, terminal_ui_1.printCommandSuccess)("port", buildMessage(pid, port, "win32", options));
+            }
+            catch (_a) {
+                // Best-effort: if the process is already gone, ignore.
+            }
+        }
+    }
+    catch (_b) {
+        // Best-effort: netstat might be missing or no process is listening on the port.
+    }
+}
+function killPort(port, options) {
+    if (!isValidPort(port)) {
+        return;
+    }
+    if (os_1.default.platform() === "win32") {
+        killPortWindows(port, options);
+        return;
+    }
+    killPortUnix(port, options);
+}
+function killPorts(ports, options) {
+    const validPorts = ports
+        .filter((port) => typeof port === "number" && isValidPort(port))
+        .filter((port, index, list) => list.indexOf(port) === index);
+    for (const port of validPorts) {
+        killPort(port, options);
+    }
+}

package/src/terminal-ui.d.ts

@@ -2,3 +2,6 @@ export declare function printCommandBanner(command: string, subtitle: string): v
 export declare function printCommandSuccess(command: string, message: string): void;
 export declare function printCommandInfo(label: string, message: string): void;
 export declare function printCommandWarn(message: string): void;
+export declare function printCommandError(message: string, error?: unknown): void;
+export declare function printCommandLog(label: string, message: string): void;
+export declare function printCommandSummary(command: string, items: string[]): void;

package/src/terminal-ui.js

@@ -7,27 +7,112 @@ exports.printCommandBanner = printCommandBanner;
 exports.printCommandSuccess = printCommandSuccess;
 exports.printCommandInfo = printCommandInfo;
 exports.printCommandWarn = printCommandWarn;
+exports.printCommandError = printCommandError;
+exports.printCommandLog = printCommandLog;
+exports.printCommandSummary = printCommandSummary;
 const chalk_1 = __importDefault(require("chalk"));
-function line(width = 64) {
-    return "═".repeat(width);
+const TERMINAL_WIDTH = 72;
+function printLine(message, method = "log") {
+    if (method === "warn") {
+        console.warn(message);
+        return;
+    }
+    if (method === "error") {
+        console.error(message);
+        return;
+    }
+    console.log(message);
+}
+function repeat(char, width = TERMINAL_WIDTH) {
+    return char.repeat(width);
+}
+function formatClock() {
+    return new Date().toLocaleTimeString("en-GB", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    });
+}
+function padText(value, width) {
+    const text = value.length > width ? `${value.slice(0, Math.max(0, width - 1))}…` : value;
+    return text + " ".repeat(Math.max(0, width - text.length));
+}
+function sectionBorder(color) {
+    return color(`╭${repeat("─", TERMINAL_WIDTH - 2)}╮`);
+}
+function sectionFooter(color) {
+    return color(`╰${repeat("─", TERMINAL_WIDTH - 2)}╯`);
+}
+function sectionBody(text, color) {
+    return color(`│ ${padText(text, TERMINAL_WIDTH - 4)} │`);
+}
+function printSection(lines, options) {
+    var _a;
+    if (lines.length === 0) {
+        return;
+    }
+    const method = (_a = options.method) !== null && _a !== void 0 ? _a : "log";
+    printLine(options.color(``), method);
+    printLine(sectionBorder(options.color), method);
+    for (const line of lines) {
+        printLine(sectionBody(line, options.color), method);
+    }
+    printLine(sectionFooter(options.color), method);
+}
+function commandChip(command) {
+    return chalk_1.default.bgBlueBright.black(` ${command.toUpperCase()} `);
+}
+function subtleChip(text) {
+    return chalk_1.default.bgBlackBright.white(` ${text} `);
 }
 function printCommandBanner(command, subtitle) {
-    const head = chalk_1.default.bgBlue.black(` ${command.toUpperCase()} `);
-    const border = chalk_1.default.blueBright(line());
-    const title = chalk_1.default.bold.white(`nuxt-gin-tools ${head}`);
-    const detail = chalk_1.default.cyan(subtitle);
-    console.log("");
-    console.log(border);
-    console.log(title);
-    console.log(detail);
-    console.log(border);
+    const timestamp = subtleChip(formatClock());
+    const title = `nuxt-gin-tools ${commandChip(command)} ${timestamp}`;
+    const detail = chalk_1.default.cyanBright(subtitle);
+    printLine("");
+    printSection([title, detail], {
+        color: chalk_1.default.blueBright,
+    });
 }
 function printCommandSuccess(command, message) {
-    console.log(chalk_1.default.green(`✔ ${command}: ${message}`));
+    printLine(chalk_1.default.greenBright(`◆ ${chalk_1.default.bold(command)} completed`) + chalk_1.default.green(`  ${message}`));
 }
 function printCommandInfo(label, message) {
-    console.log(chalk_1.default.blueBright(`ℹ ${label}: ${message}`));
+    const head = chalk_1.default.bgCyan.black(` ${label.toUpperCase()} `);
+    printLine(`${head} ${chalk_1.default.cyanBright(message)}`);
 }
 function printCommandWarn(message) {
-    console.warn(chalk_1.default.yellow(`⚠ ${message}`));
+    printSection([`${chalk_1.default.bold("warning")}  ${message}`], {
+        color: chalk_1.default.yellow,
+        method: "warn",
+    });
+}
+function printCommandError(message, error) {
+    const detail = error instanceof Error ? error.message : error !== undefined ? String(error) : "";
+    const lines = [`${chalk_1.default.bold("error")}  ${message}`];
+    if (detail) {
+        lines.push(chalk_1.default.redBright(detail));
+    }
+    printSection(lines, {
+        color: chalk_1.default.red,
+        method: "error",
+    });
+}
+function printCommandLog(label, message) {
+    const chip = chalk_1.default.bgMagenta.white(` ${label} `);
+    printLine(`${chip} ${chalk_1.default.white(message)}`);
+}
+function printCommandSummary(command, items) {
+    const normalizedItems = items.map((item) => item.trim()).filter(Boolean);
+    if (normalizedItems.length === 0) {
+        return;
+    }
+    const lines = [
+        `${chalk_1.default.bold(`${command} summary`)}  ${chalk_1.default.gray(`(${normalizedItems.length} items)`)}`,
+        ...normalizedItems.map((item) => chalk_1.default.magenta(`• ${item}`)),
+    ];
+    printSection(lines, {
+        color: chalk_1.default.magentaBright,
+    });
 }

package/src/utils.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.killPort = killPort;
 exports.killPorts = killPorts;
 const child_process_1 = require("child_process");
-const chalk_1 = __importDefault(require("chalk"));
 const os_1 = __importDefault(require("os"));
+const terminal_ui_1 = require("./terminal-ui");
 function isValidPort(port) {
     return Number.isInteger(port) && port > 0;
 }
@@ -34,7 +34,7 @@ function killPortUnix(port, options) {
         for (const pid of pids) {
             try {
                 process.kill(pid, "SIGKILL");
-                console.log(chalk_1.default.green(buildMessage(pid, port, "unix", options)));
+                (0, terminal_ui_1.printCommandSuccess)("port", buildMessage(pid, port, "unix", options));
             }
             catch (_a) {
                 // Best-effort: if the process is already gone, ignore.
@@ -81,7 +81,7 @@ function killPortWindows(port, options) {
                 (0, child_process_1.execSync)(`taskkill /PID ${pid} /F`, {
                     stdio: ["ignore", "ignore", "ignore"],
                 });
-                console.log(chalk_1.default.green(buildMessage(pid, port, "win32", options)));
+                (0, terminal_ui_1.printCommandSuccess)("port", buildMessage(pid, port, "win32", options));
             }
             catch (_a) {
                 // Best-effort: if the process is already gone, ignore.