claudekit-cli 3.32.0 → 3.32.1-dev.1

package/dist/index.js

@@ -23196,7 +23196,7 @@ function getPagerArgs(pagerCmd) {
   return [];
 }
 async function trySystemPager(content) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     const pagerCmd = process.env.PAGER || "less";
     const pagerArgs = getPagerArgs(pagerCmd);
     try {
@@ -23206,20 +23206,20 @@ async function trySystemPager(content) {
       });
       const timeout = setTimeout(() => {
         pager.kill();
-        resolve12(false);
+        resolve13(false);
       }, 30000);
       pager.stdin.write(content);
       pager.stdin.end();
       pager.on("close", (code2) => {
         clearTimeout(timeout);
-        resolve12(code2 === 0);
+        resolve13(code2 === 0);
       });
       pager.on("error", () => {
         clearTimeout(timeout);
-        resolve12(false);
+        resolve13(false);
       });
     } catch {
-      resolve12(false);
+      resolve13(false);
     }
   });
 }
@@ -23246,16 +23246,16 @@ async function basicPager(content) {
       break;
     }
     const remaining = lines.length - currentLine;
-    await new Promise((resolve12) => {
+    await new Promise((resolve13) => {
       rl.question(`-- More (${remaining} lines) [Enter/q] --`, (answer) => {
         if (answer.toLowerCase() === "q") {
           rl.close();
           process.exitCode = 0;
-          resolve12();
+          resolve13();
           return;
         }
         process.stdout.write("\x1B[1A\x1B[2K");
-        resolve12();
+        resolve13();
       });
     });
   }
@@ -30849,27 +30849,51 @@ class PromptsManager {
 init_logger();
 
 // src/shared/process-lock.ts
+init_logger();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import { mkdir as mkdir8 } from "node:fs/promises";
 import os2 from "node:os";
 import { join as join29 } from "node:path";
 var LOCK_CONFIG = {
-  stale: 300000,
+  stale: 60000,
   retries: 0
 };
+var activeLocks = new Set;
+var cleanupRegistered = false;
 function getLocksDir() {
   return join29(os2.homedir(), ".claudekit", "locks");
 }
+function cleanupLocks() {
+  for (const name of activeLocks) {
+    try {
+      const lockPath = join29(getLocksDir(), `${name}.lock`);
+      import_proper_lockfile.default.unlockSync(lockPath, { realpath: false });
+    } catch {
+      try {
+        logger.verbose(`Failed to cleanup lock: ${name}`);
+      } catch {}
+    }
+  }
+  activeLocks.clear();
+}
+function registerCleanupHandlers() {
+  if (cleanupRegistered)
+    return;
+  cleanupRegistered = true;
+  process.on("exit", cleanupLocks);
+}
 async function ensureLocksDir() {
   const lockDir = getLocksDir();
   await mkdir8(lockDir, { recursive: true });
 }
 async function withProcessLock(lockName, fn) {
+  registerCleanupHandlers();
   await ensureLocksDir();
   const lockPath = join29(getLocksDir(), `${lockName}.lock`);
   let release;
   try {
     release = await import_proper_lockfile.default.lock(lockPath, { ...LOCK_CONFIG, realpath: false });
+    activeLocks.add(lockName);
     return await fn();
   } catch (e2) {
     const error = e2;
@@ -30884,6 +30908,7 @@ Wait for it to complete or remove lock: ${lockPath}`);
     if (release) {
       await release();
     }
+    activeLocks.delete(lockName);
   }
 }
 
@@ -47943,7 +47968,8 @@ async function initCommand(options2) {
       return;
     }
     logger.error(error instanceof Error ? error.message : "Unknown error occurred");
-    process.exit(1);
+    process.exitCode = 1;
+    throw error;
   }
 }
 // src/commands/new/new-command.ts
@@ -49300,30 +49326,45 @@ var import_picocolors23 = __toESM(require_picocolors(), 1);
 // src/commands/uninstall/installation-detector.ts
 init_path_resolver();
 var import_fs_extra35 = __toESM(require_lib(), 1);
+function hasClaudeKitComponents(components) {
+  return components.agents > 0 || components.commands > 0 || components.rules > 0 || components.skills > 0;
+}
 async function detectInstallations() {
   const installations = [];
   const setup = await getClaudeKitSetup(process.cwd());
   const isLocalSameAsGlobal = PathResolver.isLocalSameAsGlobal();
-  if (setup.project.path && setup.project.metadata && !isLocalSameAsGlobal) {
-    installations.push({
-      type: "local",
-      path: setup.project.path,
-      exists: await import_fs_extra35.pathExists(setup.project.path)
-    });
+  if (setup.project.path && !isLocalSameAsGlobal) {
+    const hasMetadata = setup.project.metadata !== null;
+    const hasComponents = hasClaudeKitComponents(setup.project.components);
+    if (hasMetadata || hasComponents) {
+      installations.push({
+        type: "local",
+        path: setup.project.path,
+        exists: await import_fs_extra35.pathExists(setup.project.path),
+        hasMetadata,
+        components: setup.project.components
+      });
+    }
   }
-  if (setup.global.path && setup.global.metadata) {
-    installations.push({
-      type: "global",
-      path: setup.global.path,
-      exists: await import_fs_extra35.pathExists(setup.global.path)
-    });
+  if (setup.global.path) {
+    const hasMetadata = setup.global.metadata !== null;
+    const hasComponents = hasClaudeKitComponents(setup.global.components);
+    if (hasMetadata || hasComponents) {
+      installations.push({
+        type: "global",
+        path: setup.global.path,
+        exists: await import_fs_extra35.pathExists(setup.global.path),
+        hasMetadata,
+        components: setup.global.components
+      });
+    }
   }
   return installations.filter((i) => i.exists);
 }
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync4, rmSync as rmSync5 } from "node:fs";
-import { join as join81 } from "node:path";
+import { join as join81, resolve as resolve12, sep as sep3 } from "node:path";
 init_logger();
 var import_fs_extra36 = __toESM(require_lib(), 1);
 
@@ -49449,28 +49490,72 @@ function displayDryRunPreview(analysis, installationType) {
 }
 
 // src/commands/uninstall/removal-handler.ts
+async function isDirectory(filePath) {
+  try {
+    const stats = await import_fs_extra36.lstat(filePath);
+    return stats.isDirectory();
+  } catch {
+    logger.debug(`Failed to check if path is directory: ${filePath}`);
+    return false;
+  }
+}
+async function isPathSafeToRemove(filePath, baseDir) {
+  try {
+    const resolvedPath = resolve12(filePath);
+    const resolvedBase = resolve12(baseDir);
+    if (!resolvedPath.startsWith(resolvedBase + sep3) && resolvedPath !== resolvedBase) {
+      logger.debug(`Path outside installation directory: ${filePath}`);
+      return false;
+    }
+    const stats = await import_fs_extra36.lstat(filePath);
+    if (stats.isSymbolicLink()) {
+      const realPath = await import_fs_extra36.realpath(filePath);
+      const resolvedReal = resolve12(realPath);
+      if (!resolvedReal.startsWith(resolvedBase + sep3) && resolvedReal !== resolvedBase) {
+        logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
+        return false;
+      }
+    }
+    return true;
+  } catch {
+    logger.debug(`Failed to validate path safety: ${filePath}`);
+    return false;
+  }
+}
 async function removeInstallations(installations, options2) {
   for (const installation of installations) {
     const analysis = await analyzeInstallation(installation, options2.forceOverwrite, options2.kit);
     if (options2.dryRun) {
       const label = options2.kit ? `${installation.type} (${options2.kit} kit)` : installation.type;
-      displayDryRunPreview(analysis, label);
+      const legacyLabel2 = !installation.hasMetadata ? " [legacy]" : "";
+      displayDryRunPreview(analysis, `${label}${legacyLabel2}`);
       if (analysis.remainingKits.length > 0) {
         log.info(`Remaining kits after uninstall: ${analysis.remainingKits.join(", ")}`);
       }
+      if (!installation.hasMetadata) {
+        log.warn("Legacy installation - directories will be removed recursively");
+      }
       continue;
     }
     const kitLabel = options2.kit ? ` ${options2.kit} kit` : "";
-    const spinner = createSpinner(`Removing ${installation.type}${kitLabel} ClaudeKit files...`).start();
+    const legacyLabel = !installation.hasMetadata ? " (legacy)" : "";
+    const spinner = createSpinner(`Removing ${installation.type}${kitLabel}${legacyLabel} ClaudeKit files...`).start();
     try {
       let removedCount = 0;
       let cleanedDirs = 0;
       for (const item of analysis.toDelete) {
         const filePath = join81(installation.path, item.path);
-        if (await import_fs_extra36.pathExists(filePath)) {
-          await import_fs_extra36.remove(filePath);
-          removedCount++;
-          logger.debug(`Removed: ${item.path}`);
+        if (!await import_fs_extra36.pathExists(filePath))
+          continue;
+        if (!await isPathSafeToRemove(filePath, installation.path)) {
+          logger.debug(`Skipping unsafe path: ${item.path}`);
+          continue;
+        }
+        const isDir = await isDirectory(filePath);
+        await import_fs_extra36.remove(filePath);
+        removedCount++;
+        logger.debug(`Removed ${isDir ? "directory" : "file"}: ${item.path}`);
+        if (!isDir) {
           cleanedDirs += await cleanupEmptyDirectories3(filePath, installation.path);
         }
       }
@@ -49502,11 +49587,34 @@ async function removeInstallations(installations, options2) {
 
 // src/commands/uninstall/uninstall-command.ts
 var prompts = new PromptsManager;
+function formatComponentSummary(inst) {
+  const parts = [];
+  if (inst.components.skills > 0)
+    parts.push(`${inst.components.skills} skills`);
+  if (inst.components.commands > 0)
+    parts.push(`${inst.components.commands} commands`);
+  if (inst.components.agents > 0)
+    parts.push(`${inst.components.agents} agents`);
+  if (inst.components.rules > 0)
+    parts.push(`${inst.components.rules} rules`);
+  return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
 function displayInstallations(installations, scope) {
   prompts.intro("ClaudeKit Uninstaller");
   const scopeLabel = scope === "all" ? "all" : scope === "local" ? "local only" : "global only";
-  prompts.note(installations.map((i) => `  ${i.type === "local" ? "Local " : "Global"}: ${i.path}`).join(`
+  const hasLegacy = installations.some((i) => !i.hasMetadata);
+  const lines = installations.map((i) => {
+    const typeLabel = i.type === "local" ? "Local " : "Global";
+    const legacyTag = !i.hasMetadata ? import_picocolors23.default.yellow(" [legacy]") : "";
+    const components = formatComponentSummary(i);
+    return `  ${typeLabel}: ${i.path}${legacyTag}${components}`;
+  });
+  prompts.note(lines.join(`
 `), `Detected ClaudeKit installations (${scopeLabel})`);
+  if (hasLegacy) {
+    log.warn(import_picocolors23.default.yellow(`[!] Legacy installation(s) detected without metadata.json.
+`) + import_picocolors23.default.yellow("    These files cannot be selectively removed. Full directory cleanup will be performed."));
+  }
   log.warn("[!] This will permanently delete ClaudeKit files from the above paths.");
 }
 async function promptScope(installations) {
@@ -49787,7 +49895,7 @@ var import_fs_extra37 = __toESM(require_lib(), 1);
 // package.json
 var package_default = {
   name: "claudekit-cli",
-  version: "3.32.0",
+  version: "3.32.1-dev.1",
   description: "CLI tool for bootstrapping and updating ClaudeKit projects",
   type: "module",
   repository: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "3.32.0",
+	"version": "3.32.1-dev.1",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {