@git.zone/cli 2.25.2 → 3.0.1

package/ts/mod_meta/meta.classes.meta.ts

@@ -100,8 +100,7 @@ export class Meta {
       `cd ${this.cwd} && git pull origin master`,
     );
     if (gitCleanArg) {
-      logger.log('info', `cleaning the repository from old directories`);
-      await this.smartshellInstance.exec(`cd ${this.cwd} && git clean -fd`);
+      await this.cleanUntrackedWithConsent();
     }
     logger.log('info', `syncing  to remote origin master`);
     await this.smartshellInstance.exec(
@@ -109,6 +108,54 @@ export class Meta {
     );
   }
 
+  /**
+   * Remove untracked files from the meta repository, but only after showing
+   * exactly what would go and getting a yes.
+   *
+   * This used to be an unconditional `git clean -fd` on a code path that every
+   * meta subcommand reaches, including `meta update`. It deletes untracked,
+   * non-ignored files — which is a user's uncommitted scratch work, not the
+   * "old directories" the log line claimed, since cloned project directories
+   * are normally gitignored and `-fd` does not touch ignored paths.
+   */
+  private async cleanUntrackedWithConsent(): Promise<void> {
+    const dryRun = await this.smartshellInstance.execSilent(
+      `cd ${this.cwd} && git clean -nd`,
+    );
+    if (dryRun.exitCode !== 0) {
+      logger.log('note', 'could not determine untracked files; skipping cleanup');
+      return;
+    }
+
+    const candidates = (dryRun.stdout || '')
+      .trim()
+      .split(/\r?\n/)
+      .map((line) => line.replace(/^Would remove\s+/, '').trim())
+      .filter(Boolean);
+
+    if (candidates.length === 0) {
+      return;
+    }
+
+    logger.log('note', `${candidates.length} untracked path(s) in the meta repository:`);
+    for (const candidate of candidates) {
+      logger.log('info', `  ${candidate}`);
+    }
+
+    const shouldClean =
+      await plugins.smartinteract.SmartInteract.getCliConfirmation(
+        'Delete these untracked paths?',
+        false,
+      );
+    if (!shouldClean) {
+      logger.log('note', 'keeping untracked paths');
+      return;
+    }
+
+    logger.log('info', 'cleaning the repository from untracked paths');
+    await this.smartshellInstance.exec(`cd ${this.cwd} && git clean -fd`);
+  }
+
   /**
    * update the locally cloned repositories
    */
@@ -299,17 +346,45 @@ export class Meta {
       return;
     }
 
+    // The name comes from .meta.json, which is just a file on disk: a key of
+    // `../something` would otherwise resolve outside the meta repo and be
+    // deleted. Require the target to be a direct child of cwd.
+    const targetDirectory = plugins.path.resolve(paths.cwd, projectNameArg);
+    const expectedParent = plugins.path.resolve(paths.cwd);
+    if (
+      plugins.path.dirname(targetDirectory) !== expectedParent ||
+      targetDirectory === expectedParent
+    ) {
+      throw new Error(
+        `Refusing to remove "${projectNameArg}": it does not resolve to a direct child of ${expectedParent}`,
+      );
+    }
+
+    // Deleting a clone can destroy uncommitted or unpushed work, so it is
+    // confirmed rather than assumed.
+    const targetExists = await plugins.smartfs.directory(targetDirectory).exists();
+    if (targetExists) {
+      const shouldContinue =
+        await plugins.smartinteract.SmartInteract.getCliConfirmation(
+          `Delete directory ${targetDirectory} and everything in it?`,
+          false,
+        );
+      if (!shouldContinue) {
+        logger.log('note', 'Cancelled — nothing was removed');
+        return;
+      }
+    }
+
     delete this.metaRepoData.projects[projectNameArg];
 
     logger.log('info', 'removing project from .meta.json');
     await this.sortMetaRepoData();
     await this.writeToDisk();
 
-    logger.log('info', 'removing directory from cwd');
-    await plugins.smartfs
-      .directory(plugins.path.join(paths.cwd, projectNameArg))
-      .recursive()
-      .delete();
+    if (targetExists) {
+      logger.log('info', 'removing directory from cwd');
+      await plugins.smartfs.directory(targetDirectory).recursive().delete();
+    }
     await this.updateLocalRepos();
   }
 }

package/ts/mod_services/classes.dockercontainer.ts

@@ -4,6 +4,15 @@ import { logger } from '../gitzone.logging.js';
 
 export type ContainerStatus = 'running' | 'stopped' | 'not_exists';
 
