@infly/libs 2.0.38 → 2.0.42

package/build/build-dist/script-management.js

@@ -0,0 +1,5 @@
+function shouldManageBuildScripts(inflyConfig) {
+  return inflyConfig?.buildConfigs?.manageScripts !== false;
+}
+
+module.exports = { shouldManageBuildScripts };

package/build/build-dist/script-management.test.js

@@ -0,0 +1,16 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { shouldManageBuildScripts } = require("./script-management");
+
+test("shouldManageBuildScripts defaults to existing automatic script management", () => {
+  assert.equal(shouldManageBuildScripts(), true);
+  assert.equal(shouldManageBuildScripts({ buildConfigs: {} }), true);
+});
+
+test("shouldManageBuildScripts allows a project to own its build scripts", () => {
+  assert.equal(
+    shouldManageBuildScripts({ buildConfigs: { manageScripts: false } }),
+    false,
+  );
+});

package/build/docker/compose-command.js

@@ -0,0 +1,74 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const {
+  EXIT_SELECTION,
+  selectOption: defaultSelectOption,
+} = require("../../tools/select-option");
+const { composeRelease: defaultComposeRelease } = require("./compose-release");
+
+function loadTargetConfig(configPath) {
+  const resolvedPath = path.resolve(configPath);
+  delete require.cache[require.resolve(resolvedPath)];
+  return {
+    config: require(resolvedPath),
+    configDir: path.dirname(resolvedPath),
+  };
+}
+
+function loadPackageTargetConfig(cwd = process.cwd()) {
+  const packagePath = path.resolve(cwd, "package.json");
+  if (!fs.existsSync(packagePath)) {
+    throw new Error(`Package config not found: ${packagePath}`);
+  }
+  delete require.cache[require.resolve(packagePath)];
+  const packageJson = require(packagePath);
+  return {
+    config: packageJson.infly?.docker,
+    configDir: path.dirname(packagePath),
+  };
+}
+
+async function runComposeCommand(options = {}, dependencies = {}) {
+  const composeRelease = dependencies.composeRelease || defaultComposeRelease;
+  const usesDirectConfig = !options.config
+    && !options.configObject
+    && (options.projectDir || options.file);
+  if (usesDirectConfig) return composeRelease(options);
+
+  const loaded = options.config
+    ? loadTargetConfig(options.config)
+    : options.configObject
+      ? { config: options.configObject, configDir: options.configDir || process.cwd() }
+      : loadPackageTargetConfig(options.cwd || process.cwd());
+  const targets = loaded.config?.targets;
+  if (!targets || Object.keys(targets).length === 0) {
+    throw new Error("Docker target config must define at least one target.");
+  }
+
+  const selectOption = dependencies.selectOption || defaultSelectOption;
+  const log = dependencies.log || console.log;
+  const targetName = options.target || await selectOption(
+    "请选择 Docker 发布目标",
+    Object.entries(targets).map(([value, target]) => ({
+      value,
+      label: target.label || value,
+    })),
+  );
+  if (targetName === EXIT_SELECTION) {
+    log("已退出，未执行任何操作。");
+    return { cancelled: true };
+  }
+  const target = targets[targetName];
+  if (!target) throw new Error(`Unknown Docker target: ${targetName}`);
+
+  return composeRelease({
+    projectDir: loaded.configDir,
+    file: target.file,
+    bump: options.bump || "patch",
+    push: Boolean(options.push),
+    dryRun: Boolean(options.dryRun),
+  });
+}
+
+module.exports = { loadPackageTargetConfig, loadTargetConfig, runComposeCommand };

package/build/docker/compose-command.test.js

