ai-code-switcher 0.1.22__tar.gz → 0.1.23__tar.gz

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-code-switcher
-Version: 0.1.22
+Version: 0.1.23
 Summary: Switch AI coding tool profiles and launch the correct CLI
 License: MIT
 Requires-Python: >=3.9
@@ -97,7 +97,15 @@ The supported AI CLIs are:
 `code-ai upgrade` also refreshes the Grok binary in each login profile's
 credentials directory. Grok stores a separate binary under `GROK_HOME/bin`, so
 updating only the global npm package can leave a login profile running an old
-version. Restart running Grok sessions after upgrading.
+version. The upgrade enables npm install scripts and verifies the actual binary
+version in the default home and every login home; an unchanged or missing binary
+causes the command to fail. Restart running Grok sessions after upgrading.
+
+For Grok, `code-ai run` prefers the official package in the active npm global
+prefix, so an older native installation earlier on `PATH` cannot shadow the
+package updated by `code-ai upgrade`. Native installations remain supported
+when the npm package is absent. Login credentials still use the profile's own
+`GROK_HOME`.
 
 ## Profiles and configuration
 

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/README.md

@@ -84,7 +84,15 @@ The supported AI CLIs are:
 `code-ai upgrade` also refreshes the Grok binary in each login profile's
 credentials directory. Grok stores a separate binary under `GROK_HOME/bin`, so
 updating only the global npm package can leave a login profile running an old
-version. Restart running Grok sessions after upgrading.
+version. The upgrade enables npm install scripts and verifies the actual binary
+version in the default home and every login home; an unchanged or missing binary
+causes the command to fail. Restart running Grok sessions after upgrading.
+
+For Grok, `code-ai run` prefers the official package in the active npm global
+prefix, so an older native installation earlier on `PATH` cannot shadow the
+package updated by `code-ai upgrade`. Native installations remain supported
+when the npm package is absent. Login credentials still use the profile's own
+`GROK_HOME`.
 
 ## Profiles and configuration
 

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ai-code-switcher"
-version = "0.1.22"
+version = "0.1.23"
 description = "Switch AI coding tool profiles and launch the correct CLI"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = {text = "MIT"}

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/src/ai_code_switcher.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-code-switcher
-Version: 0.1.22
+Version: 0.1.23
 Summary: Switch AI coding tool profiles and launch the correct CLI
 License: MIT
 Requires-Python: >=3.9
@@ -97,7 +97,15 @@ The supported AI CLIs are:
 `code-ai upgrade` also refreshes the Grok binary in each login profile's
 credentials directory. Grok stores a separate binary under `GROK_HOME/bin`, so
 updating only the global npm package can leave a login profile running an old
-version. Restart running Grok sessions after upgrading.
+version. The upgrade enables npm install scripts and verifies the actual binary
+version in the default home and every login home; an unchanged or missing binary
+causes the command to fail. Restart running Grok sessions after upgrading.
+
+For Grok, `code-ai run` prefers the official package in the active npm global
+prefix, so an older native installation earlier on `PATH` cannot shadow the
+package updated by `code-ai upgrade`. Native installations remain supported
+when the npm package is absent. Login credentials still use the profile's own
+`GROK_HOME`.
 
 ## Profiles and configuration
 

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/src/ai_code_switcher.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/code_ai/__init__.py
 src/code_ai/buddy.py
 src/code_ai/cli.py
 src/code_ai/config.py
+src/code_ai/grok.py
 src/code_ai/launcher.py
 src/code_ai/models.py
 src/code_ai/profiles.py
@@ -41,6 +42,8 @@ tests/test_desktop_env.py
 tests/test_desktop_icons.py
 tests/test_desktop_macos.py
 tests/test_desktop_windows.py
+tests/test_grok.py
+tests/test_grok_unix_execution.py
 tests/test_integration.py
 tests/test_launcher.py
 tests/test_models.py

ai_code_switcher-0.1.23/src/code_ai/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.23"

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/src/code_ai/cli.py

@@ -8,6 +8,7 @@ import typer
 from .config import load_config, save_config
 from .profiles import list_profiles, add_profile, remove_profile, show_profile
 from .launcher import launch
