claude-dev-env 8.38.1 → 8.38.2

package/bin/install.mjs

@@ -1319,7 +1319,9 @@ function managedPackageSourceRoots() {
  * @param {Set<string>} managedHookRelativePaths Managed script paths under hooks/.
  * @returns {boolean} True when the command references a managed script.
  */
-export function commandReferencesManagedHook(commandString, managedHookRelativePaths) {
+export function commandReferencesManagedHook(
+    commandString, managedHookRelativePaths, sharedSettingsRealPath = null,
+) {
     if (typeof commandString !== 'string') return false;
     const normalizedCommand = commandString.replace(/\\/g, '/');
     if (commandIsInlineManagedValidatorRunner(normalizedCommand)) {
@@ -1329,6 +1331,51 @@ export function commandReferencesManagedHook(commandString, managedHookRelativeP
         if (commandTailEndsAtManagedHook(normalizedCommand, relativePath)) {
             return true;
         }
+        if (
+            sharedSettingsRealPath
+            && commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, sharedSettingsRealPath)
+        ) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Report whether a command runs `<root>/hooks/<relative>` for a root whose
+ * settings.json resolves to the given settings file.
+ *
+ * Two install roots can share one settings.json through a symlink. Each install
+ * writes its own hooks directory into that one file, so the merge treats the
+ * hooks of every root that shares the file as managed and keeps one entry per
+ * script.
+ *
+ * @param {string} normalizedCommand Forward-slash-normalized hook command.
+ * @param {string} relativePath The managed script path under hooks/.
+ * @param {string} sharedSettingsRealPath The resolved path of the settings file being merged.
+ * @returns {boolean} True when the command runs that script under a sharing root.
+ */
+function commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, sharedSettingsRealPath) {
+    const commandArgumentBoundary = /[\s'";]/;
+    const hookPathTail = `/${MANAGED_HOOKS_DIRECTORY_NAME}/${relativePath}`;
+    const sharedSettingsKey = comparisonKeyForPath(sharedSettingsRealPath);
+    let tailStart = normalizedCommand.indexOf(hookPathTail);
+    while (tailStart !== -1) {
+        const characterAfterPath = normalizedCommand[tailStart + hookPathTail.length];
+        if (characterAfterPath === undefined || commandArgumentBoundary.test(characterAfterPath)) {
+            let rootStart = tailStart;
+            while (rootStart > 0 && !commandArgumentBoundary.test(normalizedCommand[rootStart - 1])) {
+                rootStart--;
+            }
+            const rootPath = normalizedCommand.slice(rootStart, tailStart);
+            const rootSettingsRealPath = rootPath
+                ? realPathOrNull(join(rootPath, SETTINGS_FILE_NAME))
+                : null;
+            if (rootSettingsRealPath && comparisonKeyForPath(rootSettingsRealPath) === sharedSettingsKey) {
+                return true;
+            }
+        }
+        tailStart = normalizedCommand.indexOf(hookPathTail, tailStart + 1);
     }
     return false;
 }
@@ -1399,14 +1446,17 @@ export function commandIsInlineManagedValidatorRunner(normalizedCommand) {
  * @param {object} settings The parsed settings.json object (mutated in place).
  * @param {string} eventType The lifecycle event whose groups are pruned.
  * @param {Set<string>} managedHookRelativePaths Managed script paths under hooks/.
+ * @param {string|null} sharedSettingsRealPath Resolved path of the settings file, or null.
  * @returns {void}
  */
-function pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths) {
+function pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths, sharedSettingsRealPath) {
     const existingGroups = settings.hooks[eventType];
     if (!Array.isArray(existingGroups)) return;
     settings.hooks[eventType] = retainedMatcherGroups(
         existingGroups,
-        commandString => commandReferencesManagedHook(commandString, managedHookRelativePaths),
+        commandString => commandReferencesManagedHook(
+            commandString, managedHookRelativePaths, sharedSettingsRealPath,
+        ),
     ).keptGroups;
 }
 
@@ -1457,9 +1507,14 @@ function startEventFromHookGroupList(settings, eventType) {
  * @param {string} pluginRootDir Directory ${CLAUDE_PLUGIN_ROOT} resolves to
  *   (the installer's `~/.claude` root; home is its parent directory).
  * @param {string} pythonCommand Interpreter command that replaces python3.
+ * @param {string|null} [sharedSettingsRealPath] Resolved path of the settings
+ *   file being merged. Hooks of every root whose settings.json resolves to it
+ *   count as managed, so roots sharing one file keep one entry per script.
  * @returns {number} Count of matcher groups merged.
  */
-export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pythonCommand) {
+export function mergeHooksIntoSettings(
+    settings, hooksConfig, pluginRootDir, pythonCommand, sharedSettingsRealPath = null,
+) {
     const managedHookRelativePaths = managedHookScriptRelativePaths(hooksConfig);
     const pluginRootForward = pluginRootDir.replace(/\\/g, '/');
     const encodedPluginHooksPath = Buffer.from(`${pluginRootForward}/hooks`, 'utf8').toString('base64');
@@ -1467,7 +1522,7 @@ export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pyt
     let groupCount = 0;
     for (const [eventType, matcherGroups] of Object.entries(hooksConfig.hooks)) {
         startEventFromHookGroupList(settings, eventType);
-        pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths);
+        pruneManagedHooksFromEvent(settings, eventType, managedHookRelativePaths, sharedSettingsRealPath);
         for (const sourceGroup of matcherGroups) {
             const rewrittenHooks = sourceGroup.hooks.map(hook => {
                 let command = hook.command;
@@ -1492,7 +1547,9 @@ export function mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pyt
             if (existingIndex >= 0) {
                 const existing = settings.hooks[eventType][existingIndex];
                 const userHooks = (groupHookEntries(existing) || []).filter(
-                    hook => !commandReferencesManagedHook(hook?.command, managedHookRelativePaths)
+                    hook => !commandReferencesManagedHook(
+                        hook?.command, managedHookRelativePaths, sharedSettingsRealPath,
+                    )
                 );
                 settings.hooks[eventType][existingIndex] = {
                     ...existing,
@@ -2079,7 +2136,9 @@ function mergeHooksAtPath(
         pruneManagedHooksFromSettings(settings, new Set());
     }
     const hooksConfig = selectHooksConfig(sourceHooksConfig);
-    const groupCount = mergeHooksIntoSettings(settings, hooksConfig, pluginRootDir, pythonCommand);
+    const groupCount = mergeHooksIntoSettings(
+        settings, hooksConfig, pluginRootDir, pythonCommand, realPathOrNull(settingsPath),
+    );
     writeFileSync(settingsPath, JSON.stringify(settings, null, indentation) + '\n');
     return groupCount;
 }

package/bin/install.shared-settings.test.mjs

@@ -0,0 +1,202 @@
+/**
+ * Two install roots that share one settings.json through a symlink keep one
+ * hook entry per managed script, whatever order the roots install in.
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { join } from 'node:path';
+import {
+    mkdtempSync,
+    mkdirSync,
+    readFileSync,
+    rmSync,
+    symlinkSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { managedHookScriptRelativePaths, mergeHooksIntoSettings } from './install.mjs';
+
+const INSTALLER_PATH = fileURLToPath(new URL('./install.mjs', import.meta.url));
+const PACKAGE_HOOKS_JSON_PATH = fileURLToPath(new URL('../hooks/hooks.json', import.meta.url));
+
+function installEnvironment(homeDirectory) {
+    return {
+        ...process.env,
+        HOME: homeDirectory,
+        USERPROFILE: homeDirectory,
+        CLAUDE_CONFIG_DIR: '',
+        GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CDE_INSTALL_PSTACK: '0',
+        CDE_INSTALL_USAGE_WRAPUP: '0',
+    };
+}
+
+function runCoreInstall(homeDirectory, extraArguments) {
+    const installRun = spawnSync(
+        process.execPath,
+        [INSTALLER_PATH, '--only', 'core', ...extraArguments],
+        { encoding: 'utf8', env: installEnvironment(homeDirectory) },
+    );
+    assert.equal(installRun.status, 0, installRun.stdout + installRun.stderr);
+}
+
+function allHookCommands(settingsPath) {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const allCommands = [];
+    for (const matcherGroups of Object.values(settings.hooks ?? {})) {
+        for (const group of matcherGroups) {
+            for (const hook of group.hooks ?? []) {
+                if (typeof hook.command === 'string') allCommands.push(hook.command.replace(/\\/g, '/'));
+            }
+        }
+    }
+    return allCommands;
+}
+
+function entryCountByScript(settingsPath) {
+    const hooksConfig = JSON.parse(readFileSync(PACKAGE_HOOKS_JSON_PATH, 'utf8'));
+    const allCommands = allHookCommands(settingsPath);
+    const countByScript = new Map();
+    for (const relativePath of managedHookScriptRelativePaths(hooksConfig)) {
+        const scriptPattern = new RegExp(`/hooks/${relativePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=$|[\\s'";])`, 'g');
+        const occurrences = allCommands.reduce(
+            (total, command) => total + (command.match(scriptPattern) ?? []).length,
+            0,
+        );
+        countByScript.set(relativePath, occurrences);
+    }
+    return countByScript;
+}
+
+function expectedCountByScript(hooksConfig) {
+    const countByScript = new Map();
+    for (const matcherGroups of Object.values(hooksConfig.hooks)) {
+        for (const group of matcherGroups) {
+            for (const hook of group.hooks) {
+                for (const match of hook.command.matchAll(/\$\{CLAUDE_PLUGIN_ROOT\}\/hooks\/(\S+?\.(?:py|mjs))/g)) {
+                    countByScript.set(match[1], (countByScript.get(match[1]) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    return countByScript;
+}
+
+function assertOneEntryPerHookRegistration(settingsPath, stageName) {
+    const hooksConfig = JSON.parse(readFileSync(PACKAGE_HOOKS_JSON_PATH, 'utf8'));
+    const expectedCounts = expectedCountByScript(hooksConfig);
+    const actualCounts = entryCountByScript(settingsPath);
+    assert.ok(expectedCounts.size > 0, 'the package ships managed hook scripts');
+    for (const [relativePath, expectedCount] of expectedCounts) {
+        assert.equal(
+            actualCounts.get(relativePath),
+            expectedCount,
+            `${stageName}: ${relativePath} is registered once per hooks.json entry`,
+        );
+    }
+}
+
+function withSharedSettingsHome(runScenario) {
+    return t => {
+        const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-shared-settings-'));
+        try {
+            writeFileSync(join(homeDirectory, '.gitconfig'), '');
+            const mainRoot = join(homeDirectory, '.claude');
+            const profileRoot = join(homeDirectory, 'profiles', 'second');
+            mkdirSync(mainRoot, { recursive: true });
+            mkdirSync(profileRoot, { recursive: true });
+            const mainSettingsPath = join(mainRoot, 'settings.json');
+            writeFileSync(mainSettingsPath, '{}\n');
+            try {
+                symlinkSync(mainSettingsPath, join(profileRoot, 'settings.json'), 'file');
+            } catch (linkError) {
+                t.skip(`this host cannot create a file symlink (${linkError.code})`);
+                return;
+            }
+            runScenario({ homeDirectory, profileRoot, mainSettingsPath });
+        } finally {
+            rmSync(homeDirectory, { recursive: true, force: true });
+        }
+    };
+}
+
+test(
+    'main then profile then main keeps one entry per hook in the shared settings file',
+    withSharedSettingsHome(({ homeDirectory, profileRoot, mainSettingsPath }) => {
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main install');
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile install');
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main rerun');
+    }),
+);
+
+test(
+    'profile then main then profile keeps one entry per hook in the shared settings file',
+    withSharedSettingsHome(({ homeDirectory, profileRoot, mainSettingsPath }) => {
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile install');
+        runCoreInstall(homeDirectory, []);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the main install');
+        runCoreInstall(homeDirectory, ['--target', profileRoot]);
+        assertOneEntryPerHookRegistration(mainSettingsPath, 'after the profile rerun');
+    }),
+);
+
+test('the merge prunes a hook of a root sharing the settings file and keeps one with its own file', t => {
+    const sandboxRoot = mkdtempSync(join(tmpdir(), 'cdev-shared-settings-unit-'));
+    try {
+        const installRoot = join(sandboxRoot, 'install-root');
+        const sharingRoot = join(sandboxRoot, 'sharing-root');
+        const separateRoot = join(sandboxRoot, 'separate-root');
+        for (const eachRoot of [installRoot, sharingRoot, separateRoot]) mkdirSync(eachRoot, { recursive: true });
+        const settingsPath = join(installRoot, 'settings.json');
+        writeFileSync(settingsPath, '{}\n');
+        writeFileSync(join(separateRoot, 'settings.json'), '{}\n');
+        try {
+            symlinkSync(settingsPath, join(sharingRoot, 'settings.json'), 'file');
+        } catch (linkError) {
+            t.skip(`this host cannot create a file symlink (${linkError.code})`);
+            return;
+        }
+        const hooksConfig = {
+            hooks: {
+                SessionStart: [{
+                    matcher: '',
+                    hooks: [{ type: 'command', command: 'python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/start.py' }],
+                }],
+            },
+        };
+        const forwardSlashed = rootPath => rootPath.replace(/\\/g, '/');
+        const sharingCommand = `python3 "${forwardSlashed(sharingRoot)}/hooks/session/start.py"`;
+        const separateCommand = `python3 "${forwardSlashed(separateRoot)}/hooks/session/start.py"`;
+        const settings = {
+            hooks: {
+                SessionStart: [{
+                    matcher: '',
+                    hooks: [
+                        { type: 'command', command: sharingCommand },
+                        { type: 'command', command: separateCommand },
+                    ],
+                }],
+            },
+        };
+
+        mergeHooksIntoSettings(settings, hooksConfig, forwardSlashed(installRoot), 'python3', settingsPath);
+
+        const allCommands = settings.hooks.SessionStart.flatMap(group => group.hooks.map(hook => hook.command));
+        assert.ok(!allCommands.includes(sharingCommand), 'the sharing root entry is pruned');
+        assert.ok(allCommands.includes(separateCommand), 'the separate root entry stays');
+        assert.equal(
+            allCommands.filter(command => command.includes(`${forwardSlashed(installRoot)}/hooks/session/start.py`)).length,
+            1,
+            'the install root entry is written once',
+        );
+    } finally {
+        rmSync(sandboxRoot, { recursive: true, force: true });
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.38.1",
+    "version": "8.38.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {