@git.zone/cli 3.2.1 → 5.0.0

package/ts/helpers.smartconfig.ts

@@ -1,7 +1,8 @@
 import * as plugins from "./plugins.js";
-import { rename, writeFile } from "fs/promises";
+import { withInterProcessLock } from "./mod_services/classes.interprocesslock.js";
 
 export const CLI_NAMESPACE = "@git.zone/cli";
+const smartconfigSnapshots = new WeakMap<Record<string, any>, string | undefined>();
 
 const isPlainObject = (value: unknown): value is Record<string, any> => {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -16,7 +17,9 @@ export const readSmartconfigFile = async (
 ): Promise<Record<string, any>> => {
   const smartconfigPath = getSmartconfigPath(cwd);
   if (!(await plugins.smartfs.file(smartconfigPath).exists())) {
-    return {};
+    const data = {};
+    smartconfigSnapshots.set(data, undefined);
+    return data;
   }
 
   const content = (await plugins.smartfs
@@ -24,9 +27,16 @@ export const readSmartconfigFile = async (
     .encoding("utf8")
     .read()) as string;
   if (content.trim() === "") {
-    return {};
+    const data = {};
+    smartconfigSnapshots.set(data, content);
+    return data;
+  }
+  const parsed = JSON.parse(content);
+  if (!isPlainObject(parsed)) {
+    throw new Error(".smartconfig.json must contain a JSON object at its root.");
   }
-  return JSON.parse(content);
+  smartconfigSnapshots.set(parsed, content);
+  return parsed;
 };
 
 export const writeSmartconfigFile = async (
@@ -34,10 +44,48 @@ export const writeSmartconfigFile = async (
   cwd: string = process.cwd(),
 ): Promise<void> => {
   const smartconfigPath = getSmartconfigPath(cwd);
-  const tempPath = `${smartconfigPath}.tmp-${Date.now()}`;
-  const content = JSON.stringify(data, null, 2);
-  await writeFile(tempPath, content, "utf8");
-  await rename(tempPath, smartconfigPath);
+  if (!smartconfigSnapshots.has(data)) {
+    throw new Error("Refusing to write .smartconfig.json without a loaded file snapshot.");
+  }
+  await withInterProcessLock(
+    {
+      lockPath: `${smartconfigPath}.lock`,
+      description: "Project smartconfig",
+    },
+    async () => {
+      let currentSnapshot: string | undefined;
+      try {
+        currentSnapshot = await plugins.fs.readFile(smartconfigPath, "utf8");
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+          throw error;
+        }
+      }
+      if (currentSnapshot !== smartconfigSnapshots.get(data)) {
+        throw new Error(
+          "Refusing to overwrite .smartconfig.json because it changed after loading.",
+        );
+      }
+
+      const content = `${JSON.stringify(data, null, 2)}\n`;
+      const tempPath = `${smartconfigPath}.tmp-${process.pid}-${plugins.crypto
+        .randomBytes(12)
+        .toString("hex")}`;
+      try {
+        await plugins.fs.writeFile(tempPath, content, {
+          encoding: "utf8",
+          flag: "wx",
+        });
+        await plugins.fs.rename(tempPath, smartconfigPath);
+        smartconfigSnapshots.set(data, content);
+      } catch (error) {
+        await plugins.fs.rm(tempPath, { force: true }).catch(() => {});
+        throw new Error("Could not persist .smartconfig.json atomically.", {
+          cause: error,
+        });
+      }
+    },
+  );
 };
 
 export const normalizeCliConfigPath = (configPath: string): string => {
@@ -69,10 +117,13 @@ export const getCliNamespaceConfig = (
   smartconfigData: Record<string, any>,
 ): Record<string, any> => {
   const cliConfig = smartconfigData[CLI_NAMESPACE];
+  if (cliConfig === undefined) {
+    return {};
+  }
   if (isPlainObject(cliConfig)) {
     return cliConfig;
   }
-  return {};
+  throw new Error(`${CLI_NAMESPACE} in .smartconfig.json must be a JSON object.`);
 };
 
 export const getCliConfigValueFromData = (
@@ -121,8 +172,10 @@ export const setCliConfigValueInData = (
 ): Record<string, any> => {
   const segments = getCliConfigPathSegments(configPath);
 
-  if (!isPlainObject(smartconfigData[CLI_NAMESPACE])) {
+  if (smartconfigData[CLI_NAMESPACE] === undefined) {
     smartconfigData[CLI_NAMESPACE] = {};
+  } else if (!isPlainObject(smartconfigData[CLI_NAMESPACE])) {
+    throw new Error(`${CLI_NAMESPACE} in .smartconfig.json must be a JSON object.`);
   }
 
   if (segments.length === 0) {

package/ts/helpers.workflow.ts

@@ -70,7 +70,6 @@ export interface IReleaseWorkflowConfig {
     source?: "pendingChangelog" | "manual";
   };
   preflight?: {
-    requireCleanTree?: boolean;
     test?: boolean;
     build?: boolean;
     testCommand?: string;
@@ -101,7 +100,6 @@ export interface IResolvedReleaseWorkflow {
   confirmation: TConfirmationMode;
   plan: string[];
   targets: TReleaseTarget[];
-  requireCleanTree: boolean;
   runTests: boolean;
   runBuild: boolean;
   testCommand: string;
@@ -202,6 +200,22 @@ export const resolveDockerTestSetting = (valueArg: unknown): boolean => {
   return valueArg;
 };
 
+const resolveGitPushSetting = (
+  valueArg: unknown,
+  settingArg: "pushBranch" | "pushTags",
+  gitEnabledArg: boolean,
+): boolean => {
+  if (!gitEnabledArg) {
+    return valueArg === undefined ? true : valueArg === true;
+  }
+  if (valueArg !== undefined && valueArg !== true) {
+    throw new Error(
+      `release.targets.git.${settingArg} must be true when the Git target is enabled`,
+    );
+  }
+  return true;
+};
+
 const isStringRecord = (valueArg: unknown): valueArg is Record<string, unknown> => {
   return typeof valueArg === "object" && valueArg !== null && !Array.isArray(valueArg);
 };
@@ -340,15 +354,19 @@ const getTargetOverride = (argvArg: any): TReleaseTarget[] | undefined => {
   return targets.length > 0 ? targets : undefined;
 };
 
+const releaseTargetOrder: TReleaseTarget[] = ["git", "npm", "docker"];
+
 const buildReleasePlan = (options: {
-  requireCleanTree: boolean;
+  mergeRequested: boolean;
   runTests: boolean;
   runBuild: boolean;
   targets: TReleaseTarget[];
 }): string[] => {
-  const plan: string[] = [];
-  if (options.requireCleanTree) plan.push("preflight.cleanTree");
+  const plan: string[] = ["preflight.branch", "preflight.cleanTree"];
   if (options.runTests) plan.push("preflight.test");
+  if (options.mergeRequested) {
+    plan.push("integration.main", "integration.pushMain");
+  }
   plan.push("core.version", "core.changelog", "core.commit", "core.tag");
   if (options.runBuild) plan.push("core.build");
   for (const target of options.targets) {
@@ -421,6 +439,16 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
   const npmEnabled = npmConfig.enabled ?? npmRegistries.length > 0;
   const gitEnabled = gitConfig.enabled ?? true;
   const dockerEnabled = dockerConfig.enabled ?? false;
+  const pushBranch = resolveGitPushSetting(
+    gitConfig.pushBranch,
+    "pushBranch",
+    gitEnabled,
+  );
+  const pushTags = resolveGitPushSetting(
+    gitConfig.pushTags,
+    "pushTags",
+    gitEnabled,
+  );
 
   let confirmation = normalizeConfirmation(releaseConfig.confirmation, "prompt");
   if (argvArg.plan) {
@@ -429,14 +457,12 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
     confirmation = "auto";
   }
 
-  let requireCleanTree = releaseConfig.preflight?.requireCleanTree ?? true;
   let runTests = releaseConfig.preflight?.test ?? false;
   let runBuild = releaseConfig.preflight?.build ?? true;
   if (argvArg.t || argvArg.test) runTests = true;
   if (argvArg.b || argvArg.build) runBuild = true;
   if (isDisabled(argvArg, "test")) runTests = false;
   if (isDisabled(argvArg, "build")) runBuild = false;
-  if (isDisabled(argvArg, "preflight")) requireCleanTree = false;
 
   const configuredTargets: TReleaseTarget[] = [];
   if (gitEnabled) configuredTargets.push("git");
@@ -449,13 +475,16 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
   if (isDisabled(argvArg, "publish")) {
     targets = targets.filter((target) => target === "git");
   }
-  targets = unique(targets);
+  const selectedTargets = unique(targets);
+  targets = releaseTargetOrder.filter((target) =>
+    selectedTargets.includes(target),
+  );
+  const mergeRequested = argvArg.merge === true;
 
   return {
     confirmation,
-    plan: buildReleasePlan({ requireCleanTree, runTests, runBuild, targets }),
+    plan: buildReleasePlan({ mergeRequested, runTests, runBuild, targets }),
     targets,
-    requireCleanTree,
     runTests,
     runBuild,
     testCommand: releaseConfig.preflight?.testCommand || "pnpm test",
@@ -465,8 +494,8 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
     changelogVersionHeading: "## {{date}} - {{version}}",
     gitEnabled,
     gitRemote: gitConfig.remote || "origin",
-    pushBranch: gitConfig.pushBranch ?? true,
-    pushTags: gitConfig.pushTags ?? true,
+    pushBranch,
+    pushTags,
     npmEnabled,
     npmRegistries,
     npmAccessLevel: npmConfig.accessLevel || "public",

package/ts/mod_commit/mod.helpers.ts

@@ -37,9 +37,9 @@ export async function detectCurrentBranch(): Promise<string> {
  * Detects the project type based on presence of package.json and/or deno.json
  * @returns The project type
  */
-export async function detectProjectType(): Promise<ProjectType> {
-  const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
-  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+export async function detectProjectType(cwdArg = paths.cwd): Promise<ProjectType> {
+  const packageJsonPath = plugins.path.join(cwdArg, 'package.json');
+  const denoJsonPath = plugins.path.join(cwdArg, 'deno.json');
 
   const hasPackageJson = await plugins.smartfs.file(packageJsonPath).exists();
   const hasDenoJson = await plugins.smartfs.file(denoJsonPath).exists();
@@ -96,9 +96,12 @@ export function calculateNewVersion(currentVersion: string, versionType: Version
  * @param projectType The project type to determine which file to read
  * @returns The current version string
  */
-export async function readCurrentVersion(projectType: ProjectType): Promise<string> {
+export async function readCurrentVersion(
+  projectType: ProjectType,
+  cwdArg = paths.cwd,
+): Promise<string> {
   if (projectType === 'npm' || projectType === 'both') {
-    const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
+    const packageJsonPath = plugins.path.join(cwdArg, 'package.json');
     const content = (await plugins.smartfs
       .file(packageJsonPath)
       .encoding('utf8')
@@ -110,7 +113,7 @@ export async function readCurrentVersion(projectType: ProjectType): Promise<stri
     }
     return packageJson.version;
   } else {
-    const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+    const denoJsonPath = plugins.path.join(cwdArg, 'deno.json');
     const content = (await plugins.smartfs
       .file(denoJsonPath)
       .encoding('utf8')
@@ -148,10 +151,11 @@ export async function updateVersionFile(filePath: string, newVersion: string): P
 export async function updateProjectVersionFiles(
   projectType: ProjectType,
   newVersion: string,
+  cwdArg = paths.cwd,
 ): Promise<string[]> {
   const filesToUpdate: string[] = [];
-  const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
-  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+  const packageJsonPath = plugins.path.join(cwdArg, 'package.json');
+  const denoJsonPath = plugins.path.join(cwdArg, 'deno.json');
 
   if (projectType === 'npm' || projectType === 'both') {
     await updateVersionFile(packageJsonPath, newVersion);

package/ts/mod_config/index.ts

@@ -293,7 +293,7 @@ async function handleShow(mode: ICliMode): Promise<void> {
   const targets = release.targets || {};
   printConfigSection("Release Workflow", [
     ["confirmation", formatValue(release.confirmation)],
-    ["require clean tree", formatValue(release.preflight?.requireCleanTree)],
+    ["clean tree", "required"],
     ["run tests", formatValue(release.preflight?.test)],
     ["run build", formatValue(release.preflight?.build)],
     ["test command", formatValue(release.preflight?.testCommand)],
@@ -773,12 +773,6 @@ async function handleRelease(mode: ICliMode): Promise<void> {
     choices: ["prompt", "auto", "plan"],
     default: currentRelease.confirmation || "prompt",
   });
-  const requireCleanTree = await askValue<boolean>(interactInstance, {
-    type: "confirm",
-    name: "requireCleanTree",
-    message: "Require a clean git tree before release?",
-    default: currentRelease.preflight?.requireCleanTree ?? true,
-  });
   const runTests = await askValue<boolean>(interactInstance, {
     type: "confirm",
     name: "runTests",
@@ -828,18 +822,8 @@ async function handleRelease(mode: ICliMode): Promise<void> {
         message: "Git remote:",
         default: currentTargets.git?.remote || "origin",
       }),
-      pushBranch: await askValue<boolean>(interactInstance, {
-        type: "confirm",
-        name: "pushBranch",
-        message: "Push release commit branch?",
-        default: currentTargets.git?.pushBranch ?? true,
-      }),
-      pushTags: await askValue<boolean>(interactInstance, {
-        type: "confirm",
-        name: "pushTags",
-        message: "Push release tags?",
-        default: currentTargets.git?.pushTags ?? true,
-      }),
+      pushBranch: true,
+      pushTags: true,
     };
   } else {
     releaseTargets.git = { ...(currentTargets.git || {}), enabled: false };
@@ -947,12 +931,13 @@ async function handleRelease(mode: ICliMode): Promise<void> {
   }
 
   setCliConfigValueInData(smartconfigData, "schemaVersion", CURRENT_GITZONE_CLI_SCHEMA_VERSION);
+  const currentPreflight = { ...(currentRelease.preflight || {}) };
+  delete currentPreflight.requireCleanTree;
   setCliConfigValueInData(smartconfigData, "release", {
     ...currentRelease,
     confirmation,
     preflight: {
-      ...(currentRelease.preflight || {}),
-      requireCleanTree,
+      ...currentPreflight,
       test: runTests,
       build: runBuild,
       testCommand: testCommand.trim(),
@@ -1175,7 +1160,7 @@ async function handleServices(mode: ICliMode): Promise<void> {
   const { ServiceManager } =
     await import("../mod_services/classes.servicemanager.js");
   const serviceManager = new ServiceManager();
-  await serviceManager.init();
+  await serviceManager.init("config");
   await serviceManager.configureServices();
 }
 
@@ -1704,7 +1689,7 @@ async function validateReleaseConfig(
   if (preflight.build === true && preflight.buildCommand === "") {
     findings.push({
       level: "warn",
-      message: "Release build preflight has an empty command",
+      message: "Release build has an empty command",
       fix: "Set release.preflight.buildCommand or unset it to use pnpm build.",
     });
   }
@@ -1816,6 +1801,20 @@ async function validateGitTarget(
     });
     return;
   }
+  if (gitTarget.pushBranch !== undefined && gitTarget.pushBranch !== true) {
+    findings.push({
+      level: "error",
+      message: "Enabled Git release targets must push main",
+      fix: "Set release.targets.git.pushBranch to true or disable the Git target.",
+    });
+  }
+  if (gitTarget.pushTags !== undefined && gitTarget.pushTags !== true) {
+    findings.push({
+      level: "error",
+      message: "Enabled Git release targets must push release tags",
+      fix: "Set release.targets.git.pushTags to true or disable the Git target.",
+    });
+  }
   findings.push({
     level: "ok",
     message: `Git release target is enabled (${gitTarget.remote || "origin"})`,

package/ts/mod_docker/classes.dockerpruner.ts

@@ -117,6 +117,12 @@ export class DockerPruner {
     if (!labelsArg) {
       return false;
     }
+    if (labelsArg['git.zone.operation'] === 'service-bind-operation') {
+      return false;
+    }
+    if (labelsArg['git.zone.service'] === 'minio') {
+      return false;
+    }
     return (
       typeof labelsArg[toolLabelKey] === 'string' &&
       !!labelsArg[toolLabelKey] &&