+from .grok import find_npm_installation, home_binary, check_version as check_grok_version
 from .buddy import (
     RARITIES, SPECIES, RARITY_COLORS,
     roll_by_name, bruteforce_user_id,
@@ -299,18 +300,35 @@ def _run_npm(args, env):
     return subprocess.run(["npm"] + args, env=env)
 
 
+def _verify_grok(command, env, version):
+    try:
+        check_grok_version(command, env, version)
+    except RuntimeError as exc:
+        typer.echo(str(exc), err=True)
+        sys.exit(1)
+
+
 def upgrade():
     typer.echo("Upgrading claude, codex, grok CLI...")
 
     env = os.environ.copy()
     env.pop("GROK_HOME", None)
-    result = _run_npm(["install", "-g"] + UPGRADE_PACKAGES, env)
+    result = _run_npm(["install", "-g", "--ignore-scripts=false"] + UPGRADE_PACKAGES, env)
     if result.returncode:
         sys.exit(result.returncode)
 
+    installation = find_npm_installation()
+    if not installation:
+        typer.echo("Cannot find the updated @xai-official/grok installation in the active npm prefix.", err=True)
+        sys.exit(1)
+    _verify_grok(installation.command, env, installation.version)
+    default_home = os.path.expanduser("~/.grok")
+    _verify_grok(home_binary(default_home), env, installation.version)
+    typer.echo(f"Grok CLI {installation.version} verified at {installation.command}")
+
     # Grok's npm launcher prefers GROK_HOME/bin even when that binary is old.
     # Re-run its installer in each login home after updating the global package.
-    refreshed = {os.path.normcase(os.path.realpath(os.path.expanduser("~/.grok")))}
+    refreshed = {os.path.normcase(os.path.realpath(default_home))}
     for name, profile in load_config().get("profiles", {}).items():
         if (profile.get("type") != "grok" or profile.get("mode") != "login"
                 or not profile.get("credentials_path")):
@@ -321,10 +339,14 @@ def upgrade():
             continue
         typer.echo(f"Refreshing Grok CLI for login profile '{name}'...")
         profile_env = dict(env, GROK_HOME=home)
-        result = _run_npm(["rebuild", "-g", "@xai-official/grok"], profile_env)
+        result = _run_npm([
+            "rebuild", "-g", "--ignore-scripts=false", "--foreground-scripts", "@xai-official/grok",
+        ], profile_env)
         if result.returncode:
             typer.echo(f"Failed to refresh Grok CLI for profile '{name}'.", err=True)
             sys.exit(result.returncode)
+        _verify_grok(home_binary(home), profile_env, installation.version)
+        typer.echo(f"Grok CLI {installation.version} verified for profile '{name}'.")
         refreshed.add(normalized_home)
     sys.exit(0)
 

ai_code_switcher-0.1.23/src/code_ai/grok.py

@@ -0,0 +1,68 @@
+"""Locate and verify the Grok installation managed by npm."""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class GrokInstallation:
+    command: str
+    version: str
+
+
+def find_npm_installation() -> Optional[GrokInstallation]:
+    npm = shutil.which("npm.cmd" if sys.platform == "win32" else "npm")
+    if not npm:
+        return None
+    try:
+        result = subprocess.run(
+            [npm, "prefix", "-g"], capture_output=True, text=True, timeout=10,
+        )
+        prefix = result.stdout.strip()
+        if result.returncode or not prefix:
+            return None
+        if sys.platform == "win32":
+            command = os.path.join(prefix, "grok.cmd")
+            modules = os.path.join(prefix, "node_modules")
+        else:
+            command = os.path.join(prefix, "bin", "grok")
+            modules = os.path.join(prefix, "lib", "node_modules")
+        if not os.path.isfile(command):
+            return None
+        package_file = os.path.join(modules, "@xai-official", "grok", "package.json")
+        with open(package_file, encoding="utf-8") as package:
+            metadata = json.load(package)
+        if (not isinstance(metadata, dict)
+                or metadata.get("name") != "@xai-official/grok"
+                or not isinstance(metadata.get("version"), str)):
+            return None
+        return GrokInstallation(command, metadata["version"])
+    except (OSError, subprocess.SubprocessError, ValueError):
+        return None
+
+
+def home_binary(home: str) -> str:
+    name = "grok.exe" if sys.platform == "win32" else "grok"
+    return os.path.join(home, "bin", name)
+
+
+def check_version(command: str, env: dict, expected: str) -> None:
+    try:
+        result = subprocess.run(
+            [command, "--version"], env=env,
+            capture_output=True, text=True, timeout=10,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        raise RuntimeError(f"Cannot verify Grok CLI at '{command}': {exc}") from exc
+    match = re.search(r"\bgrok\s+(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)", result.stdout)
+    if result.returncode or not match:
+        raise RuntimeError(f"Cannot verify Grok CLI version at '{command}'.")
+    actual = match.group(1)
+    if actual != expected:
+        raise RuntimeError(f"Grok CLI at '{command}' is {actual}; expected {expected}.")

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/src/code_ai/launcher.py

@@ -6,6 +6,7 @@ import subprocess
 from typing import List
 
 from .models import profile_from_dict, ApiProfile, LoginProfile
+from .grok import find_npm_installation
 
 ENV_MAP = {
     "claude": {
@@ -166,6 +167,11 @@ def launch(profile_dict, extra_args, use_default_args=True):
     else:
         cmd_path = shutil.which(cmd)
 
+    if ptype == "grok":
+        installation = find_npm_installation()
+        if installation:
+            cmd_path = installation.command
+
     if not cmd_path:
         print(f"Error: '{cmd}' not found in PATH. Install it first.")
         sys.exit(1)
@@ -194,4 +200,4 @@ def launch(profile_dict, extra_args, use_default_args=True):
     else:
         # On Unix, update os.environ and use execvp
         os.environ.update(env)
-        os.execvp(cmd, [cmd] + final_args)
+        os.execvp(cmd_path, full_cmd)

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/tests/test_cli_upgrade.py

@@ -7,13 +7,23 @@ from src.code_ai import cli
 from src.code_ai.cli import UPGRADE_PACKAGES
 
 
+@pytest.fixture(autouse=True)
+def installed_grok(monkeypatch, tmp_path):
+    installation = SimpleNamespace(command=str(tmp_path / "npm-grok"), version="1.0.46")
+    monkeypatch.setattr(cli, "find_npm_installation", lambda: installation)
+    monkeypatch.setattr(cli, "load_config", lambda: {"profiles": {}})
+    checks = []
+    monkeypatch.setattr(cli, "check_grok_version", lambda command, env, version: checks.append((command, env, version)))
+    return installation, checks
+
+
 def test_upgrade_packages_use_official_grok_cli_instead_of_gemini():
     assert "@xai-official/grok" in UPGRADE_PACKAGES
     assert "@google/gemini-cli" not in UPGRADE_PACKAGES
 
 
 @pytest.mark.parametrize("platform", ["win32", "linux", "darwin"])
-def test_upgrade_refreshes_each_grok_login_home(monkeypatch, tmp_path, platform):
+def test_upgrade_refreshes_each_grok_login_home(monkeypatch, tmp_path, platform, installed_grok):
     homes = [str(tmp_path / "account-a"), str(tmp_path / "account-b")]
     monkeypatch.setattr(cli.sys, "platform", platform)
     monkeypatch.setenv("GROK_HOME", homes[0])
@@ -41,12 +51,21 @@ def test_upgrade_refreshes_each_grok_login_home(monkeypatch, tmp_path, platform)
     assert "GROK_HOME" not in calls[0][1]["env"]
     assert [call[1]["env"]["GROK_HOME"] for call in calls[1:]] == homes
     if platform == "win32":
-        assert calls[0][0] == "npm install -g " + " ".join(UPGRADE_PACKAGES)
+        assert calls[0][0] == "npm install -g --ignore-scripts=false " + " ".join(UPGRADE_PACKAGES)
         assert all(call[1]["shell"] for call in calls)
-        assert [call[0] for call in calls[1:]] == ["npm rebuild -g @xai-official/grok"] * 2
+        assert [call[0] for call in calls[1:]] == ["npm rebuild -g --ignore-scripts=false --foreground-scripts @xai-official/grok"] * 2
     else:
-        assert calls[0][0] == ["npm", "install", "-g"] + UPGRADE_PACKAGES
-        assert [call[0] for call in calls[1:]] == [["npm", "rebuild", "-g", "@xai-official/grok"]] * 2
+        assert calls[0][0] == ["npm", "install", "-g", "--ignore-scripts=false"] + UPGRADE_PACKAGES
+        assert [call[0] for call in calls[1:]] == [["npm", "rebuild", "-g", "--ignore-scripts=false", "--foreground-scripts", "@xai-official/grok"]] * 2
+    installation, checks = installed_grok
+    binary_name = "grok.exe" if platform == "win32" else "grok"
+    assert [check[0] for check in checks] == [
+        installation.command,
+        os.path.join(os.path.expanduser("~/.grok"), "bin", binary_name),
+        os.path.join(homes[0], "bin", binary_name),
+        os.path.join(homes[1], "bin", binary_name),
+    ]
+    assert all(check[2] == "1.0.46" for check in checks)
     assert os.environ["GROK_HOME"] == homes[0]
 
 
@@ -121,3 +140,45 @@ def test_upgrade_reports_grok_home_refresh_failure(monkeypatch, tmp_path, capsys
 
     assert exc.value.code == 9
     assert "grok-a" in capsys.readouterr().err
+
+
+def test_upgrade_rejects_successful_rebuild_that_leaves_profile_binary_old(monkeypatch, tmp_path, capsys):
+    home = str(tmp_path / "account-a")
+    monkeypatch.setattr(cli, "load_config", lambda: {"profiles": {
+        "grok-a": {"type": "grok", "mode": "login", "credentials_path": home},
+    }})
+    monkeypatch.setattr(cli.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0))
+
+    def check(command, env, version):
+        if env.get("GROK_HOME") == home:
+            raise RuntimeError("Grok CLI is still 0.2.118; expected 1.0.46")
+
+    monkeypatch.setattr(cli, "check_grok_version", check, raising=False)
+    with pytest.raises(SystemExit) as exc:
+        cli.upgrade()
+    assert exc.value.code == 1
+    assert "0.2.118" in capsys.readouterr().err
+
+
+def test_upgrade_rejects_stale_default_binary(monkeypatch, capsys, installed_grok):
+    monkeypatch.setattr(cli.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0))
+    installation, _ = installed_grok
+
+    def check(command, env, version):
+        if command != installation.command:
+            raise RuntimeError("Grok CLI is still 0.2.118; expected 1.0.46")
+
+    monkeypatch.setattr(cli, "check_grok_version", check, raising=False)
+    with pytest.raises(SystemExit) as exc:
+        cli.upgrade()
+    assert exc.value.code == 1
+    assert "0.2.118" in capsys.readouterr().err
+
+
+def test_upgrade_fails_when_npm_installation_cannot_be_found(monkeypatch, capsys):
+    monkeypatch.setattr(cli.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0))
+    monkeypatch.setattr(cli, "find_npm_installation", lambda: None, raising=False)
+    with pytest.raises(SystemExit) as exc:
+        cli.upgrade()
+    assert exc.value.code == 1
+    assert "npm" in capsys.readouterr().err

ai_code_switcher-0.1.23/tests/test_grok.py

@@ -0,0 +1,86 @@
+import json
+import os
+import subprocess
+from types import SimpleNamespace
+
+import pytest
+
+from src.code_ai import grok
+
+
+@pytest.mark.parametrize("platform", ["win32", "darwin", "linux"])
+def test_find_npm_installation_uses_active_prefix(monkeypatch, tmp_path, platform):
+    monkeypatch.setattr(grok.sys, "platform", platform)
+    command = tmp_path / ("grok.cmd" if platform == "win32" else "bin/grok")
+    package = tmp_path / ("node_modules" if platform == "win32" else "lib/node_modules") / "@xai-official/grok"
+    command.parent.mkdir(parents=True, exist_ok=True)
+    command.write_text("launcher", encoding="utf-8")
+    package.mkdir(parents=True)
+    (package / "package.json").write_text(json.dumps({"name": "@xai-official/grok", "version": "1.0.46"}))
+    monkeypatch.setattr(grok.shutil, "which", lambda name: "npm.cmd" if platform == "win32" else "npm")
+    calls = []
+
+    def run(args, **kwargs):
+        calls.append((args, kwargs))
+        return SimpleNamespace(returncode=0, stdout=str(tmp_path) + "\n", stderr="")
+
+    monkeypatch.setattr(grok.subprocess, "run", run)
+    installation = grok.find_npm_installation()
+
+    assert installation.command == str(command)
+    assert installation.version == "1.0.46"
+    assert calls[0][0][1:] == ["prefix", "-g"]
+    assert calls[0][1]["timeout"] == 10
+
+
+def test_find_npm_installation_returns_none_when_npm_is_missing(monkeypatch):
+    monkeypatch.setattr(grok.shutil, "which", lambda name: None)
+    assert grok.find_npm_installation() is None
+
+
+def test_find_npm_installation_returns_none_when_prefix_query_fails(monkeypatch):
+    monkeypatch.setattr(grok.shutil, "which", lambda name: "npm")
+    monkeypatch.setattr(grok.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=1, stdout="", stderr="unavailable"))
+    assert grok.find_npm_installation() is None
+
+
+def test_find_npm_installation_does_not_treat_an_empty_prefix_as_cwd(monkeypatch):
+    monkeypatch.setattr(grok.shutil, "which", lambda name: "npm")
+    monkeypatch.setattr(grok.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0, stdout="\n", stderr=""))
+    assert grok.find_npm_installation() is None
+
+
+def test_check_version_rejects_stale_binary_despite_successful_exit(monkeypatch):
+    monkeypatch.setattr(grok.subprocess, "run", lambda *args, **kwargs: SimpleNamespace(returncode=0, stdout="grok 0.2.118 (old)\n", stderr=""))
+    with pytest.raises(RuntimeError, match="0.2.118.*1.0.46"):
+        grok.check_version("/profile/bin/grok", {}, "1.0.46")
+
+
+def test_check_version_uses_profile_environment(monkeypatch):
+    calls = []
+    env = {"GROK_HOME": "/profile"}
+
+    def run(args, **kwargs):
+        calls.append((args, kwargs))
+        return SimpleNamespace(returncode=0, stdout="grok 1.0.46 (current)\n", stderr="")
+
+    monkeypatch.setattr(grok.subprocess, "run", run)
+    grok.check_version("/profile/bin/grok", env, "1.0.46")
+    assert calls[0][0] == ["/profile/bin/grok", "--version"]
+    assert calls[0][1]["env"] is env
+
+
+def test_check_version_reports_missing_binary(monkeypatch):
+    def run(*args, **kwargs):
+        raise FileNotFoundError("missing")
+
+    monkeypatch.setattr(grok.subprocess, "run", run)
+    with pytest.raises(RuntimeError, match="/profile/bin/grok"):
+        grok.check_version("/profile/bin/grok", {}, "1.0.46")
+
+
+def test_home_binary_uses_platform_filename(monkeypatch):
+    monkeypatch.setattr(grok.sys, "platform", "darwin")
+    assert grok.home_binary("/profile") == os.path.join("/profile", "bin", "grok")
+    monkeypatch.setattr(grok.sys, "platform", "win32")
+    assert grok.home_binary("/profile") == os.path.join("/profile", "bin", "grok.exe")

