claude-dev-env 8.35.0 → 8.35.2

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/package.json

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

package/scripts/claude_account_profile.py

@@ -28,14 +28,15 @@ from dev_env_scripts_constants.claude_account_constants import (
     ALL_WINDOWS_JUNCTION_COMMAND_PREFIX,
     CHOICE_MAIN,
     CHOICE_WAIT,
+    CLAUDE_LAUNCHER_PROGRAM,
     JSON_LAUNCHER_KEY,
     JSON_LINKED_KEY,
     JSON_MOVED_ASIDE_KEY,
     JSON_UNLINKED_KEY,
     ALL_LAUNCHER_DIRECTORY_RELATIVE_PARTS,
-    LAUNCHER_FILE_NAME_TEMPLATE,
+    LAUNCHER_BODY_TEMPLATE,
     LAUNCHER_REPLACED_SUFFIX,
-    LAUNCHER_TEXT_TEMPLATE,
+    LauncherProgram,
     MAIN_CLAUDE_HOME_DIRECTORY_NAME,
     PROFILES_ROOT_DIRECTORY_NAME,
     PROFILES_ROOT_ENVIRONMENT_VARIABLE,
@@ -343,16 +344,14 @@ def move_launcher_aside(launcher_path: Path, now: datetime) -> Path:
 
 
 def launcher_path(
-    launcher_directory: Path,
-    profile_name: str,
-    launcher_file_name_template: str = LAUNCHER_FILE_NAME_TEMPLATE,
+    launcher_directory: Path, profile_name: str, launcher_program: LauncherProgram
 ) -> Path:
     """Name the launcher file for a profile.
 
     Args:
         launcher_directory: The directory on PATH that holds the launcher.
         profile_name: The name used in the launcher file name.
-        launcher_file_name_template: The launcher file name, with ``{profile_name}``.
+        launcher_program: The program the launcher runs, which names the file.
 
     Returns:
         The launcher path.
@@ -360,7 +359,7 @@ def launcher_path(
     Raises:
         ValueError: When the profile name is not a valid profile name.
     """
-    return launcher_directory / launcher_file_name_template.format(
+    return launcher_directory / launcher_program.file_name_template.format(
         profile_name=validate_profile_name(profile_name)
     )
 
@@ -370,33 +369,33 @@ def write_launcher(
     launcher_directory: Path,
     profile_home: Path,
     now: datetime,
-    profile_name: str = SECOND_ACCOUNT_PROFILE_NAME,
-    launcher_file_name_template: str = LAUNCHER_FILE_NAME_TEMPLATE,
-    launcher_text_template: str = LAUNCHER_TEXT_TEMPLATE,
+    profile_name: str,
+    launcher_program: LauncherProgram,
 ) -> Path:
-    """Write the launcher that runs Claude under a named profile.
+    """Write the launcher that runs a program under a named profile.
 
     ::
 
         claude-NAME -p "fix the test"
-        -> CLAUDE_CONFIG_DIR=<profile home>, then claude -p "fix the test"
+        -> CLAUDE_CONFIG_DIR=<profile home>, then call claude -p "fix the test"
         an older claude-NAME.cmd -> claude-NAME.cmd.replaced-<time>
 
     Args:
         launcher_directory: The directory on PATH that holds the launcher.
-        profile_home: The named account's Claude home.
+        profile_home: The named account's home for the program.
         now: The run time that names a moved older launcher.
         profile_name: The name used in the launcher file name.
-        launcher_file_name_template: The launcher file name, with ``{profile_name}``.
-        launcher_text_template: The launcher body, with ``{profile_home}``.
+        launcher_program: The program to run and the variable naming its home.
 
     Returns:
         The launcher path.
     """
-    target_path = launcher_path(
-        launcher_directory, profile_name, launcher_file_name_template
+    target_path = launcher_path(launcher_directory, profile_name, launcher_program)
+    launcher_text = LAUNCHER_BODY_TEMPLATE.format(
+        environment_variable=launcher_program.environment_variable,
+        profile_home=profile_home,
+        program=launcher_program.program,
     )
-    launcher_text = launcher_text_template.format(profile_home=profile_home)
     launcher_bytes = launcher_text.encode(TEXT_ENCODING)
     if target_path.is_file() and target_path.read_bytes() == launcher_bytes:
         return target_path
@@ -454,6 +453,7 @@ def _sync_named_profile(arguments: argparse.Namespace) -> dict[str, object]:
         profile_home=profile_home,
         now=now,
         profile_name=arguments.profile_name,
+        launcher_program=CLAUDE_LAUNCHER_PROGRAM,
     )
     return {**sync_report_payload(report), JSON_LAUNCHER_KEY: str(launcher_path)}
 

package/scripts/codex_account_choice.py

@@ -71,8 +71,7 @@ from dev_env_scripts_constants.codex_account_constants import (
     CODEX_ACCOUNT_NAME_SEPARATOR,
     CODEX_ACCOUNT_PROFILES_ENVIRONMENT_VARIABLE,
     CODEX_AUTH_FILE_NAME,
-    CODEX_LAUNCHER_FILE_NAME_TEMPLATE,
-    CODEX_LAUNCHER_TEXT_TEMPLATE,
+    CODEX_LAUNCHER_PROGRAM,
     CODEX_PROFILES_ROOT_DIRECTORY_NAME,
     CODEX_PROFILES_ROOT_ENVIRONMENT_VARIABLE,
     COMMAND_INSTALL,
@@ -285,8 +284,7 @@ def _install_account(
         profile_home=profiles_root / name,
         now=now,
         profile_name=name,
-        launcher_file_name_template=CODEX_LAUNCHER_FILE_NAME_TEMPLATE,
-        launcher_text_template=CODEX_LAUNCHER_TEXT_TEMPLATE,
+        launcher_program=CODEX_LAUNCHER_PROGRAM,
     )
     return {**sync_payload, JSON_LAUNCHER_KEY: str(launcher_path)}
 
@@ -338,9 +336,7 @@ def _retire_codex_account_launchers(
     """
     all_retired: dict[str, str] = {}
     for each_name in all_names:
-        retired_path = launcher_path(
-            launcher_directory, each_name, CODEX_LAUNCHER_FILE_NAME_TEMPLATE
-        )
+        retired_path = launcher_path(launcher_directory, each_name, CODEX_LAUNCHER_PROGRAM)
         if retired_path.is_file():
             all_retired[each_name] = str(move_launcher_aside(retired_path, now))
     return all_retired

package/scripts/dev_env_scripts_constants/claude_account_constants.py

@@ -8,8 +8,11 @@ main account so its owner never runs out.
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from datetime import timedelta
 
+from dev_env_scripts_constants.shared_tree_constants import CLAUDE_CONFIG_DIR_ENV_VAR
+
 MAIN_CLAUDE_HOME_DIRECTORY_NAME: str = ".claude"
 """Directory under the user home that holds the main account's Claude home."""
 
@@ -38,22 +41,39 @@ ALL_WINDOWS_RESERVED_PROFILE_NAMES: frozenset[str] = frozenset(
 ALL_LAUNCHER_DIRECTORY_RELATIVE_PARTS: tuple[str, ...] = (".local", "bin")
 """Path parts under the user home of the directory on PATH that holds the launcher."""
 
-LAUNCHER_FILE_NAME_TEMPLATE: str = "claude-{profile_name}.cmd"
-"""File name pattern for a named profile launcher."""
-
-LAUNCHER_FILE_NAME: str = LAUNCHER_FILE_NAME_TEMPLATE.format(
-    profile_name=SECOND_ACCOUNT_PROFILE_NAME
-)
-"""File name of the launcher that runs Claude under the second account."""
+CLAUDE_BINARY_NAME: str = "claude"
+"""Claude command name looked up on PATH."""
 
-LAUNCHER_TEXT_TEMPLATE: str = (
+LAUNCHER_BODY_TEMPLATE: str = (
     "@echo off\r\n"
     "setlocal\r\n"
-    'set "CLAUDE_CONFIG_DIR={profile_home}"\r\n'
-    "claude %*\r\n"
+    'set "{environment_variable}={profile_home}"\r\n'
+    "call {program} %*\r\n"
     "exit /b %ERRORLEVEL%\r\n"
 )
-"""Launcher body: point Claude at the profile and pass every argument through."""
+"""Launcher body: point a program at the profile home and pass every argument through.
+
+The program resolves to npm's ``<program>.cmd``, whose last line runs ``endLocal``
+and a ``goto`` to a missing label. Chained into without ``call``, that line ends
+this launcher's ``setlocal`` too, and the program starts without the variable.
+"""
+
+
+@dataclass(frozen=True)
+class LauncherProgram:
+    """The program a profile launcher runs and the variable naming its home."""
+
+    program: str
+    environment_variable: str
+    file_name_template: str
+
+
+CLAUDE_LAUNCHER_PROGRAM: LauncherProgram = LauncherProgram(
+    program=CLAUDE_BINARY_NAME,
+    environment_variable=CLAUDE_CONFIG_DIR_ENV_VAR,
+    file_name_template="claude-{profile_name}.cmd",
+)
+"""Launcher that runs Claude with ``CLAUDE_CONFIG_DIR`` set to the profile home."""
 
 LAUNCHER_REPLACED_SUFFIX: str = ".replaced-"
 """Suffix, before the run time, of an older launcher the sync moved aside."""

package/scripts/dev_env_scripts_constants/claude_account_worker_constants.py

@@ -6,6 +6,7 @@ from dev_env_scripts_constants.claude_account_constants import (
     CHOICE_MAIN,
     CHOICE_SECOND,
     CHOICE_WAIT,
+    CLAUDE_BINARY_NAME,
     CREDENTIALS_FILE_NAME,
     EXTRA_PROFILES_FILE_NAME,
     JSON_ACCOUNT_KEY,
@@ -15,8 +16,6 @@ from dev_env_scripts_constants.claude_account_constants import (
 )
 from dev_env_scripts_constants.shared_tree_constants import CLAUDE_CONFIG_DIR_ENV_VAR
 
-CLAUDE_BINARY_NAME: str = "claude"
-
 DEFAULT_PERMISSION_MODE: str = "auto"
 
 DEFAULT_TIMEOUT_MINUTES: int = 60

package/scripts/dev_env_scripts_constants/codex_account_constants.py

@@ -7,6 +7,8 @@ a job runs on, trying the accounts in roster order.
 
 from __future__ import annotations
 
+from dev_env_scripts_constants.claude_account_constants import LauncherProgram
+
 ALL_CODEX_ACCOUNT_NAMES: tuple[str, ...] = ("codex-1", "codex-2", "codex-3", "codex-4")
 """Fallback Codex accounts, in try order, when no account roster is saved or set."""
 
@@ -19,23 +21,6 @@ CODEX_ACCOUNT_LAUNCHERS_FILE_NAME: str = "account-launchers.json"
 CODEX_ACCOUNT_NAME_SEPARATOR: str = ","
 """Separator between account names in the roster environment variable."""
 
-CODEX_LAUNCHER_FILE_NAME_TEMPLATE: str = "codex-{profile_name}.cmd"
-"""File name pattern for one account's Codex launcher."""
-
-CODEX_LAUNCHER_TEXT_TEMPLATE: str = (
-    "@echo off\r\n"
-    "setlocal\r\n"
-    'set "CODEX_HOME={profile_home}"\r\n'
-    "call codex %*\r\n"
-    "exit /b %ERRORLEVEL%\r\n"
-)
-"""Launcher body: point Codex at the account's home and pass every argument through.
-
-``codex`` resolves to npm's ``codex.cmd``, whose last line runs ``endLocal`` and a
-``goto`` to a missing label. Chained into without ``call``, that line ends this
-launcher's ``setlocal`` too, and Codex starts without ``CODEX_HOME``.
-"""
-
 SETUP_PROMPT_TEXT: str = "Name for this Codex account launcher (blank to finish): "
 """Prompt the setup command shows for each account name."""
 
@@ -134,6 +119,13 @@ ALL_CODEX_BINARY_CANDIDATE_RELATIVE_PARTS: tuple[tuple[str, ...], ...] = (
 CODEX_BINARY_NAME: str = "codex"
 """Codex command name looked up on PATH."""
 
+CODEX_LAUNCHER_PROGRAM: LauncherProgram = LauncherProgram(
+    program=CODEX_BINARY_NAME,
+    environment_variable=CODEX_HOME_ENVIRONMENT_VARIABLE,
+    file_name_template="codex-{profile_name}.cmd",
+)
+"""Launcher that runs Codex with ``CODEX_HOME`` set to the account's home."""
+
 ALL_APP_SERVER_ARGUMENTS: tuple[str, ...] = ("app-server", "--listen", "stdio://")
 """Arguments that start Codex as a JSON-RPC server on standard input and output."""
 

package/scripts/dev_env_scripts_constants/test_claude_account_constants.py

@@ -11,7 +11,6 @@ from dev_env_scripts_constants.claude_account_constants import (
     JSON_SESSION_USED_PERCENT_KEY,
     JSON_WEEKLY_RESETS_AT_KEY,
     JSON_WEEKLY_USED_PERCENT_KEY,
-    LAUNCHER_TEXT_TEMPLATE,
     MAIN_SESSION_USED_CEILING_PERCENT,
     MAIN_WEEKLY_USED_CEILING_PERCENT,
     SECOND_SESSION_USED_CEILING_PERCENT,
@@ -24,11 +23,6 @@ def test_main_ceilings_sit_below_the_second_account_ceilings() -> None:
     assert MAIN_SESSION_USED_CEILING_PERCENT < SECOND_SESSION_USED_CEILING_PERCENT
 
 
-def test_launcher_names_the_profile_and_passes_every_argument() -> None:
-    assert "{profile_home}" in LAUNCHER_TEXT_TEMPLATE
-    assert "claude %*" in LAUNCHER_TEXT_TEMPLATE
-
-
 def test_picker_report_keys_never_collide() -> None:
     all_report_keys = [
         JSON_ACCOUNT_KEY,

package/scripts/test_claude_account_profile.py

@@ -4,12 +4,18 @@ from __future__ import annotations
 
 import json
 import os
+import subprocess
 from datetime import datetime, timezone
 from pathlib import Path
 
 import pytest
 
 import claude_account_profile as profile
+from dev_env_scripts_constants.claude_account_constants import (
+    CLAUDE_LAUNCHER_PROGRAM,
+    LauncherProgram,
+)
+from dev_env_scripts_constants.codex_account_constants import CODEX_LAUNCHER_PROGRAM
 
 NOW = datetime(2026, 9, 22, 21, 0, tzinfo=timezone.utc)
 
@@ -201,11 +207,15 @@ class TestWriteLauncher:
     ) -> None:
         profile_home = tmp_path / "ev"
         launcher_path = profile.write_launcher(
-            launcher_directory=tmp_path / "bin", profile_home=profile_home, now=NOW
+            launcher_directory=tmp_path / "bin",
+            profile_home=profile_home,
+            now=NOW,
+            profile_name="ev",
+            launcher_program=CLAUDE_LAUNCHER_PROGRAM,
         )
         launcher_text = launcher_path.read_text(encoding="utf-8")
         assert f'set "CLAUDE_CONFIG_DIR={profile_home}"' in launcher_text
-        assert "claude %*" in launcher_text
+        assert "call claude %*" in launcher_text
 
     def test_should_move_an_older_launcher_aside(self, tmp_path: Path) -> None:
         launcher_directory = tmp_path / "bin"
@@ -214,14 +224,18 @@ class TestWriteLauncher:
             "old launcher", encoding="utf-8"
         )
         profile.write_launcher(
-            launcher_directory=launcher_directory, profile_home=tmp_path / "ev", now=NOW
+            launcher_directory=launcher_directory,
+            profile_home=tmp_path / "ev",
+            now=NOW,
+            profile_name="ev",
+            launcher_program=CLAUDE_LAUNCHER_PROGRAM,
         )
         moved_launcher = launcher_directory / (
             "claude-ev.cmd.replaced-" + NOW.strftime("%Y%m%dT%H%M%SZ")
         )
         assert moved_launcher.read_text(encoding="utf-8") == "old launcher"
 
-    def test_should_write_the_launcher_from_the_callers_templates(
+    def test_should_write_the_launcher_for_the_callers_program(
         self, tmp_path: Path
     ) -> None:
         launcher_path = profile.write_launcher(
@@ -229,11 +243,75 @@ class TestWriteLauncher:
             profile_home=tmp_path / "alpha",
             now=NOW,
             profile_name="alpha",
-            launcher_file_name_template="tool-{profile_name}.cmd",
-            launcher_text_template="home={profile_home}",
+            launcher_program=LauncherProgram(
+                program="tool",
+                environment_variable="TOOL_HOME",
+                file_name_template="tool-{profile_name}.cmd",
+            ),
         )
         assert launcher_path == tmp_path / "bin" / "tool-alpha.cmd"
-        assert launcher_path.read_text(encoding="utf-8") == f"home={tmp_path / 'alpha'}"
+        assert launcher_path.read_bytes() == (
+            "@echo off\r\n"
+            "setlocal\r\n"
+            f'set "TOOL_HOME={tmp_path / "alpha"}"\r\n'
+            "call tool %*\r\n"
+            "exit /b %ERRORLEVEL%\r\n"
+        ).encode()
+
+
+NPM_SHIM_TEXT_TEMPLATE = (
+    "@ECHO off\r\n"
+    "GOTO start\r\n"
+    ":find_dp0\r\n"
+    "SET dp0=%~dp0\r\n"
+    "EXIT /b\r\n"
+    ":start\r\n"
+    "SETLOCAL\r\n"
+    "CALL :find_dp0\r\n"
+    'SET "_prog=cmd"\r\n'
+    "endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% &"
+    ' "%_prog%" /d /c "echo %%{environment_variable}%%"\r\n'
+)
+
+
+class TestNpmShimLauncher:
+    @pytest.mark.skipif(os.name != "nt", reason="runs the launcher through cmd.exe")
+    @pytest.mark.parametrize(
+        "launcher_program",
+        [
+            pytest.param(CLAUDE_LAUNCHER_PROGRAM, id="claude"),
+            pytest.param(CODEX_LAUNCHER_PROGRAM, id="codex"),
+        ],
+    )
+    def should_hand_the_profile_home_to_the_npm_shim(
+        self, tmp_path: Path, launcher_program: LauncherProgram
+    ) -> None:
+        profile_home = tmp_path / "profiles" / "alpha"
+        launcher_path = profile.write_launcher(
+            launcher_directory=tmp_path / "bin",
+            profile_home=profile_home,
+            now=NOW,
+            profile_name="alpha",
+            launcher_program=launcher_program,
+        )
+        fake_directory = tmp_path / "fake"
+        fake_directory.mkdir()
+        (fake_directory / f"{launcher_program.program}.cmd").write_bytes(
+            NPM_SHIM_TEXT_TEMPLATE.format(
+                environment_variable=launcher_program.environment_variable
+            ).encode("utf-8")
+        )
+        environment = dict(os.environ)
+        environment["PATH"] = str(fake_directory) + os.pathsep + environment["PATH"]
+        environment[launcher_program.environment_variable] = str(tmp_path / "decoy")
+        completed = subprocess.run(
+            ["cmd", "/c", str(launcher_path)],
+            env=environment,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert completed.stdout.strip() == str(profile_home)
 
 
 class TestMoveLauncherAside:

package/scripts/test_codex_account_choice.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import json
 import os
-import subprocess
 from collections.abc import Callable, Iterator
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -26,19 +25,6 @@ ALL_SHARED_ENTRY_NAMES = (
     "rules",
     "skills",
 )
-NPM_CODEX_SHIM_TEXT = (
-    "@ECHO off\r\n"
-    "GOTO start\r\n"
-    ":find_dp0\r\n"
-    "SET dp0=%~dp0\r\n"
-    "EXIT /b\r\n"
-    ":start\r\n"
-    "SETLOCAL\r\n"
-    "CALL :find_dp0\r\n"
-    'SET "_prog=cmd"\r\n'
-    "endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% &"
-    ' "%_prog%" /d /c "echo %%CODEX_HOME%%"\r\n'
-)
 
 
 @pytest.fixture(autouse=True)
@@ -621,24 +607,3 @@ class TestSetupRoster:
             "beta sign-in"
         )
         assert choice.saved_codex_account_names(profiles_root) == ("alpha",)
-
-
-class TestCodexLauncher:
-    @pytest.mark.skipif(os.name != "nt", reason="runs the launcher through cmd.exe")
-    def should_hand_codex_home_to_the_npm_codex_shim(self, tmp_path: Path) -> None:
-        install(build_codex_main_home(tmp_path), tmp_path, "alpha")
-        launcher_path = tmp_path / "bin" / "codex-alpha.cmd"
-        fake_directory = tmp_path / "fake"
-        fake_directory.mkdir()
-        (fake_directory / "codex.cmd").write_bytes(NPM_CODEX_SHIM_TEXT.encode("utf-8"))
-        environment = dict(os.environ)
-        environment["PATH"] = str(fake_directory) + os.pathsep + environment["PATH"]
-        environment["CODEX_HOME"] = str(tmp_path / "decoy")
-        completed = subprocess.run(
-            ["cmd", "/c", str(launcher_path)],
-            env=environment,
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        assert completed.stdout.strip() == str(tmp_path / "profiles" / "alpha")