claude-dev-env 8.48.1 → 8.48.3

package/bin/install-plan.mjs

@@ -214,7 +214,6 @@ export function preflightSettingsIfNeeded(settingsPath, shouldInstallHooks, io =
  */
 export function buildInstallPlan(input) {
     const io = input.io || {};
-    const exists = io.existsSync || existsSync;
     const packageName = input.packageName || 'claude-dev-env';
 
     preflightManagedRoot(input.managedRoot, io);
@@ -250,9 +249,6 @@ export function buildInstallPlan(input) {
     preflightSettingsIfNeeded(settingsPath, shouldInstallHooks, io);
 
     const isUpdateRefresh = Boolean(input.isUpdateRefresh);
-    const shouldPurgeBeforeReinstall = isUpdateRefresh
-        && !input.selectedGroups
-        && exists(input.manifestFilePath);
 
     return Object.freeze({
         packageRoot: input.packageRoot,
@@ -261,7 +257,6 @@ export function buildInstallPlan(input) {
         targetIdentity: input.targetIdentity,
         selectedGroups: input.selectedGroups,
         isUpdateRefresh,
-        shouldPurgeBeforeReinstall,
         pythonCommand,
         shouldInstallHooks,
         priorManifest: Object.freeze({
@@ -277,7 +272,6 @@ export function buildInstallPlan(input) {
  * High-level mutation kinds the executor applies for this plan (E2 surface).
  *
  * @param {{
- *   shouldPurgeBeforeReinstall: boolean,
  *   shouldInstallHooks: boolean,
  *   selectedGroups: string[]|null,
  * }} plan
@@ -286,9 +280,6 @@ export function buildInstallPlan(input) {
 export function describeInstallMutations(plan) {
     /** @type {string[]} */
     const allMutations = [];
-    if (plan.shouldPurgeBeforeReinstall) {
-        allMutations.push('purge_managed_installation');
-    }
     allMutations.push(
         'ensure_managed_root',
         'publish_directory_pointers',

package/bin/install.mjs

@@ -2597,7 +2597,7 @@ function runFullInstallPrunes(
  * available to a later prune and to uninstall.
  *
  * @param {string[]|null} selectedGroups The `--only` group names, or null for a full install.
- * @param {{isUpdateRefresh?: boolean}} [options] Run options; `isUpdateRefresh` purges before reinstalling.
+ * @param {{isUpdateRefresh?: boolean}} [options] Run options; `isUpdateRefresh` labels the run as an update in the log.
  * @returns {void}
  */
 function install(selectedGroups, options = {}) {
@@ -2674,15 +2674,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     const isUpdateRefresh = plan.isUpdateRefresh;
     const pythonCommand = plan.pythonCommand;
 
-    if (plan.shouldPurgeBeforeReinstall) {
-        console.log(
-            `${PACKAGE_NAME}: --update — removing prior managed files under ${CLAUDE_HOME}, then reinstalling from the package.\n`,
-        );
-        purgeManagedInstallation({
-            isManifestRequired: false,
-            throwIfFault,
-        });
-    } else if (isUpdateRefresh) {
+    if (isUpdateRefresh) {
         const installScope = selectedGroups ? `groups: ${selectedGroups.join(', ')}` : 'full';
         console.log(`${PACKAGE_NAME}: --update — re-running ${installScope} install into ${CLAUDE_HOME}\n`);
     }
@@ -3335,28 +3327,6 @@ function executeUninstallPlan(plan, helpers = {}) {
     return removed;
 }
 
-/**
- * Remove every file the ownership record lists for this managed root.
- *
- * Preflights the uninstall plan (settings JSON must be an object when present)
- * before any removal. When called from `--update` inside an install transaction,
- * pass that transaction's `throwIfFault` so a fault restores the outer snapshot
- * without nesting a second journal.
- *
- * @param {{
- *   isManifestRequired: boolean,
- *   throwIfFault?: (phase: string) => void,
- * }} options
- * @returns {number|void} 0 when no manifest exists and none is required.
- */
-function purgeManagedInstallation({ isManifestRequired, throwIfFault }) {
-    const plan = resolveUninstallPlan(isManifestRequired);
-    if (plan.isNoOp) {
-        return 0;
-    }
-    return executeUninstallPlan(plan, { throwIfFault });
-}
-
 /**
  * Uninstall the selected managed root inside a snapshot/restore transaction.
  *
@@ -3435,7 +3405,7 @@ ${PACKAGE_NAME} - Claude Code development standards installer
 
 Usage:
   npx ${PACKAGE_NAME}              Install everything into the main default root
-  npx ${PACKAGE_NAME} --update     Full install: remove prior manifest-tracked files first, then reinstall
+  npx ${PACKAGE_NAME} --update     Full install: copy the package over the prior install, then prune files it no longer ships
   npx ${PACKAGE_NAME} --only X     Install specific groups
   npx ${PACKAGE_NAME} --target DIR Install into DIR instead of ~/.claude (overrides CLAUDE_CONFIG_DIR)
   npx ${PACKAGE_NAME} --profile ID Install into one named profile root (under the profiles root)

package/bin/install.plan.test.mjs

@@ -91,7 +91,6 @@ test('buildInstallPlan is zero-write and freezes a success plan', () => {
         const plan = buildInstallPlan(planInput(packageRoot, managedRoot));
         assert.equal(plan.pythonCommand, 'python3');
         assert.equal(plan.shouldInstallHooks, true);
-        assert.equal(plan.shouldPurgeBeforeReinstall, false);
         assert.deepEqual(plan.priorManifest.skills, ['a']);
         assert.ok(Object.isFrozen(plan));
         assert.equal(treeStamp(managedRoot) + '//' + treeStamp(packageRoot), before);
@@ -166,7 +165,7 @@ test('settings preflight is hooks-gated; broken manifest stays tolerant', () =>
     }
 });
 
-test('update plan marks purge and lists E2 mutation kinds; journal omits hooks', () => {
+test('update plan copies before it prunes and never purges; journal omits hooks', () => {
     const { root, managedRoot, packageRoot } = sandbox();
     try {
         const manifestFilePath = join(managedRoot, '.claude-dev-env-manifest.json');
@@ -177,9 +176,11 @@ test('update plan marks purge and lists E2 mutation kinds; journal omits hooks',
             targetIdentity: 'profile-a',
             isUpdateRefresh: true,
         }));
-        assert.equal(plan.shouldPurgeBeforeReinstall, true);
         const allMutations = describeInstallMutations(plan);
-        assert.ok(allMutations.includes('purge_managed_installation'));
+        assert.ok(!allMutations.includes('purge_managed_installation'));
+        assert.ok(
+            allMutations.indexOf('copy_hook_files') < allMutations.indexOf('prune_retired_and_stale'),
+        );
         assert.ok(allMutations.includes('publish_directory_pointers'));
         assert.ok(allMutations.includes('merge_hooks_settings'));
         assert.ok(allMutations.includes('write_manifest'));

package/bin/install.update-keeps-hooks.test.mjs

@@ -0,0 +1,96 @@
+/**
+ * An `--update` reinstall keeps every registered hook script on disk for the
+ * whole run, so a live session's hook call never finds its script missing.
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn, spawnSync } from 'node:child_process';
+import { INSTALL_FAULT_ENV } from './install-transaction.mjs';
+
+const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
+const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
+const REGISTERED_HOOK_RELATIVE_PATHS = [
+    join('blocking', 'bash_post_call_dispatcher.py'),
+    join('blocking', 'verify_before_acting.py'),
+];
+
+function installerEnvironment(homeDirectory) {
+    const childEnvironment = {
+        ...process.env,
+        CDE_INSTALL_PSTACK: '0',
+        CDE_INSTALL_USAGE_WRAPUP: '0',
+        HOME: homeDirectory,
+        USERPROFILE: homeDirectory,
+        GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CODEX_HOME: join(homeDirectory, '.codex'),
+    };
+    delete childEnvironment[INSTALL_FAULT_ENV];
+    return childEnvironment;
+}
+
+function runUpdateWhileWatching(homeDirectory, watchedPaths) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const missingCountByPath = new Map();
+        let outputText = '';
+        let hasExited = false;
+        const child = spawn(process.execPath, [INSTALLER_PATH, '--update'], {
+            cwd: THIS_DIRECTORY,
+            env: installerEnvironment(homeDirectory),
+        });
+        child.stdout.on('data', (chunk) => { outputText += chunk; });
+        child.stderr.on('data', (chunk) => { outputText += chunk; });
+        child.on('error', rejectPromise);
+        child.on('exit', (exitCode) => {
+            hasExited = true;
+            resolvePromise({ exitCode, outputText, missingCountByPath });
+        });
+        const pollOnce = () => {
+            if (hasExited) return;
+            for (const watchedPath of watchedPaths) {
+                if (!existsSync(watchedPath)) {
+                    missingCountByPath.set(watchedPath, (missingCountByPath.get(watchedPath) ?? 0) + 1);
+                }
+            }
+            setImmediate(pollOnce);
+        };
+        setImmediate(pollOnce);
+    });
+}
+
+test('--update never leaves a registered hook script missing mid-install', async () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-update-hooks-'));
+    try {
+        const firstInstall = spawnSync(process.execPath, [INSTALLER_PATH], {
+            cwd: THIS_DIRECTORY,
+            encoding: 'utf8',
+            env: installerEnvironment(homeDirectory),
+        });
+        assert.equal(firstInstall.status, 0, firstInstall.stdout + firstInstall.stderr);
+        const hooksDirectory = join(homeDirectory, '.agents', 'hooks');
+        const watchedPaths = REGISTERED_HOOK_RELATIVE_PATHS.map(
+            (relativePath) => join(hooksDirectory, relativePath),
+        );
+        for (const watchedPath of watchedPaths) {
+            assert.equal(existsSync(watchedPath), true, `first install wrote ${watchedPath}`);
+        }
+
+        const updateRun = await runUpdateWhileWatching(homeDirectory, watchedPaths);
+
+        assert.equal(updateRun.exitCode, 0, updateRun.outputText);
+        assert.deepEqual(
+            Object.fromEntries(updateRun.missingCountByPath),
+            {},
+            'a registered hook script was absent while --update ran',
+        );
+        for (const watchedPath of watchedPaths) {
+            assert.equal(existsSync(watchedPath), true, `--update left ${watchedPath} in place`);
+        }
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+});

package/hooks/blocking/test_code_rules_enforcer_ephemeral.py

@@ -28,6 +28,8 @@ _ENFORCER_SCRIPT = Path(__file__).resolve().parent / "code_rules_enforcer.py"
 
 _VIOLATING_PRODUCTION_SOURCE = "def process_data(payload: str) -> None:\n    print(payload)\n"
 
+_DIRECTORY_OUTSIDE_TEMP_ROOTS = Path("/home/user")
+
 
 def _run_enforcer_cli(
     all_cli_arguments: list[str],
@@ -74,6 +76,7 @@ def test_should_return_false_for_os_tempfile_gettempdir_root(
     """
     monkeypatch.delenv("CLAUDE_CODE_RULES_DISABLE_EPHEMERAL_EXEMPT", raising=False)
     monkeypatch.delenv("CLAUDE_JOB_DIR", raising=False)
+    monkeypatch.setattr(tempfile, "tempdir", str(_DIRECTORY_OUTSIDE_TEMP_ROOTS / "os_temp_root"))
     system_temp_root = tempfile.gettempdir()
     scratch_path = str(Path(system_temp_root) / "scratch_work.py")
     assert is_ephemeral_script_path(scratch_path) is False
@@ -82,7 +85,6 @@ def test_should_return_false_for_os_tempfile_gettempdir_root(
 @pytest.mark.parametrize("env_name", ["TMPDIR", "TEMP", "TMP"])
 def test_should_return_false_for_tmpdir_temp_tmp_env_roots(
     env_name: str,
-    tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     """B3: $TMPDIR / $TEMP / $TMP are not ephemeral sources.
@@ -92,8 +94,9 @@ def test_should_return_false_for_tmpdir_temp_tmp_env_roots(
     """
     monkeypatch.delenv("CLAUDE_CODE_RULES_DISABLE_EPHEMERAL_EXEMPT", raising=False)
     monkeypatch.delenv("CLAUDE_JOB_DIR", raising=False)
-    monkeypatch.setenv(env_name, str(tmp_path / "env_root"))
-    scratch_path = str(tmp_path / "env_root" / "scratch.py")
+    env_root = _DIRECTORY_OUTSIDE_TEMP_ROOTS / "env_root"
+    monkeypatch.setenv(env_name, str(env_root))
+    scratch_path = str(env_root / "scratch.py")
     assert is_ephemeral_script_path(scratch_path) is False
 
 
@@ -111,7 +114,8 @@ def test_should_return_false_for_pytest_tmp_path_when_job_dir_elsewhere(
     """
     monkeypatch.delenv("CLAUDE_CODE_RULES_DISABLE_EPHEMERAL_EXEMPT", raising=False)
     monkeypatch.setenv("CLAUDE_JOB_DIR", str(tmp_path / "elsewhere"))
-    pytest_sandbox_target = str(tmp_path / "candidate.py")
+    monkeypatch.setattr(tempfile, "tempdir", str(_DIRECTORY_OUTSIDE_TEMP_ROOTS / "os_temp_root"))
+    pytest_sandbox_target = str(Path(tempfile.gettempdir()) / "pytest-of-user" / "candidate.py")
     assert is_ephemeral_script_path(pytest_sandbox_target) is False
 
 

package/package.json

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