ai_code_switcher-0.1.23/tests/test_grok_unix_execution.py

@@ -0,0 +1,40 @@
+import json
+import os
+from pathlib import Path
+import shlex
+import subprocess
+import sys
+
+import pytest
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Requires Unix executable scripts")
+def test_grok_launch_executes_updated_npm_binary_with_isolated_home(tmp_path):
+    old_bin = tmp_path / "old-install"
+    prefix = tmp_path / "npm-prefix"
+    old_bin.mkdir()
+    (prefix / "bin").mkdir(parents=True)
+    package = prefix / "lib/node_modules/@xai-official/grok"
+    package.mkdir(parents=True)
+    (package / "package.json").write_text(json.dumps({"name": "@xai-official/grok", "version": "1.0.46"}))
+    scripts = {
+        old_bin / "npm": "#!/bin/sh\nprintf '%s\\n' " + shlex.quote(str(prefix)) + "\n",
+        old_bin / "grok": "#!/bin/sh\necho 'grok 0.2.118 (old)'\n",
+        prefix / "bin/grok": "#!/bin/sh\necho 'grok 1.0.46 (current)'\nprintf 'profile=%s\\n' \"$GROK_HOME\"\n",
+    }
+    for path, script in scripts.items():
+        path.write_text(script, encoding="utf-8")
+        path.chmod(0o755)
+    home = str(tmp_path / "profile with spaces")
+    profile = {"name": "account-a", "type": "grok", "mode": "login", "credentials_path": home}
+    env = os.environ.copy()
+    env["PATH"] = str(old_bin) + os.pathsep + env.get("PATH", "")
+    env["PYTHONPATH"] = str(Path(__file__).resolve().parents[1] / "src")
+    result = subprocess.run(
+        [sys.executable, "-c", "from code_ai.launcher import launch; launch(" + repr(profile) + ", ['--version'])"],
+        env=env, capture_output=True, text=True, timeout=15,
+    )
+    assert result.returncode == 0, result.stderr
+    assert "grok 1.0.46" in result.stdout
+    assert "0.2.118" not in result.stdout
+    assert "profile=" + home in result.stdout