@@ -0,0 +1,148 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const { runComposeCommand } = require("./compose-command");
+const { EXIT_SELECTION } = require("../../tools/select-option");
+
+test("runComposeCommand resolves a configured target relative to its config file", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-command-"));
+  const configPath = path.join(dir, "docker.targets.js");
+  fs.writeFileSync(
+    configPath,
+    `module.exports = { targets: { qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" } } };`,
+  );
+  const calls = [];
+
+  try {
+    await runComposeCommand(
+      { config: configPath, target: "qdxy", push: true, dryRun: true },
+      { composeRelease: (options) => calls.push(options) },
+    );
+
+    assert.deepEqual(calls, [{
+      projectDir: dir,
+      file: "docker-compose.qdxy.yaml",
+      bump: "patch",
+      push: true,
+      dryRun: true,
+    }]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("runComposeCommand discovers targets from package.json in the working directory", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-package-config-"));
+  fs.writeFileSync(
+    path.join(dir, "package.json"),
+    JSON.stringify({
+      infly: {
+        docker: {
+          targets: {
+            qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" },
+          },
+        },
+      },
+    }),
+  );
+  const calls = [];
+
+  try {
+    await runComposeCommand(
+      { cwd: dir, target: "qdxy", push: true, dryRun: true },
+      { composeRelease: (options) => calls.push(options) },
+    );
+
+    assert.deepEqual(calls, [{
+      projectDir: dir,
+      file: "docker-compose.qdxy.yaml",
+      bump: "patch",
+      push: true,
+      dryRun: true,
+    }]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("runComposeCommand prompts for a target when omitted", async () => {
+  const calls = [];
+
+  await runComposeCommand(
+    {
+      configObject: {
+        targets: {
+          yhqy: { label: "邮惠权益", file: "docker-compose.yaml" },
+          qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" },
+        },
+      },
+      configDir: "C:/dist",
+      dryRun: true,
+    },
+    {
+      selectOption: async (message, choices) => {
+        assert.equal(message, "请选择 Docker 发布目标");
+        assert.deepEqual(choices.map(({ value }) => value), ["yhqy", "qdxy"]);
+        return "qdxy";
+      },
+      composeRelease: (options) => calls.push(options),
+    },
+  );
+
+  assert.equal(calls[0].file, "docker-compose.qdxy.yaml");
+});
+
+test("runComposeCommand exits without publishing when the user chooses exit", async () => {
+  const logs = [];
+  const result = await runComposeCommand(
+    {
+      configObject: {
+        targets: {
+          qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" },
+        },
+      },
+      configDir: "C:/dist",
+    },
+    {
+      selectOption: async () => EXIT_SELECTION,
+      log: (message) => logs.push(message),
+      composeRelease: () => assert.fail("release should not run after exit"),
+    },
+  );
+
+  assert.deepEqual(result, { cancelled: true });
+  assert.deepEqual(logs, ["已退出，未执行任何操作。"]);
+});
+
+test("runComposeCommand preserves direct project-dir and file usage", async () => {
+  const calls = [];
+
+  await runComposeCommand(
+    { projectDir: "apps/dist", file: "docker-compose.yaml", dryRun: true },
+    { composeRelease: (options) => calls.push(options) },
+  );
+
+  assert.deepEqual(calls, [{
+    projectDir: "apps/dist",
+    file: "docker-compose.yaml",
+    dryRun: true,
+  }]);
+});
+
+test("postal dist package owns its Docker target mapping", () => {
+  const projectDir = path.resolve(__dirname, "../../../../apps/postal-benefits-platform-dist");
+  const packageJson = require(path.join(projectDir, "package.json"));
+
+  assert.equal(packageJson.scripts["docker:release"], "infly-libs docker:compose --push");
+  assert.deepEqual(packageJson.infly.docker.targets, {
+    yhqy: { label: "邮惠权益默认前端", file: "docker-compose.frontend.yaml" },
+    sq223: { label: "宿迁贰贰叁", file: "docker-compose.frontend.sq223.yaml" },
+    qdxy: { label: "青岛信跃", file: "docker-compose.frontend.qdxy.yaml" },
+    xzya: { label: "徐州沂埃", file: "docker-compose.frontend.xzya.yaml" },
+    next: { label: "邮惠权益 Next", file: "docker-compose.frontend.next.yaml" },
+  });
+  assert.equal(fs.existsSync(path.join(projectDir, "docker.targets.js")), false);
+});

package/build/docker/compose-release.js

@@ -0,0 +1,91 @@
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+function bumpComposeImageVersion(content, bump = "patch") {
+  if (bump !== "patch") {
+    throw new Error(`Unsupported version bump: ${bump}. Only patch is supported.`);
+  }
+
+  const imageRegex = /^(\s*image:\s*)([^\s#]+):(\d+)\.(\d+)\.(\d+)(\s*(?:#.*)?)$/gm;
+  const matches = [...content.matchAll(imageRegex)];
+
+  if (matches.length !== 1) {
+    throw new Error(`Compose file must contain exactly one versioned image; found ${matches.length}.`);
+  }
+
+  const [, prefix, image, major, minor, patchVersion, suffix] = matches[0];
+  const from = `${image}:${major}.${minor}.${patchVersion}`;
+  const to = `${image}:${major}.${minor}.${Number(patchVersion) + 1}`;
+  const replacement = `${prefix}${to}${suffix}`;
+
+  return {
+    content: content.replace(imageRegex, replacement),
+    from,
+    to,
+  };
+}
+
+function resolveComposePath(projectDir, file) {
+  if (!projectDir) throw new Error("--project-dir is required.");
+  if (!file) throw new Error("--file is required.");
+
+  const resolvedProjectDir = path.resolve(projectDir);
+  const composePath = path.resolve(resolvedProjectDir, file);
+  const relative = path.relative(resolvedProjectDir, composePath);
+
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error("Compose file must be inside project-dir.");
+  }
+  if (!fs.existsSync(composePath)) {
+    throw new Error(`Compose file not found: ${composePath}`);
+  }
+
+  return { projectDir: resolvedProjectDir, composePath };
+}
+
+function defaultRunDocker(args, options) {
+  execFileSync("docker", args, { cwd: options.cwd, stdio: "inherit" });
+}
+
+function composeRelease(options = {}, dependencies = {}) {
+  const {
+    projectDir,
+    file,
+    bump = "patch",
+    push = false,
+    dryRun = false,
+  } = options;
+  const runDocker = dependencies.runDocker || defaultRunDocker;
+  const resolved = resolveComposePath(projectDir, file);
+  const original = fs.readFileSync(resolved.composePath, "utf8");
+  const updated = bumpComposeImageVersion(original, bump);
+  const baseArgs = ["compose", "-f", resolved.composePath];
+
+  console.log(`Version update: ${updated.from} -> ${updated.to}`);
+
+  if (dryRun) {
+    console.log(`[dry-run] docker ${[...baseArgs, "config"].join(" ")}`);
+    console.log(`[dry-run] docker ${[...baseArgs, "build"].join(" ")}`);
+    if (push) console.log(`[dry-run] docker ${[...baseArgs, "push"].join(" ")}`);
+    return { ...updated, projectDir: resolved.projectDir, composePath: resolved.composePath };
+  }
+
+  fs.writeFileSync(resolved.composePath, updated.content, "utf8");
+  try {
+    runDocker([...baseArgs, "config"], { cwd: resolved.projectDir });
+    runDocker([...baseArgs, "build"], { cwd: resolved.projectDir });
+    if (push) runDocker([...baseArgs, "push"], { cwd: resolved.projectDir });
+  } catch (error) {
+    fs.writeFileSync(resolved.composePath, original, "utf8");
+    throw error;
+  }
+
+  return { ...updated, projectDir: resolved.projectDir, composePath: resolved.composePath };
+}
+
+module.exports = {
+  bumpComposeImageVersion,
+  composeRelease,
+  resolveComposePath,
+};

package/build/docker/compose-release.test.js

@@ -0,0 +1,101 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const {
+  bumpComposeImageVersion,
+  composeRelease,
+} = require("./compose-release");
+
+const composeSource = `services:\n  frontend:\n    image: registry.example.com/team/app:1.2.9\n`;
+
+test("bumpComposeImageVersion bumps exactly one image patch version", () => {
+  const result = bumpComposeImageVersion(composeSource, "patch");
+
+  assert.equal(
+    result.content,
+    `services:\n  frontend:\n    image: registry.example.com/team/app:1.2.10\n`,
+  );
+  assert.equal(result.from, "registry.example.com/team/app:1.2.9");
+  assert.equal(result.to, "registry.example.com/team/app:1.2.10");
+});
+
+test("bumpComposeImageVersion rejects zero or multiple versioned images", () => {
+  assert.throws(() => bumpComposeImageVersion("services: {}\n", "patch"), /exactly one versioned image/);
+  assert.throws(
+    () => bumpComposeImageVersion(`${composeSource}  worker:\n    image: team/worker:2.0.0\n`, "patch"),
+    /exactly one versioned image/,
+  );
+});
+
+test("composeRelease dry-run does not write or invoke Docker", () => {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-release-"));
+  const composeFile = "docker-compose.yaml";
+  const composePath = path.join(projectDir, composeFile);
+  fs.writeFileSync(composePath, composeSource);
+  const calls = [];
+
+  try {
+    const result = composeRelease(
+      { projectDir, file: composeFile, dryRun: true, push: true },
+      { runDocker: (args) => calls.push(args) },
+    );
+
+    assert.equal(fs.readFileSync(composePath, "utf8"), composeSource);
+    assert.deepEqual(calls, []);
+    assert.equal(result.to, "registry.example.com/team/app:1.2.10");
+  } finally {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("composeRelease builds without pushing unless push is explicit", () => {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-release-"));
+  const composeFile = "docker-compose.yaml";
+  const composePath = path.join(projectDir, composeFile);
+  fs.writeFileSync(composePath, composeSource);
+  const calls = [];
+
+  try {
+    composeRelease(
+      { projectDir, file: composeFile },
+      { runDocker: (args) => calls.push(args) },
+    );
+
+    assert.deepEqual(calls, [
+      ["compose", "-f", composePath, "config"],
+      ["compose", "-f", composePath, "build"],
+    ]);
+  } finally {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("composeRelease restores the compose file when Docker fails", () => {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-release-"));
+  const composeFile = "docker-compose.yaml";
+  const composePath = path.join(projectDir, composeFile);
+  fs.writeFileSync(composePath, composeSource);
+
+  try {
+    assert.throws(
+      () => composeRelease(
+        { projectDir, file: composeFile, push: true },
+        { runDocker: () => { throw new Error("docker failed"); } },
+      ),
+      /docker failed/,
+    );
+    assert.equal(fs.readFileSync(composePath, "utf8"), composeSource);
+  } finally {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("composeRelease rejects files outside projectDir", () => {
+  assert.throws(
+    () => composeRelease({ projectDir: ".", file: "../docker-compose.yaml", dryRun: true }),
+    /inside project-dir/,
+  );
+});

package/build/docker/docker-build-push.js

@@ -0,0 +1,240 @@
+/**
+ * Docker 镜像构建与推送（infly-libs 公共模块）
+ *
+ * 支持两种运行模式（自动检测）：
+ *
+ * 1. Monorepo 模式 — 检测到 git submodule (--show-superproject-working-tree 有值)
+ *    构建上下文 = superproject 根，Dockerfile 使用 Dockerfile.monorepo
+ *    @infly/* 包从 workspace 源码解析
+ *
+ * 2. 独立模式 — 非 submodule 且 cwd = git 根
+ *    构建上下文 = 当前目录，Dockerfile 使用 Dockerfile
+ *    @infly/* 包从 npm registry 安装
+ *
+ * 用法：
+ *   infly-libs build:docker [--local] [--env prod|dev] [--dry-run] [--cicd-url URL]
+ */
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+// ---------- 默认配置 ----------
+const DEFAULT_REGISTRY = "ccr.ccs.tencentyun.com";
+const DEFAULT_NAMESPACE = "points";
+
+function formatCicdLink(value) {
+  if (value === undefined) {
+    return "";
+  }
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("--cicd-url 缺少参数值");
+  }
+
+  const rawUrl = value.trim();
+  if (/[\u0000-\u001f\u007f]/.test(rawUrl)) {
+    throw new Error("--cicd-url 不能包含控制字符");
+  }
+
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(rawUrl);
+  } catch {
+    throw new Error("--cicd-url 必须是合法的 HTTP/HTTPS URL");
+  }
+
+  if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+    throw new Error("--cicd-url 只支持 HTTP/HTTPS URL");
+  }
+  if (parsedUrl.username || parsedUrl.password) {
+    throw new Error("--cicd-url 不能包含用户名或密码凭据");
+  }
+
+  return `发布系统：\x1b[34m${decodeURI(parsedUrl.href)}\x1b[0m`;
+}
+
+function detectMode() {
+  const cwd = path.resolve(process.cwd());
+
+  // git submodule → monorepo 模式，contextRoot = superproject 根
+  try {
+    const superproject = execSync("git rev-parse --show-superproject-working-tree", {
+      encoding: "utf-8", stdio: "pipe",
+    }).trim();
+    if (superproject) {
+      return { isStandalone: false, contextRoot: superproject };
+    }
+  } catch {}
+
+  // 非 submodule：cwd = git 根 → 独立模式，否则 monorepo 模式
+  const gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+  const isStandalone = path.resolve(cwd) === path.resolve(gitRoot);
+
+  return {
+    isStandalone,
+    contextRoot: isStandalone ? cwd : gitRoot,
+  };
+}
+
+function run(cmd, { silent = false, dryRun = false, cwd } = {}) {
+  if (dryRun) {
+    console.log(`  [DRY RUN] ${cmd}`);
+    return "";
+  }
+  return execSync(cmd, {
+    stdio: silent ? "pipe" : "inherit",
+    cwd: cwd || process.cwd(),
+    encoding: "utf-8",
+  });
+}
+
+function startDockerDesktop() {
+  console.log("\x1b[1;33mDocker Desktop 未运行，正在启动...\x1b[0m");
+  try {
+    try {
+      execSync(
+        `powershell.exe -Command "Start-Process 'C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe'"`,
+        { stdio: "ignore" }
+      );
+    } catch {
+      execSync(
+        `cmd.exe /c start "" "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe"`,
+        { stdio: "ignore" }
+      );
+    }
+
+    process.stdout.write("等待 Docker 引擎就绪");
+    for (let i = 0; i < 30; i++) {
+      try {
+        execSync("docker info", { stdio: "ignore" });
+        console.log("\n\x1b[0;32m✓ Docker 已就绪\x1b[0m");
+        return true;
+      } catch {}
+      process.stdout.write(".");
+      execSync("sleep 2", { stdio: "ignore" });
+    }
+    console.log("");
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+async function dockerBuildPush(options = {}) {
+  const {
+    env = "prod",
+    registry = DEFAULT_REGISTRY,
+    namespace = DEFAULT_NAMESPACE,
+    local = false,
+    dryRun = false,
+    cicdUrl,
+  } = options;
+  const cicdLink = formatCicdLink(cicdUrl);
+
+  // 1. 检测运行模式并定位关键路径
+  const cwd = path.resolve(process.cwd());
+  const { isStandalone, contextRoot } = detectMode();
+
+  const appPkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(appPkgPath)) {
+    console.error("错误: 当前目录下缺少 package.json，请在 app 目录内执行");
+    process.exit(1);
+  }
+
+  let buildContext, dockerfileArg, modeLabel;
+  if (isStandalone) {
+    if (!fs.existsSync(path.join(cwd, "Dockerfile"))) {
+      console.error("错误: 当前目录下缺少 Dockerfile");
+      process.exit(1);
+    }
+    buildContext = cwd;
+    dockerfileArg = "Dockerfile";
+    modeLabel = "独立模式";
+  } else {
+    const appDir = path.relative(contextRoot, cwd).replace(/\\/g, "/");
+    if (!fs.existsSync(path.join(contextRoot, appDir, "Dockerfile.monorepo"))) {
+      console.error("错误: 缺少 Dockerfile.monorepo");
+      process.exit(1);
+    }
+    buildContext = contextRoot;
+    dockerfileArg = `${appDir}/Dockerfile.monorepo`;
+    modeLabel = `monorepo 模式 (${appDir})`;
+  }
+
+  // 2. 从 package.json 推导镜像名
+  const pkg = JSON.parse(fs.readFileSync(appPkgPath, "utf-8"));
+  const imageName = pkg.name.replace(/^@[^/]+\//, "");
+
+  // 3. 获取版本号（monorepo 模式取 superproject 的 commit）
+  const commitHash = execSync("git rev-parse --short HEAD", {
+    cwd: contextRoot, encoding: "utf-8",
+  }).trim();
+  const fullCommit = execSync("git rev-parse HEAD", {
+    cwd: contextRoot, encoding: "utf-8",
+  }).trim();
+
+  // 4. 镜像标签
+  const imageBase = `${registry}/${namespace}/${imageName}`;
+  const tags = [`${imageBase}:${commitHash}`, `${imageBase}:${env}`];
+  if (env === "prod") tags.push(`${imageBase}:latest`);
+
+  // 5. Docker Desktop 自动启动（仅本地模式）
+  if (local) {
+    console.log("\x1b[0;32m>>> 检查 Docker 运行状态\x1b[0m");
+    try {
+      execSync("docker info", { stdio: "ignore" });
+      console.log("\x1b[0;32m✓ Docker 已运行\x1b[0m");
+    } catch {
+      const ok = startDockerDesktop();
+      if (!ok) {
+        console.error("\x1b[0;31m错误: Docker Desktop 启动超时，请手动启动后重试\x1b[0m");
+        process.exit(1);
+      }
+    }
+  }
+
+  // 6. 打印信息
+  console.log("\x1b[0;34m==========================================");
+  console.log("构建并推送 Docker 镜像");
+  console.log("==========================================\x1b[0m");
+  console.log(`运行模式:   ${modeLabel}`);
+  console.log(`镜像名称:   ${imageName}`);
+  console.log(`环境:        ${env}`);
+  console.log(`版本号:      ${commitHash}`);
+  console.log("标签:");
+  tags.forEach((t) => console.log(`  ${t}`));
+  console.log("");
+
+  // 7. 构建
+  console.log("\x1b[0;32m>>> 开始构建 Docker 镜像\x1b[0m");
+  const tagArgs = tags.map((t) => `-t ${t}`).join(" ");
+  const buildCmd = `docker build -f ${dockerfileArg} ${tagArgs} --build-arg GIT_COMMIT=${fullCommit} .`;
+  run(buildCmd, { cwd: buildContext, dryRun });
+  console.log("\x1b[0;32m✓ 镜像构建完成\x1b[0m");
+
+  // 8. 推送
+  console.log("");
+  console.log(`\x1b[0;32m>>> 推送镜像到 ${registry}\x1b[0m`);
+  for (const tag of tags) {
+    run(`docker push ${tag}`, { dryRun });
+  }
+
+  // 9. 结果摘要
+  console.log("");
+  console.log("\x1b[0;34m==========================================");
+  console.log("✅ 完成");
+  console.log("==========================================\x1b[0m");
+  console.log("可用标签:");
+  console.log(`  ${tags[0]}  (commit 精确版本)`);
+  console.log(`  ${tags[1]}       (${env} 环境)`);
+  if (env === "prod") console.log(`  ${tags[2]}    (最新)`);
+  if (cicdLink) {
+    console.log("");
+    console.log(cicdLink);
+  }
+  console.log("");
+
+  return { mode: isStandalone ? "standalone" : "monorepo", buildContext, imageName, commitHash, tags };
+}
+
+module.exports = { dockerBuildPush, detectMode, formatCicdLink };