claude-dev-env 8.35.1 → 8.35.3

package/bin/install.mjs

@@ -76,6 +76,7 @@ import {
 } from './resolve-package-managed-directory.mjs';
 import {
     ensureDirectoryPointer,
+    POINTER_ACTION_CREATED,
 } from './publish-directory-pointer.mjs';
 import {
     parseInstallTargetSelectionFromArgv,
@@ -872,7 +873,11 @@ function owningManagedRoot(installedFilePath) {
  * so those two paths are pointers. A real directory from an older install at a
  * lookup path is merged into the agents home before the pointer is written.
  *
- * @returns {string[]} The lookup paths this run published.
+ * A pointer that already aimed at its target is left out of the result, so a
+ * rollback that removes this run's written paths keeps the pointer a prior
+ * install published.
+ *
+ * @returns {string[]} The lookup paths this run created.
  */
 function publishManagedLookupPointers() {
     const pointerPairs = [
@@ -897,10 +902,10 @@ function publishManagedLookupPointers() {
             INSTALL_ROOT_RESOLUTION.hooksInstallDirectory,
         ],
     ];
-    for (const [pointerPath, targetPath] of pointerPairs) {
-        ensureDirectoryPointer(pointerPath, targetPath);
-    }
-    return pointerPairs.map(([pointerPath]) => pointerPath);
+    return pointerPairs
+        .map(([pointerPath, targetPath]) => ensureDirectoryPointer(pointerPath, targetPath))
+        .filter((pointerResult) => pointerResult.action === POINTER_ACTION_CREATED)
+        .map((pointerResult) => pointerResult.pointerPath);
 }
 
 /**

package/bin/install.transaction.test.mjs

@@ -6,9 +6,11 @@ import { test } from 'node:test';
 import { strict as assert } from 'node:assert';
 import {
     existsSync,
+    lstatSync,
     mkdtempSync,
     mkdirSync,
     readFileSync,
+    realpathSync,
     rmSync,
     writeFileSync,
 } from 'node:fs';
@@ -501,3 +503,44 @@ test('successful install after prior install leaves one manifest and no fault',
         rmSync(homeDirectory, { recursive: true, force: true });
     }
 });
+
+test('installer fault keeps the lookup pointers a prior install published', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-txn-e2e-pointers-'));
+    try {
+        writeFileSync(join(homeDirectory, '.gitconfig'), '');
+        const homeOnlyEnvironment = { CLAUDE_CONFIG_DIR: '' };
+        const okRun = runInstaller(homeDirectory, ['--only', 'core'], {
+            environment: homeOnlyEnvironment,
+        });
+        assert.equal(okRun.status, 0, okRun.stdout + okRun.stderr);
+        const allPointerTargets = [
+            ...['skills', 'agents', 'hooks', 'scripts'].map((name) => ({
+                pointerPath: join(homeDirectory, '.claude', name),
+                targetPath: realpathSync(join(homeDirectory, '.agents', name)),
+            })),
+            {
+                pointerPath: join(homeDirectory, '.codex', 'hooks'),
+                targetPath: realpathSync(join(homeDirectory, '.agents', 'hooks')),
+            },
+        ];
+
+        for (const faultPhase of [FAULT_PHASES.AFTER_FILE_STAGING, FAULT_PHASES.AFTER_MANIFEST_WRITE]) {
+            const failedRun = runInstaller(homeDirectory, ['--only', 'core'], {
+                faultPhase,
+                environment: homeOnlyEnvironment,
+            });
+            assert.notEqual(failedRun.status, 0, failedRun.stdout + failedRun.stderr);
+            assert.match(`${failedRun.stdout}${failedRun.stderr}`, /prior installation restored/);
+            for (const { pointerPath, targetPath } of allPointerTargets) {
+                assert.equal(
+                    lstatSync(pointerPath, { throwIfNoEntry: false })?.isSymbolicLink(),
+                    true,
+                    `${pointerPath} survives a fault at ${faultPhase}`,
+                );
+                assert.equal(realpathSync(pointerPath), targetPath);
+            }
+        }
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});

package/hooks/validation/mypy_validator.py

@@ -13,7 +13,6 @@ Project root is discovered via CLAUDE_PROJECT_ROOT env var or git rev-parse.
 """
 
 import hashlib
-import importlib
 import json
 import os
 import platform
@@ -21,13 +20,9 @@ import stat
 import subprocess
 import sys
 from pathlib import Path
-from types import ModuleType
 
 _hooks_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
-_notification_utils_directory = os.path.join(_hooks_directory, "notification")
-sys.path.insert(0, _notification_utils_directory)
-
 _validators_directory = os.path.join(_hooks_directory, "validators")
 if _validators_directory not in sys.path:
     sys.path.insert(0, _validators_directory)
@@ -59,14 +54,6 @@ from json_file_reader import read_json_object  # noqa: E402
 
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 
-
-def load_notification_utils() -> ModuleType | None:
-    try:
-        return importlib.import_module("notification_utils")
-    except ImportError:
-        return None
-
-
 IS_WINDOWS = platform.system() == "Windows"
 
 GIT_COMMAND_TIMEOUT_SECONDS = 5
@@ -530,25 +517,6 @@ def format_error_summary(all_error_lines: list[str]) -> str:
     return error_summary
 
 
-def send_block_notification(error_summary: str) -> None:
-    notification_module = load_notification_utils()
-    if notification_module is None:
-        return
-
-    notification_title = "Mypy Type Errors"
-    notification_body = f"Write blocked: {error_summary[:200]}"
-
-    try:
-        if notification_module.is_wsl():
-            notification_module.notify_wsl(notification_title, notification_body)
-        elif platform.system() == "Linux":
-            notification_module.notify_linux()
-        elif platform.system() == "Windows":
-            notification_module.notify_windows(notification_title, notification_body)
-    except (AttributeError, OSError):
-        pass
-
-
 def build_block_response(error_summary: str) -> dict[str, str | dict[str, str]]:
     return {
         "decision": "block",
@@ -615,7 +583,6 @@ def main() -> None:
         sys.exit(0)
 
     error_summary = format_error_summary(all_error_lines)
-    send_block_notification(error_summary)
     block_response = build_block_response(error_summary)
     log_hook_block(
         calling_hook_name="mypy_validator.py",

package/hooks/validation/test_mypy_validator_toast.py

@@ -0,0 +1,77 @@
+"""The mypy_validator hook reports a block through its reply and nothing else.
+
+An install from before the package dropped ``hooks/notification`` keeps
+``notification_utils.py`` on disk. This test puts a recording stand-in for
+that module on the import path and checks a blocked write never reads it.
+"""
+
+import importlib.util
+import io
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+HOOK_PATH = Path(__file__).resolve().parent / "mypy_validator.py"
+TYPE_ERROR_MODULE_SOURCE = 'value: int = "not an integer"\n'
+
+
+def _load_validator() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("mypy_validator_toast_under_test", HOOK_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _build_recording_notification_module(all_touched_names: list[str]) -> ModuleType:
+    class RecordingNotificationModule(ModuleType):
+        def __getattr__(self, attribute_name: str) -> object:
+            if not attribute_name.startswith("__"):
+                all_touched_names.append(attribute_name)
+            return lambda *_arguments, **_options: False
+
+    return RecordingNotificationModule("notification_utils")
+
+
+def test_type_error_block_opens_no_desktop_toast(
+    tmp_path_factory: pytest.TempPathFactory,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """A blocked write reports through the hook reply and leaves the desktop alone.
+
+    ::
+
+        mypy typed_module.py  ->  error: Incompatible types
+        ok:   {"decision": "block"} on stdout, notification_utils untouched
+        flag: notify_windows() opens a toast window at the bottom of the screen
+    """
+    validator = _load_validator()
+    project_root = tmp_path_factory.mktemp("blocked_project")
+    target_file = project_root / "typed_module.py"
+    target_file.write_text(TYPE_ERROR_MODULE_SOURCE, encoding="utf-8")
+    all_touched_names: list[str] = []
+    monkeypatch.setitem(
+        sys.modules,
+        "notification_utils",
+        _build_recording_notification_module(all_touched_names),
+    )
+    monkeypatch.setattr(validator, "discover_project_root", lambda _target: project_root)
+    monkeypatch.setattr(
+        validator,
+        "run_mypy",
+        lambda _target, _root: (1, f"{target_file}:1: error: Incompatible types\n"),
+    )
+    monkeypatch.setattr(validator, "log_hook_block", lambda **_details: None)
+    monkeypatch.setattr(
+        sys, "stdin", io.StringIO(json.dumps({"tool_input": {"file_path": str(target_file)}}))
+    )
+
+    with pytest.raises(SystemExit):
+        validator.main()
+
+    assert json.loads(capsys.readouterr().out)["decision"] == "block"
+    assert all_touched_names == []

package/hooks/workflow/auto_formatter.py

@@ -4,15 +4,12 @@
 
 from __future__ import annotations
 
-import importlib
 import json
 import os
-import platform
 import subprocess
 import sys
 from collections.abc import Mapping
 from pathlib import Path
-from types import ModuleType
 
 _subprocess_window_hooks_directory = str(Path(__file__).resolve().parents[2] / "hooks")
 if _subprocess_window_hooks_directory not in sys.path:
@@ -20,11 +17,6 @@ if _subprocess_window_hooks_directory not in sys.path:
 
 from hooks_constants.subprocess_window import hidden_window_creation_flags
 
-NOTIFICATION_UTILS_DIRECTORY = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "notification"
-)
-sys.path.insert(0, NOTIFICATION_UTILS_DIRECTORY)
-
 PYTHON_EXTENSIONS = frozenset({".py"})
 JS_EXTENSIONS = frozenset({".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs"})
 JSON_EXTENSIONS = frozenset({".json"})
@@ -57,32 +49,6 @@ PRETTIER_CONFIG_NAMES = frozenset(
 )
 
 
-def load_notification_utils() -> ModuleType | None:
-    try:
-        return importlib.import_module("notification_utils")
-    except ImportError:
-        return None
-
-
-def send_format_notification(file_path: str, formatter_name: str) -> None:
-    notification_module = load_notification_utils()
-    if notification_module is None:
-        return
-
-    notification_title = "Auto-Formatter"
-    notification_body = f"{formatter_name} formatted: {Path(file_path).name}"
-
-    try:
-        if notification_module.is_wsl():
-            notification_module.notify_wsl(notification_title, notification_body)
-        elif platform.system() == "Linux":
-            notification_module.notify_linux()
-        elif platform.system() == "Windows":
-            notification_module.notify_windows(notification_title, notification_body)
-    except (AttributeError, OSError):
-        pass
-
-
 def has_prettier_config(file_path: str) -> bool:
     each_ancestor = Path(file_path).resolve().parent
     while True:
@@ -249,16 +215,9 @@ def _run_python_format_commands(file_path: str) -> None:
         if did_timeout:
             return
         if completed_process is not None and completed_process.returncode == 0:
-            send_format_notification(file_path, formatter_name_for_command(each_command))
             return
 
 
-def formatter_name_for_command(command: list[str]) -> str:
-    if command[0] == sys.executable:
-        return command[2]
-    return command[0]
-
-
 def _run_prettier(file_path: str) -> None:
     prettier_command = [
         NPX_EXECUTABLE,
@@ -267,11 +226,7 @@ def _run_prettier(file_path: str) -> None:
         "--write",
         os.path.realpath(file_path),
     ]
-    completed_process, _did_timeout = _run_command(
-        prettier_command, file_path, JS_FORMAT_TIMEOUT_SECONDS
-    )
-    if completed_process is not None and completed_process.returncode == 0:
-        send_format_notification(file_path, PRETTIER_FORMATTER_NAME)
+    _run_command(prettier_command, file_path, JS_FORMAT_TIMEOUT_SECONDS)
 
 
 def run_eligible_formatter(file_path: str) -> None:

package/hooks/workflow/test_auto_formatter_toast.py

@@ -0,0 +1,67 @@
+"""The auto_formatter hook leaves the desktop alone after a format.
+
+An install from before the package dropped ``hooks/notification`` keeps
+``notification_utils.py`` on disk. These tests put a recording stand-in for
+that module on the import path and check the hook never reads it.
+"""
+
+import importlib.util
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+HOOK_SCRIPT_PATH = Path(__file__).resolve().parent / "auto_formatter.py"
+
+
+def _load_auto_formatter_module() -> ModuleType:
+    module_spec = importlib.util.spec_from_file_location(
+        "auto_formatter_toast_under_test", HOOK_SCRIPT_PATH
+    )
+    assert module_spec is not None and module_spec.loader is not None
+    auto_formatter_module = importlib.util.module_from_spec(module_spec)
+    module_spec.loader.exec_module(auto_formatter_module)
+    return auto_formatter_module
+
+
+def _build_recording_notification_module(all_touched_names: list[str]) -> ModuleType:
+    class RecordingNotificationModule(ModuleType):
+        def __getattr__(self, attribute_name: str) -> object:
+            if not attribute_name.startswith("__"):
+                all_touched_names.append(attribute_name)
+            return lambda *_arguments, **_options: False
+
+    return RecordingNotificationModule("notification_utils")
+
+
+def test_successful_format_opens_no_desktop_toast(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A stale notification_utils on the import path stays untouched after a format.
+
+    ::
+
+        ~/.claude/hooks/notification/notification_utils.py   left behind by an old install
+        ruff format module.py  ->  exit 0
+        ok:   nothing reads notification_utils
+        flag: notify_windows() opens a toast window at the bottom of the screen
+    """
+    auto_formatter_module = _load_auto_formatter_module()
+    all_touched_names: list[str] = []
+    monkeypatch.setitem(
+        sys.modules,
+        "notification_utils",
+        _build_recording_notification_module(all_touched_names),
+    )
+
+    def report_formatter_success(
+        command: list[str], _file_path: str, _timeout_seconds: int
+    ) -> tuple[subprocess.CompletedProcess[str], bool]:
+        return subprocess.CompletedProcess(command, 0, "", ""), False
+
+    monkeypatch.setattr(auto_formatter_module, "_run_command", report_formatter_success)
+
+    auto_formatter_module.run_eligible_formatter("formatted_module.py")
+    auto_formatter_module._run_prettier("formatted_module.js")
+
+    assert all_touched_names == []

package/package.json

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