@git.zone/cli 2.25.2 → 3.0.0

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.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/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 {