{ai_code_switcher-0.1.22 → ai_code_switcher-0.1.23}/tests/test_launcher.py

@@ -325,3 +325,32 @@ def test_launch_windows_passes_env_correctly():
                 env = mock_run.call_args[1]["env"]
                 assert env["ANTHROPIC_BASE_URL"] == "https://example.com"
                 assert "ANTHROPIC_AUTH_TOKEN" in env
+
+
+@pytest.mark.parametrize("platform", ["darwin", "linux"])
+def test_launch_grok_uses_updated_npm_entry_instead_of_shadowing_path(monkeypatch, tmp_path, platform):
+    from types import SimpleNamespace
+    from src.code_ai import launcher
+
+    profile_home = str(tmp_path / "grok-account")
+    npm_command = str(tmp_path / "npm-prefix" / "bin" / "grok")
+    monkeypatch.setattr(launcher.sys, "platform", platform)
+    monkeypatch.setattr(launcher.shutil, "which", lambda name: "/old-install/grok")
+    monkeypatch.setattr(launcher, "find_npm_installation", lambda: SimpleNamespace(command=npm_command, version="1.0.46"))
+    with patch.object(launcher.os, "execvp") as execute:
+        with patch.dict(os.environ):
+            launcher.launch({"type": "grok", "mode": "login", "name": "grok-account", "credentials_path": profile_home}, ["--version"])
+            assert os.environ["GROK_HOME"] == profile_home
+    execute.assert_called_once_with(npm_command, [npm_command, "--version"])
+
+
+def test_launch_grok_without_npm_preserves_native_install(monkeypatch, tmp_path):
+    from src.code_ai import launcher
+
+    monkeypatch.setattr(launcher.sys, "platform", "darwin")
+    monkeypatch.setattr(launcher.shutil, "which", lambda name: "/native/bin/grok")
+    monkeypatch.setattr(launcher, "find_npm_installation", lambda: None)
+    with patch.object(launcher.os, "execvp") as execute:
+        with patch.dict(os.environ):
+            launcher.launch({"type": "grok", "mode": "login", "credentials_path": str(tmp_path / "native-account")}, ["--version"])
+    execute.assert_called_once_with("/native/bin/grok", ["/native/bin/grok", "--version"])

ai_code_switcher-0.1.22/src/code_ai/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.22"