+export interface IDockerUlimit {
+  soft: number;
+  hard: number;
+}
+
+export type TDockerUlimits = Record<string, IDockerUlimit>;
+
+export type TDockerUlimitMatch = 'match' | 'mismatch' | 'unavailable';
+
 export interface IDockerRunOptions {
   name: string;
   image: string;
@@ -11,6 +20,7 @@ export interface IDockerRunOptions {
   volumes?: { [key: string]: string };
   environment?: { [key: string]: string };
   labels?: { [key: string]: string };
+  ulimits?: TDockerUlimits;
   restart?: string;
   command?: string;
 }
@@ -29,6 +39,66 @@ export interface IContainerInspectInfo {
 /** Single-quote a value for safe interpolation into a bash command. */
 export const shellQuote = (valueArg: string): string => `'${valueArg.replace(/'/g, `'"'"'`)}'`;
 
+const assertDockerUlimit = (nameArg: string, limitArg: IDockerUlimit): void => {
+  if (!/^[a-z][a-z0-9_-]*$/u.test(nameArg)) {
+    throw new Error(`Invalid Docker ulimit name: ${nameArg}`);
+  }
+  if (
+    !Number.isSafeInteger(limitArg.soft) ||
+    !Number.isSafeInteger(limitArg.hard) ||
+    limitArg.soft <= 0 ||
+    limitArg.hard <= 0 ||
+    limitArg.hard < limitArg.soft
+  ) {
+    throw new Error(`Invalid Docker ulimit values for ${nameArg}`);
+  }
+};
+
+export const renderDockerUlimits = (ulimitsArg: TDockerUlimits = {}): string => {
+  let rendered = '';
+  for (const [name, limit] of Object.entries(ulimitsArg)) {
+    assertDockerUlimit(name, limit);
+    rendered += ` --ulimit ${shellQuote(`${name}=${limit.soft}:${limit.hard}`)}`;
+  }
+  return rendered;
+};
+
+export const matchDockerUlimits = (
+  inspectDataArg: unknown,
+  expectedArg: TDockerUlimits,
+): TDockerUlimitMatch => {
+  if (!Array.isArray(inspectDataArg) || inspectDataArg.length !== 1) {
+    return 'unavailable';
+  }
+  const container = inspectDataArg[0] as {
+    HostConfig?: {
+      Ulimits?: Array<{ Name?: unknown; Soft?: unknown; Hard?: unknown }> | null;
+    };
+  };
+  if (!container?.HostConfig) {
+    return 'unavailable';
+  }
+  if (!Object.hasOwn(container.HostConfig, 'Ulimits')) {
+    return 'unavailable';
+  }
+  const actual = container.HostConfig.Ulimits ?? [];
+  if (!Array.isArray(actual)) {
+    return 'unavailable';
+  }
+  for (const [name, expected] of Object.entries(expectedArg)) {
+    assertDockerUlimit(name, expected);
+    const matchingName = actual.filter((entry) => entry?.Name === name);
+    if (
+      matchingName.length !== 1 ||
+      matchingName[0].Soft !== expected.soft ||
+      matchingName[0].Hard !== expected.hard
+    ) {
+      return 'mismatch';
+    }
+  }
+  return 'match';
+};
+
 export class DockerContainer {
   private smartshell: plugins.smartshell.Smartshell;
   /**
@@ -171,6 +241,8 @@ export class DockerContainer {
       }
     }
 
+    command += renderDockerUlimits(options.ulimits);
+
     // Add restart policy
     if (options.restart) {
       command += ` --restart ${options.restart}`;

package/ts/mod_services/classes.globalregistry.ts

@@ -200,18 +200,43 @@ export class GlobalRegistry {
   /**
    * Remove stale registry entries (projects that no longer exist on disk)
    */
-  public async cleanup(): Promise<string[]> {
+  public async cleanup(): Promise<{ removed: string[]; kept: Array<{ projectPath: string; reason: string }> }> {
     const projects = await this.getAllProjects();
     const removed: string[] = [];
+    const kept: Array<{ projectPath: string; reason: string }> = [];
 
-    for (const projectPath of Object.keys(projects)) {
-      const exists = await plugins.smartfs.directory(projectPath).exists();
-      if (!exists) {
-        await this.unregisterProject(projectPath);
-        removed.push(projectPath);
+    for (const [projectPath, project] of Object.entries(projects)) {
+      if (await plugins.smartfs.directory(projectPath).exists()) {
+        continue;
       }
+
+      // Same rule ServicePruner enforces: for containers created before labels
+      // existed, this registry entry is the only thing that can still identify
+      // them. Dropping it while one exists would hide the container from prune,
+      // `stop -g` and `cleanup -g` alike, leaving it running forever under
+      // `restart: unless-stopped`.
+      const survivingContainers: string[] = [];
+      for (const containerName of Object.values(project.containers)) {
+        if (!containerName) {
+          continue;
+        }
+        if ((await this.docker.getStatus(containerName)) !== 'not_exists') {
+          survivingContainers.push(containerName);
+        }
+      }
+
+      if (survivingContainers.length > 0) {
+        kept.push({
+          projectPath,
+          reason: `container(s) still exist: ${survivingContainers.join(', ')}`,
+        });
+        continue;
+      }
+
+      await this.unregisterProject(projectPath);
+      removed.push(projectPath);
     }
 
-    return removed;
+    return { removed, kept };
   }
 }

package/ts/mod_services/classes.servicemanager.ts

@@ -1,7 +1,11 @@
 import * as plugins from './mod.plugins.js';
 import * as helpers from './helpers.js';
 import { ServiceConfiguration } from './classes.serviceconfiguration.js';
-import { DockerContainer } from './classes.dockercontainer.js';
+import {
+  DockerContainer,
+  matchDockerUlimits,
+  type TDockerUlimits,
+} from './classes.dockercontainer.js';
 import { GlobalRegistry } from './classes.globalregistry.js';
 import {
   getServiceContainerLabels,
@@ -44,6 +48,13 @@ export interface IServicesStatus {
   totalDataBytes: number;
 }
 
+export const mongoServiceUlimits = {
+  nofile: {
+    soft: 65_536,
+    hard: 65_536,
+  },
+} as const satisfies TDockerUlimits;
+
 export class ServiceManager {
   private config: ServiceConfiguration;
   private docker: DockerContainer;
@@ -297,24 +308,60 @@ export class ServiceManager {
 
     const status = await this.docker.getStatus(containers.mongo);
 
-    // Containers created before replica-set support, with a changed port, or
-    // running the other auth mode must be recreated; the data is preserved.
+    // Containers created before replica-set or managed-limit support, with a
+    // changed port, or running the other auth mode must be recreated; the data
+    // is preserved.
     let needsRecreate = false;
     if (status !== 'not_exists') {
-      const containerCmd = await this.getMongoContainerCmd(containers.mongo);
+      const inspectInfo = await this.docker.inspect(containers.mongo);
+      if (!Array.isArray(inspectInfo) || inspectInfo.length !== 1) {
+        throw new Error(
+          `Unable to inspect MongoDB container ${containers.mongo}; refusing to recreate it.`,
+        );
+      }
+      const inspectedContainer = inspectInfo[0];
+      if (
+        !inspectedContainer?.Config ||
+        !Array.isArray(inspectedContainer.Config.Cmd) ||
+        !inspectedContainer.HostConfig ||
+        !Object.hasOwn(inspectedContainer.HostConfig, 'PortBindings')
+      ) {
+        throw new Error(
+          `Incomplete inspection for MongoDB container ${containers.mongo}; refusing to recreate it.`,
+        );
+      }
+      const containerCmd = inspectedContainer.Config.Cmd;
       const hasReplSet = containerCmd.includes('--replSet');
       const hasKeyFile = containerCmd.includes('--keyFile');
-      const portMappings = await this.docker.getPortMappings(containers.mongo);
+      const mongoPortBindings =
+        inspectedContainer.HostConfig.PortBindings?.[`${config.MONGODB_PORT}/tcp`];
       const portMatches =
-        !!portMappings && portMappings[config.MONGODB_PORT] === config.MONGODB_PORT;
+        Array.isArray(mongoPortBindings) &&
+        mongoPortBindings.length > 0 &&
+        mongoPortBindings.some(
+          (bindingArg: { HostPort?: string }) => bindingArg?.HostPort === config.MONGODB_PORT,
+        );
       const authMatches = hasKeyFile === this.config.isMongoAuthEnabled();
-      needsRecreate = !hasReplSet || !portMatches || !authMatches;
+      const ulimitMatch = matchDockerUlimits(inspectInfo, mongoServiceUlimits);
+      if (ulimitMatch === 'unavailable') {
+        throw new Error(
+          `Unable to inspect MongoDB container limits for ${containers.mongo}; refusing to recreate it.`,
+        );
+      }
+      needsRecreate =
+        !hasReplSet ||
+        !portMatches ||
+        !authMatches ||
+        ulimitMatch === 'mismatch';
       if (!authMatches) {
         logger.log(
           'note',
           `  Auth mode changed to ${this.config.isMongoAuthEnabled() ? 'enabled' : 'disabled'}, recreating container...`,
         );
       }
+      if (ulimitMatch === 'mismatch') {
+        logger.log('note', '  MongoDB file-descriptor limit changed, recreating container...');
+      }
     }
 
     switch (status) {
@@ -323,7 +370,7 @@ export class ServiceManager {
           logger.log('ok', '  Already running ✓');
           break;
         }
-        logger.log('note', '  Upgrading to single-node replica set, recreating container...');
+        logger.log('note', '  MongoDB service configuration changed, recreating container...');
         await this.docker.remove(containers.mongo, true);
         await this.createMongoContainer();
         break;
@@ -420,6 +467,7 @@ export class ServiceManager {
       },
       environment,
       labels,
+      ulimits: mongoServiceUlimits,
       restart: 'unless-stopped',
       command
     });
@@ -428,6 +476,7 @@ export class ServiceManager {
       logger.log('ok', '  Created and started ✓');
     } else {
       logger.log('error', '  Failed to create container');
+      throw new Error(`Failed to create MongoDB container ${containers.mongo}.`);
     }
   }
 
@@ -451,14 +500,6 @@ export class ServiceManager {
     });
   }
 
-  /**
-   * The mongod argv the container was created with
-   */
-  private async getMongoContainerCmd(containerName: string): Promise<string[]> {
-    const info = await this.docker.inspect(containerName);
-    return info?.[0]?.Config?.Cmd ?? [];
-  }
-
   /**
    * Make sure the configured root user exists when auth is enabled.
    *

package/ts/mod_services/index.ts

@@ -1162,10 +1162,17 @@ async function handleGlobalCleanup(globalRegistry: GlobalRegistry) {
   helpers.printHeader("Cleanup Registry (Global)");
 
   logger.log("note", "Checking for stale registry entries...");
-  const removed = await globalRegistry.cleanup();
+  const { removed, kept } = await globalRegistry.cleanup();
+
+  for (const keptEntry of kept) {
+    logger.log(
+      "note",
+      `  kept ${keptEntry.projectPath}: ${keptEntry.reason} — removing the entry would make them unidentifiable`,
+    );
+  }
 
   if (removed.length === 0) {
-    logger.log("ok", "No stale entries found");
+    logger.log("ok", "No stale entries removed");
     return;
   }
 

package/ts/mod_standard/index.ts

@@ -26,7 +26,10 @@ const commandSummaries: ICommandHelpSummary[] = [
   { name: "tools", description: "Manage the global @git.zone toolchain" },
   { name: "template", description: "Create a project from a template" },
   { name: "open", description: "Open project assets and CI pages" },
-  { name: "docker", description: "Run Docker-related maintenance tasks" },
+  {
+    name: "docker",
+    description: "Report and reclaim Docker resources created by git.zone tooling",
+  },
   {
     name: "deprecate",
     description: "Deprecate npm packages across registries",
@@ -245,6 +248,11 @@ async function showCommandHelp(
       modTools.showHelp(mode);
       return true;
     }
+    case "docker": {
+      const modDocker = await import("../mod_docker/index.js");
+      modDocker.showHelp(mode);
+      return true;
+    }
     default:
       return false;
   }

package/ts/mod_tools/classes.packagemanager.ts

@@ -362,6 +362,26 @@ export class PackageManagerUtil {
       return results;
     }
 
+    // Only shims belonging to packages this tool manages may be removed.
+    // Pointing at a legacy root is not sufficient evidence of ownership: a
+    // legacy root retained precisely because it holds unmanaged packages also
+    // holds their shims, and deleting those silently breaks unrelated global
+    // CLIs that have nothing to do with @git.zone.
+    const managedLegacyBinNames = new Set<string>();
+    for (const legacyRoot of legacyRoots) {
+      for (const packageInfo of legacyRoot.packages) {
+        if (!packageInfo.packagePath) {
+          continue;
+        }
+        const packageJson = await readJson(
+          plugins.path.join(packageInfo.packagePath, "package.json"),
+        );
+        for (const binName of getPackageBinNames(packageInfo.name, packageJson)) {
+          managedLegacyBinNames.add(binName);
+        }
+      }
+    }
+
     for (const pnpmShimDir of pnpmShimDirs) {
       try {
         const entries = await plugins.fs.readdir(pnpmShimDir, {
@@ -372,6 +392,11 @@ export class PackageManagerUtil {
             continue;
           }
 
+          if (!managedLegacyBinNames.has(entry.name)) {
+            // Not a binary of a package this tool manages — leave it alone.
+            continue;
+          }
+
           const filePath = plugins.path.join(pnpmShimDir, entry.name);
           let content = "";
           try {