claudekit-cli 4.3.1-dev.18 → 4.3.1-dev.19

package/bin/postinstall-hook-restore.cjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const MAX_SETTINGS_BYTES = 5 * 1024 * 1024;
+const SAFE_KIT_NAMES = new Set(["engineer", "marketing"]);
+
+function getHomeDir() {
+	return process.env.CK_TEST_HOME || os.homedir();
+}
+
+function readJsonFile(filePath) {
+	try {
+		if (!filePath || !fs.existsSync(filePath)) return null;
+		const stat = fs.statSync(filePath);
+		if (!stat.isFile() || stat.size > MAX_SETTINGS_BYTES) return null;
+		return JSON.parse(fs.readFileSync(filePath, "utf8").replace(/^\uFEFF/, ""));
+	} catch {
+		return null;
+	}
+}
+
+function normalizeCommand(command) {
+	if (!command) return "";
+	let normalized = String(command).replace(/"/g, "");
+	normalized = normalized.replace(/~\//g, "$HOME/");
+	normalized = normalized.replace(/\$\{HOME\}/g, "$HOME");
+	normalized = normalized.replace(/\$CLAUDE_PROJECT_DIR/g, "$HOME");
+	normalized = normalized.replace(/%USERPROFILE%/g, "$HOME");
+	normalized = normalized.replace(/%CLAUDE_PROJECT_DIR%/g, "$HOME");
+	normalized = normalized.replace(/(^|\s)(?:\.\/)?\.claude\//g, "$1$HOME/.claude/");
+	normalized = normalized.replace(/\\/g, "/");
+	return normalized.replace(/\s+/g, " ").trim();
+}
+
+function collectHookCommands(settings) {
+	const commands = new Set();
+	for (const entries of Object.values(settings?.hooks || {})) {
+		if (!Array.isArray(entries)) continue;
+		for (const entry of entries) {
+			if (typeof entry?.command === "string") commands.add(normalizeCommand(entry.command));
+			if (!Array.isArray(entry?.hooks)) continue;
+			for (const hook of entry.hooks) {
+				if (typeof hook?.command === "string") commands.add(normalizeCommand(hook.command));
+			}
+		}
+	}
+	return commands;
+}
+
+function extractCkHookName(command) {
+	if (!String(command || "").trim().startsWith("node ")) return null;
+	const normalized = String(command).replace(/\\/g, "/");
+	const match = normalized.match(/\/hooks\/([^/"'\s]+)\.(?:cjs|mjs|js)(?:["'\s]|$)/);
+	return match?.[1] || null;
+}
+
+function installedHookCommands(config) {
+	return Object.values(config?.kits || {}).flatMap((entry) =>
+		Array.isArray(entry?.installedSettings?.hooks) ? entry.installedSettings.hooks : [],
+	);
+}
+
+function countMissingCkHookRegistrations(claudeDir) {
+	const settings = readJsonFile(path.join(claudeDir, "settings.json"));
+	const config = readJsonFile(path.join(claudeDir, ".ck.json"));
+	if (!settings || !config) return 0;
+
+	const existingCommands = collectHookCommands(settings);
+	const disabledHooks = new Set(
+		Object.entries(config.hooks || {})
+			.filter(([, enabled]) => enabled === false)
+			.map(([name]) => name),
+	);
+
+	let missing = 0;
+	for (const command of installedHookCommands(config)) {
+		const hookName = extractCkHookName(command);
+		if (hookName && disabledHooks.has(hookName)) continue;
+		if (!existingCommands.has(normalizeCommand(command))) missing++;
+	}
+	return missing;
+}
+
+function normalizeKitName(name) {
+	const normalized = String(name || "").toLowerCase();
+	if (normalized.includes("engineer")) return "engineer";
+	if (normalized.includes("marketing")) return "marketing";
+	return SAFE_KIT_NAMES.has(normalized) ? normalized : null;
+}
+
+function getInstalledKit(claudeDir) {
+	const metadata = readJsonFile(path.join(claudeDir, "metadata.json"));
+	const metadataKit = normalizeKitName(Object.keys(metadata?.kits || {})[0] || metadata?.name);
+	if (metadataKit) {
+		const kitVersion = metadata?.kits?.[metadataKit]?.version || metadata?.version || "";
+		return { kit: metadataKit, isBeta: String(kitVersion).includes("beta") };
+	}
+
+	const config = readJsonFile(path.join(claudeDir, ".ck.json"));
+	const configKit = normalizeKitName(Object.keys(config?.kits || {})[0]);
+	return configKit ? { kit: configKit, isBeta: false } : null;
+}
+
+function collectCandidateClaudeDirs(settingsFiles) {
+	const dirs = new Set();
+	for (const settingsFile of settingsFiles) dirs.add(path.dirname(settingsFile));
+	return [...dirs];
+}
+
+function resolveCkEntrypoint() {
+	return process.env.CK_POSTINSTALL_CK_BIN || path.join(__dirname, "ck.js");
+}
+
+function restoreMissingHookRegistrations(settingsFiles) {
+	if (process.env.CK_POSTINSTALL_SKIP_RESTORE_CK_HOOKS === "1") return 0;
+
+	let restored = 0;
+	for (const claudeDir of collectCandidateClaudeDirs(settingsFiles)) {
+		const missing = countMissingCkHookRegistrations(claudeDir);
+		if (missing <= 0) continue;
+
+		const installedKit = getInstalledKit(claudeDir);
+		if (!installedKit?.kit) continue;
+
+		const homeDir = getHomeDir();
+		const globalClaudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(homeDir, ".claude");
+		const isGlobal = path.resolve(claudeDir) === path.resolve(globalClaudeDir);
+		const args = [resolveCkEntrypoint(), "init"];
+		if (isGlobal) args.push("-g");
+		args.push("--kit", installedKit.kit, "--yes", "--restore-ck-hooks", "--install-skills");
+		if (installedKit.isBeta) args.push("--beta");
+
+		const result = spawnSync(process.execPath, args, {
+			env: { ...process.env, CK_POSTINSTALL_SKIP_RESTORE_CK_HOOKS: "1" },
+			stdio: process.env.CK_POSTINSTALL_DEBUG === "1" ? "inherit" : "ignore",
+		});
+		if (result.status === 0) restored += missing;
+	}
+
+	return restored;
+}
+
+module.exports = {
+	countMissingCkHookRegistrations,
+	restoreMissingHookRegistrations,
+};

package/bin/postinstall-self-heal.cjs

@@ -4,6 +4,10 @@
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
+const {
+	countMissingCkHookRegistrations,
+	restoreMissingHookRegistrations,
+} = require("./postinstall-hook-restore.cjs");
 
 const MAX_SETTINGS_BYTES = 5 * 1024 * 1024;
 
@@ -124,20 +128,28 @@ function collectCandidateSettingsFiles() {
 
 function main() {
 	let pruned = 0;
-	for (const filePath of collectCandidateSettingsFiles()) {
+	const settingsFiles = collectCandidateSettingsFiles();
+	for (const filePath of settingsFiles) {
 		pruned += pruneSettingsFile(filePath);
 	}
 
+	const restored = restoreMissingHookRegistrations(settingsFiles);
+
 	if (pruned > 0 && process.env.CK_POSTINSTALL_DEBUG === "1") {
 		console.warn(`[claudekit-cli] Pruned ${pruned} legacy hook prompt(s)`);
 	}
+	if (restored > 0 && process.env.CK_POSTINSTALL_DEBUG === "1") {
+		console.warn(`[claudekit-cli] Restored ${restored} missing hook registration(s)`);
+	}
 }
 
 main();
 
 module.exports = {
 	collectCandidateSettingsFiles,
+	countMissingCkHookRegistrations,
 	isLegacyDescriptiveNamePrompt,
 	pruneHooks,
 	pruneSettingsFile,
+	restoreMissingHookRegistrations,
 };

package/cli-manifest.json

@@ -1,6 +1,6 @@
 {
-	"version": "4.3.1-dev.18",
-	"generatedAt": "2026-05-27T12:21:02.391Z",
+	"version": "4.3.1-dev.19",
+	"generatedAt": "2026-05-27T13:19:15.391Z",
 	"commands": {
 		"agents": {
 			"name": "agents",

package/dist/index.js

@@ -12941,8 +12941,8 @@ function getCliVersion() {
     return "unknown";
   }
 }
-async function migrateLegacyRegistry() {
-  const { legacyRegistryPath } = getPortableRegistryPaths();
+async function migrateLegacyRegistry(paths = getPortableRegistryPaths()) {
+  const { legacyRegistryPath } = paths;
   try {
     const content = await readFile2(legacyRegistryPath, "utf-8");
     const data = JSON.parse(content);
@@ -13051,15 +13051,15 @@ async function repairStaleRegistryV3(registry) {
     appliedManifestVersion: registry.appliedManifestVersion
   });
 }
-async function persistCurrentStaleRegistryV3Repair(preparedRepair) {
-  return withRegistryLock(async () => {
-    const { registryPath } = getPortableRegistryPaths();
+async function persistCurrentStaleRegistryV3Repair(preparedRepair, paths = getPortableRegistryPaths()) {
+  return withRegistryLock(async (lockedPaths) => {
+    const { registryPath } = lockedPaths;
     let content;
     try {
       content = await readFile2(registryPath, "utf-8");
     } catch (error) {
       if (isErrnoCode(error, "ENOENT")) {
-        return readPortableRegistryInternal({ persistStaleV3Repair: false });
+        return readPortableRegistryInternal({ persistStaleV3Repair: false }, lockedPaths);
       }
       throw error;
     }
@@ -13075,20 +13075,20 @@ async function persistCurrentStaleRegistryV3Repair(preparedRepair) {
     }
     const repairableV3Result = RepairablePortableRegistrySchemaV3.safeParse(data);
     if (!repairableV3Result.success) {
-      return readPortableRegistryInternal({ persistStaleV3Repair: false });
+      return readPortableRegistryInternal({ persistStaleV3Repair: false }, lockedPaths);
     }
     const repairedRegistry = preparedRepair && preparedRepair.sourceContent === content ? preparedRepair.repairedRegistry : await repairStaleRegistryV3(repairableV3Result.data);
-    if (await isMigrationLocked()) {
+    if (await isMigrationLocked(lockedPaths)) {
       logger.verbose("Migration in progress by another process, using repaired v3 view");
       return repairedRegistry;
     }
     logger.verbose("Repairing stale portable registry v3.0 fields");
-    await writePortableRegistry(repairedRegistry);
+    await writePortableRegistry(repairedRegistry, lockedPaths);
     return repairedRegistry;
-  });
+  }, paths);
 }
-async function isMigrationLocked() {
-  const { migrationLockPath } = getPortableRegistryPaths();
+async function isMigrationLocked(paths = getPortableRegistryPaths()) {
+  const { migrationLockPath } = paths;
   try {
     const lockContent = await readFile2(migrationLockPath, "utf-8");
     const lockTime = Number.parseInt(lockContent, 10);
@@ -13112,16 +13112,16 @@ async function isMigrationLocked() {
     return true;
   }
 }
-async function createMigrationLock() {
-  const { migrationLockPath } = getPortableRegistryPaths();
+async function createMigrationLock(paths = getPortableRegistryPaths()) {
+  const { migrationLockPath } = paths;
   const lockDir = dirname(migrationLockPath);
   if (!existsSync3(lockDir)) {
     await mkdir(lockDir, { recursive: true });
   }
   await writeFile(migrationLockPath, Date.now().toString(), "utf-8");
 }
-async function removeMigrationLock() {
-  const { migrationLockPath } = getPortableRegistryPaths();
+async function removeMigrationLock(paths = getPortableRegistryPaths()) {
+  const { migrationLockPath } = paths;
   try {
     await unlink(migrationLockPath);
   } catch {}
@@ -13129,8 +13129,8 @@ async function removeMigrationLock() {
 async function readPortableRegistry() {
   return readPortableRegistryInternal({ persistStaleV3Repair: true });
 }
-async function readPortableRegistryInternal(options2) {
-  const { registryPath } = getPortableRegistryPaths();
+async function readPortableRegistryInternal(options2, paths = getPortableRegistryPaths()) {
+  const { registryPath } = paths;
   try {
     const content = await readFile2(registryPath, "utf-8");
     let data;
@@ -13149,59 +13149,59 @@ async function readPortableRegistryInternal(options2) {
       if (!options2.persistStaleV3Repair) {
         return repairedRegistry;
       }
-      if (await isMigrationLocked()) {
+      if (await isMigrationLocked(paths)) {
         logger.verbose("Migration in progress by another process, using repaired v3 view");
         return repairedRegistry;
       }
       return persistCurrentStaleRegistryV3Repair({
         sourceContent: content,
         repairedRegistry
-      });
+      }, paths);
     }
     const v2Result = PortableRegistrySchema.safeParse(data);
     if (!v2Result.success) {
       throw new Error("portable-registry.json has unsupported schema/version");
     }
-    if (await isMigrationLocked()) {
+    if (await isMigrationLocked(paths)) {
       logger.verbose("Migration in progress by another process, using in-memory v2→v3 view");
       return normalizePortableRegistryChecksums(await migrateRegistryV2ToV3(v2Result.data));
     }
     logger.verbose("Auto-migrating registry from v2.0 to v3.0");
-    await createMigrationLock();
+    await createMigrationLock(paths);
     try {
       const v3Registry = normalizePortableRegistryChecksums(await migrateRegistryV2ToV3(v2Result.data));
-      await writePortableRegistry(v3Registry);
+      await writePortableRegistry(v3Registry, paths);
       return v3Registry;
     } finally {
-      await removeMigrationLock();
+      await removeMigrationLock(paths);
     }
   } catch (error) {
     if (!isErrnoCode(error, "ENOENT")) {
       throw error;
     }
   }
-  const migratedV2 = await migrateLegacyRegistry();
+  const migratedV2 = await migrateLegacyRegistry(paths);
   if (migratedV2) {
-    if (await isMigrationLocked()) {
+    if (await isMigrationLocked(paths)) {
       logger.verbose("Migration in progress by another process, using in-memory v2→v3 view");
       return normalizePortableRegistryChecksums(await migrateRegistryV2ToV3(migratedV2));
     }
-    await createMigrationLock();
+    await createMigrationLock(paths);
     try {
       const v3Registry = normalizePortableRegistryChecksums(await migrateRegistryV2ToV3(migratedV2));
-      await writePortableRegistry(v3Registry);
+      await writePortableRegistry(v3Registry, paths);
       return v3Registry;
     } finally {
-      await removeMigrationLock();
+      await removeMigrationLock(paths);
     }
   }
   return { version: "3.0", installations: [] };
 }
-async function readPortableRegistryWithinRegistryLock() {
-  return readPortableRegistryInternal({ persistStaleV3Repair: false });
+async function readPortableRegistryWithinRegistryLock(paths) {
+  return readPortableRegistryInternal({ persistStaleV3Repair: false }, paths);
 }
-async function writePortableRegistry(registry) {
-  const { registryPath } = getPortableRegistryPaths();
+async function writePortableRegistry(registry, paths = getPortableRegistryPaths()) {
+  const { registryPath } = paths;
   const dir = dirname(registryPath);
   if (!existsSync3(dir)) {
     await mkdir(dir, { recursive: true });
@@ -13218,8 +13218,8 @@ async function writePortableRegistry(registry) {
     throw error;
   }
 }
-async function withRegistryLock(operation) {
-  const { registryLockPath } = getPortableRegistryPaths();
+async function withRegistryLock(operation, paths = getPortableRegistryPaths()) {
+  const { registryLockPath } = paths;
   const lockDir = dirname(registryLockPath);
   if (!existsSync3(lockDir)) {
     await mkdir(lockDir, { recursive: true });
@@ -13237,14 +13237,14 @@ async function withRegistryLock(operation) {
     }
   });
   try {
-    return await operation();
+    return await operation(paths);
   } finally {
     await release();
   }
 }
 async function addPortableInstallation(item, type, provider, global2, path2, sourcePath, options2) {
-  await withRegistryLock(async () => {
-    const registry = await readPortableRegistryWithinRegistryLock();
+  await withRegistryLock(async (lockedPaths) => {
+    const registry = await readPortableRegistryWithinRegistryLock(lockedPaths);
     registry.installations = registry.installations.filter((i) => !(i.item === item && i.type === type && i.provider === provider && i.global === global2));
     registry.installations.push({
       item,
@@ -13260,17 +13260,17 @@ async function addPortableInstallation(item, type, provider, global2, path2, sou
       installSource: options2?.installSource || "kit",
       ownedSections: options2?.ownedSections
     });
-    await writePortableRegistry(registry);
+    await writePortableRegistry(registry, lockedPaths);
   });
 }
 async function removePortableInstallation(item, type, provider, global2, options2) {
-  return withRegistryLock(async () => {
-    const registry = await readPortableRegistryWithinRegistryLock();
+  return withRegistryLock(async (lockedPaths) => {
+    const registry = await readPortableRegistryWithinRegistryLock(lockedPaths);
     const index = registry.installations.findIndex((i) => i.item === item && i.type === type && i.provider === provider && i.global === global2 && (!options2?.path || resolve2(i.path) === resolve2(options2.path)));
     if (index === -1)
       return null;
     const [removed] = registry.installations.splice(index, 1);
-    await writePortableRegistry(registry);
+    await writePortableRegistry(registry, lockedPaths);
     return removed;
   });
 }
@@ -13288,15 +13288,15 @@ function findPortableInstallations(registry, item, type, provider, global2) {
   });
 }
 async function updateAppliedManifestVersion(version) {
-  await withRegistryLock(async () => {
-    const registry = await readPortableRegistryWithinRegistryLock();
+  await withRegistryLock(async (lockedPaths) => {
+    const registry = await readPortableRegistryWithinRegistryLock(lockedPaths);
     registry.appliedManifestVersion = version;
-    await writePortableRegistry(registry);
+    await writePortableRegistry(registry, lockedPaths);
   });
 }
 async function removeInstallationsByFilter(predicate) {
-  return withRegistryLock(async () => {
-    const registry = await readPortableRegistryWithinRegistryLock();
+  return withRegistryLock(async (lockedPaths) => {
+    const registry = await readPortableRegistryWithinRegistryLock(lockedPaths);
     const removed = [];
     registry.installations = registry.installations.filter((entry) => {
       if (predicate(entry)) {
@@ -13306,14 +13306,14 @@ async function removeInstallationsByFilter(predicate) {
       return true;
     });
     if (removed.length > 0) {
-      await writePortableRegistry(registry);
+      await writePortableRegistry(registry, lockedPaths);
     }
     return removed;
   });
 }
 async function syncPortableRegistry() {
-  return withRegistryLock(async () => {
-    const registry = await readPortableRegistryWithinRegistryLock();
+  return withRegistryLock(async (lockedPaths) => {
+    const registry = await readPortableRegistryWithinRegistryLock(lockedPaths);
     const removed = [];
     registry.installations = registry.installations.filter((i) => {
       if (!existsSync3(i.path)) {
@@ -13323,7 +13323,7 @@ async function syncPortableRegistry() {
       return true;
     });
     if (removed.length > 0) {
-      await writePortableRegistry(registry);
+      await writePortableRegistry(registry, lockedPaths);
     }
     return { removed };
   });
@@ -63852,7 +63852,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.3.1-dev.18",
+    version: "4.3.1-dev.19",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -63868,6 +63868,7 @@ var init_package = __esm(() => {
     },
     files: [
       "bin/ck.js",
+      "bin/postinstall-hook-restore.cjs",
       "bin/postinstall-self-heal.cjs",
       "dist/index.js",
       "dist/ui/",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claudekit-cli",
-	"version": "4.3.1-dev.18",
+	"version": "4.3.1-dev.19",
 	"description": "CLI tool for bootstrapping and updating ClaudeKit projects",
 	"type": "module",
 	"repository": {
@@ -16,6 +16,7 @@
 	},
 	"files": [
 		"bin/ck.js",
+		"bin/postinstall-hook-restore.cjs",
 		"bin/postinstall-self-heal.cjs",
 		"dist/index.js",
 		"dist/ui/",