claude-dev-env 8.43.4 → 8.43.5

package/bin/install.mjs

@@ -1363,15 +1363,16 @@ function commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, s
     while (tailStart !== -1) {
         const characterAfterPath = normalizedCommand[tailStart + hookPathTail.length];
         if (characterAfterPath === undefined || commandArgumentBoundary.test(characterAfterPath)) {
-            let rootStart = tailStart;
+            let rootPath;
             if (characterAfterPath === '"' || characterAfterPath === "'") {
-                rootStart = normalizedCommand.lastIndexOf(characterAfterPath, tailStart - 1) + 1;
+                rootPath = quotedRootPathBeforeTail(normalizedCommand.slice(0, tailStart), characterAfterPath);
             } else {
+                let rootStart = tailStart;
                 while (rootStart > 0 && !commandArgumentBoundary.test(normalizedCommand[rootStart - 1])) {
                     rootStart--;
                 }
+                rootPath = normalizedCommand.slice(rootStart, tailStart);
             }
-            const rootPath = normalizedCommand.slice(rootStart, tailStart);
             const rootSettingsRealPath = rootPath
                 ? realPathOrNull(join(rootPath, SETTINGS_FILE_NAME))
                 : null;
@@ -1384,6 +1385,41 @@ function commandRunsHookOfRootSharingSettings(normalizedCommand, relativePath, s
     return false;
 }
 
+/**
+ * How each quote style of a hook path argument joins the segments around an
+ * escaped character, keyed by the quote, in the forward-slash command form.
+ */
+const QUOTED_ARGUMENT_ESCAPES = {
+    '"': { segmentJoin: '"^%"', joinedCharacter: '%' },
+    "'": { segmentJoin: "'/''", joinedCharacter: "'" },
+};
+
+/**
+ * Decode the root part of a quoted argument that `commandArgumentFromPath`
+ * wrote, read from the command text that ends where the hook path tail starts.
+ *
+ * The win32 form splits a path at each `%` into `"a"^%"b"`. The POSIX form
+ * escapes each `'` as `'\''`, which reads `'/''` once backslashes become
+ * forward slashes.
+ *
+ * @param {string} commandBeforeTail Normalized command text up to the hook path tail.
+ * @param {string} closingQuote The quote that closes the argument after the tail.
+ * @returns {string} The root path with each escaped character restored.
+ */
+function quotedRootPathBeforeTail(commandBeforeTail, closingQuote) {
+    const { segmentJoin, joinedCharacter } = QUOTED_ARGUMENT_ESCAPES[closingQuote];
+    const segments = [];
+    let segmentEnd = commandBeforeTail.length;
+    let openingQuote = commandBeforeTail.lastIndexOf(closingQuote, segmentEnd - 1);
+    while (commandBeforeTail.slice(openingQuote - segmentJoin.length + 1, openingQuote + 1) === segmentJoin) {
+        segments.unshift(commandBeforeTail.slice(openingQuote + 1, segmentEnd));
+        segmentEnd = openingQuote - segmentJoin.length + 1;
+        openingQuote = commandBeforeTail.lastIndexOf(closingQuote, segmentEnd - 1);
+    }
+    segments.unshift(commandBeforeTail.slice(openingQuote + 1, segmentEnd));
+    return segments.join(joinedCharacter);
+}
+
 function commandTailEndsAtManagedHook(normalizedCommand, relativePath) {
     if (commandHoldsPathAtBoundary(normalizedCommand, `/.claude/hooks/${relativePath}`)) {
         return true;

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

@@ -243,3 +243,49 @@ test('the merge prunes a quoted hook of a sharing root whose path holds a space'
         rmSync(sandboxRoot, { recursive: true, force: true });
     }
 });
+
+for (const { shape, rootDirectoryName, platform } of [
+    { shape: 'a percent sign', rootDirectoryName: 'Jane 100% Doe', platform: 'win32' },
+    { shape: 'an apostrophe', rootDirectoryName: "Jane O'Doe", platform: 'linux' },
+]) {
+    test(`the merge prunes a ${platform}-quoted hook of a sharing root whose path holds ${shape}`, t => {
+        const sandboxRoot = mkdtempSync(join(tmpdir(), 'cdev-shared-settings-escape-'));
+        try {
+            const installRoot = join(sandboxRoot, 'install-root');
+            const sharingRoot = join(sandboxRoot, rootDirectoryName, 'profiles', 'second');
+            for (const eachRoot of [installRoot, sharingRoot]) mkdirSync(eachRoot, { recursive: true });
+            const settingsPath = join(installRoot, 'settings.json');
+            writeFileSync(settingsPath, '{}\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 sharingHookPath = `${forwardSlashed(sharingRoot)}/hooks/session/start.py`;
+            const sharingCommand = `python3 ${commandArgumentFromPath(sharingHookPath, platform)}`;
+            const settings = {
+                hooks: {
+                    SessionStart: [{ matcher: '', hooks: [{ type: 'command', command: sharingCommand }] }],
+                },
+            };
+
+            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 ${sharingCommand} is pruned`);
+            assert.equal(allCommands.length, 1, 'only the install root entry stays after the merge');
+        } finally {
+            rmSync(sandboxRoot, { recursive: true, force: true });
+        }
+    });
+}

package/package.json

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

package/scripts/policy_lint/config/approved_test_pairs.py

@@ -23,6 +23,7 @@ APPROVED_TEST_PATHS_BY_PRODUCTION_PATH: dict[
         {
             PurePosixPath("packages/claude-dev-env/bin/install.agents-home.test.mjs"),
             PurePosixPath("packages/claude-dev-env/bin/install.cursor-rules.test.mjs"),
+            PurePosixPath("packages/claude-dev-env/bin/install.shared-settings.test.mjs"),
         }
     ),
     PurePosixPath(

package/scripts/tests/test_policy_lint_rules_pairing.py

@@ -557,6 +557,19 @@ def test_pairing_accepts_installer_module_with_the_agents_home_suite(
     assert all_paths == ()
 
 
+def test_pairing_accepts_installer_module_with_the_shared_settings_suite(
+    tmp_path: Path,
+) -> None:
+    all_paths = _diagnostic_paths(
+        tmp_path,
+        _body_change_at(_INSTALLER_MODULE_PATH),
+        _body_change_at(
+            PurePosixPath("packages/claude-dev-env/bin/install.shared-settings.test.mjs")
+        ),
+    )
+    assert all_paths == ()
+
+
 _COMMENT_RULES_PRODUCTION_PATH = PurePosixPath(
     "packages/claude-dev-env/hooks/blocking/code_rules_comments.py"
 )