inspect-swe 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

inspect_swe/__init__.py

@@ -1,4 +1,6 @@
 from ._claude_code.claude_code import claude_code
+from ._claude_code.install.download import download_claude_code
+from ._util.sandbox import SandboxPlatform
 
 try:
     from ._version import __version__
@@ -6,4 +8,4 @@ except ImportError:
     __version__ = "unknown"
 
 
-__all__ = ["claude_code", "__version__"]
+__all__ = ["claude_code", "download_claude_code", "SandboxPlatform", "__version__"]

inspect_swe/_claude_code/claude_code.py

@@ -1,3 +1,5 @@
+from typing import Literal
+
 from inspect_ai.agent import (
     Agent,
     AgentState,
@@ -5,16 +7,44 @@ from inspect_ai.agent import (
     sandbox_agent_bridge,
 )
 from inspect_ai.model import ChatMessageSystem, ChatMessageUser
-from inspect_ai.util import sandbox
+from inspect_ai.util import sandbox as sandbox_env
+
+from inspect_swe._claude_code.install.install import ensure_claude_code_installed
 
 
 @agent
-def claude_code() -> Agent:
+def claude_code(
+    version: Literal["auto", "sandbox", "stable", "latest"] | str = "auto",
+    user: str | None = None,
+    sandbox: str | None = None,
+) -> Agent:
+    """Claude Code agent.
+
+    Agent that uses [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) running in a sandbox.
+
+    The agent can either use a version of Claude Code installed in the sandbox, or can download a version and install it in the sandbox (see docs on `version` option below for details).
+
+    Args:
+        version: Version of claude code to use. One of:
+            - "auto": Use any available version of claude code in the sandbox, otherwise download the current stable version.
+            - "sandbox": Use the version of claude code in the sandbox (raises `RuntimeError` if claude is not available in the sandbox)
+            - "stable": Download and use the current stable version of claude code.
+            - "latest": Download and use the very latest version of claude code.
+            - "x.x.x": Download and use a specific version of claude code.
+        user: User to execute claude code with.
+        sandbox: Optional sandbox environment name.
+    """
+
     async def execute(state: AgentState) -> AgentState:
         async with sandbox_agent_bridge(state) as bridge:
+            # ensure claude is installed and get binary location
+            claude_binary = await ensure_claude_code_installed(
+                version, user, sandbox_env(sandbox)
+            )
+
             # base options
             cmd = [
-                "claude",
+                claude_binary,
                 "--print",  # run without interactions
                 "--dangerously-skip-permissions",
                 "--model",  # use current inspect model
@@ -35,7 +65,7 @@ def claude_code() -> Agent:
             cmd.append(prompt)
 
             # execute the agent
-            result = await sandbox().exec(
+            result = await sandbox_env(sandbox).exec(
                 cmd=cmd,
                 env={
                     "ANTHROPIC_BASE_URL": f"http://localhost:{bridge.port}",
@@ -44,6 +74,7 @@ def claude_code() -> Agent:
                     "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
                     "IS_SANDBOX": "1",
                 },
+                user=user,
             )
 
         if result.success:

inspect_swe/_claude_code/install/cache.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+from inspect_swe._util.sandbox import SandboxPlatform
+
+from ..._util.appdirs import package_cache_dir
+from ..._util.checksum import verify_checksum
+
+
+def read_cached_claude_code_binary(
+    version: str, platform: SandboxPlatform, expected_checksum: str | None
+) -> bytes | None:
+    # no cached binary
+    cache_path = _claude_code_cached_binary(version, platform)
+    if not cache_path.exists():
+        return None
+
+    # read binary
+    with open(cache_path, "rb") as f:
+        binary_data = f.read()
+
+    if expected_checksum is None or verify_checksum(binary_data, expected_checksum):
+        cache_path.touch()
+        return binary_data
+    else:
+        cache_path.unlink()
+        return None
+
+
+def write_cached_claude_code_binary(
+    binary_data: bytes, version: str, platform: SandboxPlatform
+) -> None:
+    binary_path = _claude_code_cached_binary(version, platform)
+
+    with open(binary_path, "wb") as f:
+        f.write(binary_data)
+
+    _cleanup_claude_code_binary_cache(keep_count=3)
+
+
+def _cleanup_claude_code_binary_cache(keep_count: int = 5) -> None:
+    # get all cached binaries
+    cache_files = list(_claude_code_cached_binary_dir().glob("claude-*"))
+    if len(cache_files) <= keep_count:
+        return
+
+    # remove oldest
+    cache_files.sort(key=lambda f: f.stat().st_atime)
+    files_to_remove = cache_files[:-keep_count]
+    for file_path in files_to_remove:
+        file_path.unlink()
+
+
+def _claude_code_cached_binary_dir() -> Path:
+    return package_cache_dir("claude-code-downloads")
+
+
+def _claude_code_cached_binary(version: str, platform: SandboxPlatform) -> Path:
+    return _claude_code_cached_binary_dir() / f"claude-{version}-{platform}"

inspect_swe/_claude_code/install/download.py

@@ -0,0 +1,111 @@
+import re
+from typing import Literal
+
+from pydantic import BaseModel
+
+from ..._util._async import run_coroutine
+from ..._util.checksum import verify_checksum
+from ..._util.download import download_file, download_text_file
+from ..._util.sandbox import SandboxPlatform
+from ..._util.trace import trace
+from .cache import (
+    read_cached_claude_code_binary,
+    write_cached_claude_code_binary,
+)
+
+
+def download_claude_code(
+    version: Literal["stable", "latest"] | str, platform: SandboxPlatform
+) -> None:
+    """Download Claude Code.
+
+    Download a version of Claude Code. This version will be added to the cache of downloaded versions (which retains the 5 most recently downloaded versions).
+
+    Use this if you need to ensure that a specific version of Claude Code is downloaded in advance (e.g. if you are going to run your evaluations offline). After downloading, explicit requests for the downloaded version (e.g. `claude_code(version="1.0.98")`) will not require network access.
+
+    Args:
+        version: Version to download ("stable", "latest", or an explicit version number).
+        platform: Target platform ("linux-x64", "linux-arm64", "linux-x64-musl", or "linux-arm64-musl")
+    """
+    run_coroutine(download_claude_code_async(version, platform))
+
+
+async def download_claude_code_async(
+    version: Literal["stable", "latest"] | str, platform: SandboxPlatform
+) -> bytes:
+    # determine version and checksum
+    gcs_bucket = await _claude_code_gcs_bucket()
+    version = await _claude_code_version(gcs_bucket, version)
+    manifest = await _claude_code_manifest(gcs_bucket, version)
+    expected_checksum = _checksum_for_platform(manifest, platform)
+
+    # check the cache
+    binary_data = read_cached_claude_code_binary(version, platform, expected_checksum)
+    if binary_data is None:
+        # not in cache, download and verify checksum
+        binary_url = f"{gcs_bucket}/{version}/{platform}/claude"
+        binary_data = await download_file(binary_url)
+        if not verify_checksum(binary_data, expected_checksum):
+            raise ValueError("Checksum verification failed")
+
+        # save to cache
+        write_cached_claude_code_binary(binary_data, version, platform)
+
+        # trace
+        trace(f"Downloaded claude code binary: {version} ({platform})")
+    else:
+        trace(f"Used claude code binary from cache: {version} ({platform})")
+
+    # return data
+    return binary_data
+
+
+async def _claude_code_gcs_bucket() -> str:
+    INSTALL_SCRIPT_URL = "https://claude.ai/install.sh"
+    script_content = await download_text_file(INSTALL_SCRIPT_URL)
+    pattern = r'GCS_BUCKET="(https://storage\.googleapis\.com/[^"]+)"'
+    match = re.search(pattern, script_content)
+    if match is not None:
+        gcs_bucket = match.group(1)
+        return gcs_bucket
+    else:
+        raise RuntimeError("Unable to determine GCS bucket for claude code.")
+
+
+async def _claude_code_version(gcs_bucket: str, target: str) -> str:
+    # validate target
+    target_pattern = r"^(stable|latest|[0-9]+\.[0-9]+\.[0-9]+(-[^[:space:]]+)?)$"
+    if re.match(target_pattern, target) is None:
+        raise RuntimeError(
+            "Invalid version target (must be 'stable', 'latest', or a semver version number)"
+        )
+
+    # resolve target alias if required
+    if target in ["stable", "latest"]:
+        version_url = f"{gcs_bucket}/{target}"
+        version = await download_text_file(version_url)
+        return version
+    else:
+        return target
+
+
+class PlatformInfo(BaseModel):
+    checksum: str
+    size: int
+
+
+class Manifest(BaseModel):
+    version: str
+    platforms: dict[str, PlatformInfo]
+
+
+async def _claude_code_manifest(gcs_bucket: str, version: str) -> Manifest:
+    manifest_url = f"{gcs_bucket}/{version}/manifest.json"
+    manifest_json = await download_text_file(manifest_url)
+    return Manifest.model_validate_json(manifest_json)
+
+
+def _checksum_for_platform(manifest: Manifest, platform: SandboxPlatform) -> str:
+    if platform not in manifest.platforms:
+        raise RuntimeError(f"Platform '{platform}' not found in manifest.")
+    return manifest.platforms[platform].checksum

inspect_swe/_claude_code/install/install.py

@@ -0,0 +1,58 @@
+from typing import Literal
+
+from inspect_ai.util import SandboxEnvironment, concurrency
+from inspect_ai.util import sandbox as sandbox_env
+
+from inspect_swe._claude_code.install.cache import read_cached_claude_code_binary
+from inspect_swe._util.trace import trace
+
+from ..._util.sandbox import bash_command, detect_sandbox_platform, sandbox_exec
+from .download import download_claude_code_async
+
+
+async def ensure_claude_code_installed(
+    version: Literal["auto", "sandbox", "stable", "latest"] | str = "auto",
+    user: str | None = None,
+    sandbox: SandboxEnvironment | None = None,
+) -> str:
+    # resolve sandbox
+    sandbox = sandbox or sandbox_env()
+
+    # look in the sandbox first if we need to
+    if version == "auto" or version == "sandbox":
+        result = await sandbox.exec(bash_command("which claude"), user=user)
+        if result.success:
+            claude_binary = result.stdout.strip()
+            trace(f"Using claude code installed in sandbox: {claude_binary}")
+            return claude_binary
+
+        # if version == "sandbox" and we don't find it that's an error
+        if version == "sandbox":
+            raise RuntimeError("unable to locate claude code in sandbox")
+
+        # otherwise set to "stable"
+        version = "stable"
+
+    # detect the sandbox target platform
+    platform = await detect_sandbox_platform(sandbox)
+
+    # use concurrency so multiple samples don't attempt the same download all at once
+    async with concurrency("claude-install", 1, visible=False):
+        # if a specific version is requested, first try to read it directly from the cache
+        if version not in ["stable", "latest"]:
+            claude_binary_bytes: bytes | None = read_cached_claude_code_binary(
+                version, platform, None
+            )
+            if claude_binary_bytes is not None:
+                trace(f"Used claude code binary from cache: {version} ({platform})")
+
+        # download the binary
+        if claude_binary_bytes is None:
+            claude_binary_bytes = await download_claude_code_async(version, platform)
+
+        # write it into the container and return it
+        claude_binary = f"/opt/claude-{version}-{platform}"
+        await sandbox.write_file(claude_binary, claude_binary_bytes)
+        await sandbox_exec(sandbox, f"chmod +x {claude_binary}")
+        await sandbox_exec(sandbox, f"{claude_binary} config list", user=user)
+        return claude_binary

inspect_swe/_util/_async.py

@@ -0,0 +1,54 @@
+import asyncio
+from typing import Coroutine, Literal, TypeVar, cast
+
+import nest_asyncio  # type: ignore
+import sniffio
+
+from .platform import running_in_notebook
+
+T = TypeVar("T")
+
+
+def run_coroutine(coroutine: Coroutine[None, None, T]) -> T:
+    if current_async_backend() == "trio":
+        raise RuntimeError("run_coroutine cannot be used with trio")
+
+    if running_in_notebook():
+        init_nest_asyncio()
+        return asyncio.run(coroutine)
+    else:
+        try:
+            # this will throw if there is no running loop
+            asyncio.get_running_loop()
+
+            # initialiase nest_asyncio then we are clear to run
+            init_nest_asyncio()
+            return asyncio.run(coroutine)
+
+        except RuntimeError:
+            # No running event loop so we are clear to run
+            return asyncio.run(coroutine)
+
+
+_initialised_nest_asyncio: bool = False
+
+
+def init_nest_asyncio() -> None:
+    global _initialised_nest_asyncio
+    if not _initialised_nest_asyncio:
+        nest_asyncio.apply()
+        _initialised_nest_asyncio = True
+
+
+def current_async_backend() -> Literal["asyncio", "trio"] | None:
+    try:
+        return _validate_backend(sniffio.current_async_library().lower())
+    except sniffio.AsyncLibraryNotFoundError:
+        return None
+
+
+def _validate_backend(backend: str) -> Literal["asyncio", "trio"]:
+    if backend in ["asyncio", "trio"]:
+        return cast(Literal["asyncio", "trio"], backend)
+    else:
+        raise RuntimeError(f"Unknown async backend: {backend}")

inspect_swe/_util/appdirs.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+
+from inspect_ai._util.constants import PKG_NAME
+from platformdirs import user_cache_path, user_data_path
+
+
+def package_data_dir(subdir: str | None) -> Path:
+    data_dir = user_data_path(PKG_NAME)
+    if subdir:
+        data_dir = data_dir / subdir
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def package_cache_dir(subdir: str | None) -> Path:
+    cache_dir = user_cache_path(PKG_NAME)
+    if subdir:
+        cache_dir = cache_dir / subdir
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir

inspect_swe/_util/checksum.py

@@ -0,0 +1,6 @@
+import hashlib
+
+
+def verify_checksum(data: bytes, expected_checksum: str) -> bool:
+    actual_checksum = hashlib.sha256(data).hexdigest()
+    return actual_checksum == expected_checksum

inspect_swe/_util/constants.py

@@ -0,0 +1 @@
+PKG_NAME = "inspect_swe"

inspect_swe/_util/download.py

@@ -0,0 +1,12 @@
+import httpx
+
+
+async def download_file(url: str) -> bytes:
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url, follow_redirects=True)
+        response.raise_for_status()
+        return response.content
+
+
+async def download_text_file(url: str) -> str:
+    return (await download_file(url)).decode("utf-8")

inspect_swe/_util/platform.py

@@ -0,0 +1,15 @@
+from typing import no_type_check
+
+
+@no_type_check
+def running_in_notebook() -> bool:
+    try:
+        from IPython import get_ipython  # type: ignore
+
+        if "IPKernelApp" not in get_ipython().config:
+            return False
+    except ImportError:
+        return False
+    except AttributeError:
+        return False
+    return True

inspect_swe/_util/sandbox.py

@@ -0,0 +1,59 @@
+from typing import Literal, TypeAlias, cast
+
+from inspect_ai.util import SandboxEnvironment
+
+SandboxPlatform: TypeAlias = Literal[
+    "linux-x64", "linux-arm64", "linux-x64-musl", "linux-arm64-musl"
+]
+
+
+async def detect_sandbox_platform(sandbox: SandboxEnvironment) -> SandboxPlatform:
+    # Get OS
+    os_name = await sandbox_exec(sandbox, "uname -s")
+    if os_name == "Linux":
+        os_type = "linux"
+    else:
+        raise ValueError(f"Unsupported OS: {os_name}")
+
+    # Get architecture
+    arch = await sandbox_exec(sandbox, "uname -m")
+    if arch in ["x86_64", "amd64"]:
+        arch_type = "x64"
+    elif arch in ["arm64", "aarch64"]:
+        arch_type = "arm64"
+    else:
+        raise ValueError(f"Unsupported architecture: {arch}")
+
+    # Check for musl on Linux
+    if os_type == "linux":
+        # Check for musl libc
+        musl_check_cmd = (
+            "if [ -f /lib/libc.musl-x86_64.so.1 ] || "
+            "[ -f /lib/libc.musl-aarch64.so.1 ] || "
+            "ldd /bin/ls 2>&1 | grep -q musl; then "
+            "echo 'musl'; else echo 'glibc'; fi"
+        )
+        libc_type = await sandbox_exec(sandbox, musl_check_cmd)
+        if libc_type == "musl":
+            platform = f"linux-{arch_type}-musl"
+        else:
+            platform = f"linux-{arch_type}"
+    else:
+        platform = f"{os_type}-{arch_type}"
+
+    return cast(SandboxPlatform, platform)
+
+
+def bash_command(cmd: str) -> list[str]:
+    return ["bash", "--login", "-c", cmd]
+
+
+async def sandbox_exec(
+    sandbox: SandboxEnvironment, cmd: str, user: str | None = None
+) -> str:
+    result = await sandbox.exec(bash_command(cmd), user=user)
+    if not result.success:
+        raise RuntimeError(
+            f"Error executing sandbox command {','.join(cmd)}: {result.stderr}"
+        )
+    return result.stdout.strip()

inspect_swe/_util/trace.py

@@ -0,0 +1,7 @@
+from logging import getLogger
+
+logger = getLogger(__file__)
+
+
+def trace(message: str) -> None:
+    logger.info(f"[Inspect SWE] {message}")

inspect_swe/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.1'
-__version_tuple__ = version_tuple = (0, 2, 1)
+__version__ = version = '0.2.3'
+__version_tuple__ = version_tuple = (0, 2, 3)
 
 __commit_id__ = commit_id = None

{inspect_swe-0.2.1.dist-info → inspect_swe-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inspect_swe
-Version: 0.2.1
+Version: 0.2.3
 Summary: Software engineering agents for Inspect AI.
 Project-URL: Documentation, https://meridianlabs-ai.github.io/inspect_swe/
 Project-URL: Source Code, https://github.com/meridianlabs-ai/inspect_swe
@@ -9,7 +9,12 @@ Author: Meridian Labs
 License: MIT License
 License-File: LICENSE
 Requires-Python: >=3.10
+Requires-Dist: httpx
 Requires-Dist: inspect-ai>=0.3.125
+Requires-Dist: nest-asyncio
+Requires-Dist: platformdirs
+Requires-Dist: pydantic>=2.11.4
+Requires-Dist: sniffio
 Requires-Dist: typing-extensions>=4.9.0
 Provides-Extra: dev
 Requires-Dist: anthropic; extra == 'dev'

inspect_swe-0.2.3.dist-info/RECORD

@@ -0,0 +1,24 @@
+inspect_swe/__init__.py,sha256=Jg2VYr_eK8_fOXA4Oj0UAQj-g-RxDJuXrIhxKhassko,335
+inspect_swe/_registry.py,sha256=jM37ysrY39Ufd67GRKbiwfSViOLlm-82lm_JEaWKshw,97
+inspect_swe/_version.py,sha256=kBRz0P2plw1eVdIpt70W6m1LMbEIhLY3RyOfVGdubaI,704
+inspect_swe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+inspect_swe/_claude_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+inspect_swe/_claude_code/claude_code.py,sha256=YfxNLgohMMhAohLdclgGyLsfcjocwgmMyOxl2-HlepA,3297
+inspect_swe/_claude_code/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+inspect_swe/_claude_code/install/cache.py,sha256=k08bCxGq-iYVpO16LNQhPjxTM9p2iecpqMjqYd2WBss,1708
+inspect_swe/_claude_code/install/download.py,sha256=QKlFuDqCV55coTumIjyTXt2MU-vUQg8qPL3z3LHIUq8,4132
+inspect_swe/_claude_code/install/install.py,sha256=cJP2JOUZNfPphz0eWbzrY7ULjSUU_SbSlPy3QecBltw,2430
+inspect_swe/_util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+inspect_swe/_util/_async.py,sha256=cL8_Smmj2Es41TefceGDYLyVaO7gZ56VJcA4oByrWfQ,1520
+inspect_swe/_util/appdirs.py,sha256=V3o1ERdSYLjKP-m4O1T_Hvkx0UsP2HdfvsshLSQgP6E,562
+inspect_swe/_util/checksum.py,sha256=i-_GhtgCFd5eFj3PPJiGSCHDhZdPcIPNwiqddX93Sls,186
+inspect_swe/_util/constants.py,sha256=xKvGgaJ0MwNbdzaken5HMbxYyKBEw_3VrBwCgkvAIWo,25
+inspect_swe/_util/download.py,sha256=cCUau4ZBOKezpotJV5-v3JY_5CuYDZ-VcWlLf_EyNL0,340
+inspect_swe/_util/platform.py,sha256=wm4efIFfdyTeaV2oxOXVvYl1u22MHX3jQMERHJMgv7A,339
+inspect_swe/_util/sandbox.py,sha256=RixiEY1asFHa8HTsAHAxYXcPL-mUMgprQke1-TRbWYE,1812
+inspect_swe/_util/trace.py,sha256=mFHmBKn2F8iJP9PpTHaCseMHnTMz3ErRx6RCKV83rZk,139
+inspect_swe-0.2.3.dist-info/METADATA,sha256=yod5MyJGNjnpnlPCPczXyXMfx5BXhBrHJDoIkcTGpDI,1658
+inspect_swe-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+inspect_swe-0.2.3.dist-info/entry_points.txt,sha256=OzpvUhd7M3T2Rog4MjwJAxIKeX5ljiR0mVYM9GefBKg,49
+inspect_swe-0.2.3.dist-info/licenses/LICENSE,sha256=Hi3UDcbD6yCKZ1mcgt7pprzSG0rDEnSrbrm3XinyiDA,1070
+inspect_swe-0.2.3.dist-info/RECORD,,

inspect_swe/_claude_code/install_claude.py

@@ -1,341 +0,0 @@
-#!/usr/bin/env python3
-
-import hashlib
-import json
-import os
-import re
-import subprocess
-import tempfile
-import urllib.request
-from pathlib import Path
-from typing import Optional, cast
-
-# Constants
-INSTALL_SCRIPT_URL = "https://claude.ai/install.sh"
-CACHE_DIR = Path.home() / ".claude" / "downloads"
-# Fallback GCS bucket in case we can't fetch from install.sh
-FALLBACK_GCS_BUCKET = "https://storage.googleapis.com/claude-code-dist-86c565f3-f756-42ad-8dfa-d59b1c096819/claude-code-releases"
-
-
-def run_docker_exec(container_name: str, command: str) -> str:
-    """Execute a command in the Docker container and return output."""
-    cmd = ["docker", "exec", container_name, "bash", "-c", command]
-    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-    return result.stdout.strip()
-
-
-def detect_platform(container_name: str) -> str:
-    """Detect the platform (OS and architecture) of the container."""
-    # Get OS
-    os_name = run_docker_exec(container_name, "uname -s")
-    if os_name == "Darwin":
-        os_type = "darwin"
-    elif os_name == "Linux":
-        os_type = "linux"
-    else:
-        raise ValueError(f"Unsupported OS: {os_name}")
-
-    # Get architecture
-    arch = run_docker_exec(container_name, "uname -m")
-    if arch in ["x86_64", "amd64"]:
-        arch_type = "x64"
-    elif arch in ["arm64", "aarch64"]:
-        arch_type = "arm64"
-    else:
-        raise ValueError(f"Unsupported architecture: {arch}")
-
-    # Check for musl on Linux
-    if os_type == "linux":
-        # Check for musl libc
-        musl_check_cmd = (
-            "if [ -f /lib/libc.musl-x86_64.so.1 ] || "
-            "[ -f /lib/libc.musl-aarch64.so.1 ] || "
-            "ldd /bin/ls 2>&1 | grep -q musl; then "
-            "echo 'musl'; else echo 'glibc'; fi"
-        )
-        libc_type = run_docker_exec(container_name, musl_check_cmd)
-        if libc_type == "musl":
-            platform = f"linux-{arch_type}-musl"
-        else:
-            platform = f"linux-{arch_type}"
-    else:
-        platform = f"{os_type}-{arch_type}"
-
-    return platform
-
-
-def download_file(url: str) -> bytes:
-    """Download a file from the given URL and return its contents."""
-    with urllib.request.urlopen(url) as response:
-        return cast(bytes, response.read())
-
-
-def get_gcs_bucket_from_install_script() -> str:
-    """Fetch the install.sh script and extract the GCS_BUCKET URL.
-
-    Falls back to hardcoded URL if extraction fails.
-    """
-    try:
-        print("Fetching install script to discover GCS bucket...")
-        script_content = download_file(INSTALL_SCRIPT_URL).decode("utf-8")
-
-        # Look for GCS_BUCKET= line in the script
-        # Pattern matches: GCS_BUCKET="https://storage.googleapis.com/..."
-        pattern = r'GCS_BUCKET="(https://storage\.googleapis\.com/[^"]+)"'
-        match = re.search(pattern, script_content)
-
-        if match:
-            gcs_bucket = match.group(1)
-            print(f"Discovered GCS bucket: {gcs_bucket}")
-            return gcs_bucket
-        else:
-            print("Could not extract GCS bucket from install script, using fallback")
-            return FALLBACK_GCS_BUCKET
-
-    except Exception as e:
-        print(f"Error fetching install script: {e}, using fallback")
-        return FALLBACK_GCS_BUCKET
-
-
-def validate_target(target: str) -> bool:
-    """Validate the target parameter format."""
-    pattern = r"^(stable|latest|[0-9]+\.[0-9]+\.[0-9]+(-[^[:space:]]+)?)$"
-    return bool(re.match(pattern, target))
-
-
-def get_version(gcs_bucket: str, target: str = "stable") -> str:
-    """Get the actual version to install based on the target."""
-    if not validate_target(target):
-        raise ValueError(f"Invalid target: {target}")
-
-    # Always download stable version first (it has the most up-to-date installer)
-    stable_url = f"{gcs_bucket}/stable"
-    stable_version = download_file(stable_url).decode("utf-8").strip()
-
-    if target == "stable" or target == stable_version:
-        return stable_version
-    elif target == "latest":
-        # For latest, we'd need to check the latest version
-        # For now, we'll use stable as the implementation
-        return stable_version
-    else:
-        # Specific version requested
-        return target
-
-
-def get_checksum_from_manifest(manifest_json: str, platform: str) -> str:
-    """Extract the checksum for the given platform from the manifest."""
-    manifest = json.loads(manifest_json)
-
-    if "platforms" not in manifest:
-        raise ValueError("Invalid manifest: missing platforms")
-
-    if platform not in manifest["platforms"]:
-        raise ValueError(f"Platform {platform} not found in manifest")
-
-    checksum = manifest["platforms"][platform].get("checksum")
-
-    if not checksum or not re.match(r"^[a-f0-9]{64}$", checksum):
-        raise ValueError(f"Invalid checksum for platform {platform}")
-
-    return str(checksum)
-
-
-def verify_checksum(data: bytes, expected_checksum: str) -> bool:
-    """Verify the SHA256 checksum of the data."""
-    actual_checksum = hashlib.sha256(data).hexdigest()
-    return actual_checksum == expected_checksum
-
-
-def get_cached_binary_path(version: str, platform: str) -> Path:
-    """Get the path where a binary would be cached."""
-    return CACHE_DIR / f"claude-{version}-{platform}"
-
-
-def get_cached_binary(
-    version: str, platform: str, expected_checksum: str
-) -> Optional[bytes]:
-    """
-    Check if we have a cached binary and verify its checksum.
-
-    Returns the binary data if valid, None otherwise.
-    """
-    cache_path = get_cached_binary_path(version, platform)
-
-    if not cache_path.exists():
-        return None
-
-    try:
-        with open(cache_path, "rb") as f:
-            binary_data = f.read()
-
-        # Verify the cached binary still has the correct checksum
-        if verify_checksum(binary_data, expected_checksum):
-            # Update access time so this file is considered "recently used"
-            cache_path.touch()
-            print(f"Using cached binary from {cache_path}")
-            return binary_data
-        else:
-            print("Cached binary checksum mismatch, will re-download")
-            cache_path.unlink()  # Remove invalid cache file
-            return None
-    except Exception as e:
-        print(f"Error reading cached binary: {e}")
-        return None
-
-
-def cleanup_old_cache_files(keep_count: int = 3) -> None:
-    """
-    Remove old cached binaries, keeping only the most recent ones.
-
-    Keeps the specified number of most recently accessed files.
-    """
-    if not CACHE_DIR.exists():
-        return
-
-    # Get all claude binary files in cache
-    cache_files = list(CACHE_DIR.glob("claude-*"))
-
-    if len(cache_files) <= keep_count:
-        return  # Nothing to clean up
-
-    # Sort by access time (most recently accessed last)
-    cache_files.sort(key=lambda f: f.stat().st_atime)
-
-    # Remove oldest files
-    files_to_remove = cache_files[:-keep_count]
-    for file_path in files_to_remove:
-        try:
-            file_size_mb = file_path.stat().st_size / (1024 * 1024)
-            file_path.unlink()
-            print(f"Removed old cache file: {file_path.name} ({file_size_mb:.1f} MB)")
-        except Exception as e:
-            print(f"Error removing cache file {file_path}: {e}")
-
-
-def save_to_cache(binary_data: bytes, version: str, platform: str) -> None:
-    """Save a binary to the cache directory and clean up old files."""
-    CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    cache_path = get_cached_binary_path(version, platform)
-
-    with open(cache_path, "wb") as f:
-        f.write(binary_data)
-
-    print(f"Saved binary to cache: {cache_path}")
-
-    # Clean up old cache files, keeping only the 3 most recent
-    cleanup_old_cache_files(keep_count=3)
-
-
-def transfer_binary(container_name: str, binary_data: bytes, target_path: str) -> None:
-    """Transfer binary data to the container."""
-    # Use a temporary file and docker cp
-    with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
-        tmp_file.write(binary_data)
-        tmp_file_path = tmp_file.name
-
-    try:
-        # Copy file to container
-        subprocess.run(
-            ["docker", "cp", tmp_file_path, f"{container_name}:{target_path}"],
-            check=True,
-        )
-    finally:
-        # Clean up temporary file
-        os.unlink(tmp_file_path)
-
-
-def install_claude(container_name: str, binary_path: str) -> None:
-    """Install claude binary and verify it works."""
-    # Copy binary to /usr/local/bin for system-wide access
-    run_docker_exec(container_name, f"cp {binary_path} /usr/local/bin/claude")
-    run_docker_exec(container_name, "chmod +x /usr/local/bin/claude")
-
-    # Clean up the temporary binary
-    run_docker_exec(container_name, f"rm -f {binary_path}")
-
-    # Verify installation and initialize config
-    try:
-        # Check version
-        version_output = run_docker_exec(container_name, "claude --version")
-        print(f"Claude installed successfully: {version_output}")
-
-        # Initialize config files/directories by running config list
-        run_docker_exec(container_name, "claude config list")
-        print("Claude configuration initialized")
-
-    except subprocess.CalledProcessError as e:
-        print(f"Warning: Could not verify claude installation: {e}")
-        raise ValueError("Claude installation verification failed") from e
-
-
-def main(container_name: str, target: str = "stable") -> None:
-    """Main function to orchestrate the Claude installation."""
-    print(f"Installing Claude Code in container: {container_name}")
-    print(f"Target: {target}")
-
-    # Step 0: Get GCS bucket URL
-    gcs_bucket = get_gcs_bucket_from_install_script()
-
-    # Step 1: Detect platform
-    print("Detecting platform...")
-    platform = detect_platform(container_name)
-    print(f"Platform: {platform}")
-
-    # Step 2: Get version
-    print("Determining version...")
-    version = get_version(gcs_bucket, target)
-    print(f"Version: {version}")
-
-    # Step 3: Download and parse manifest
-    print("Downloading manifest...")
-    manifest_url = f"{gcs_bucket}/{version}/manifest.json"
-    manifest_json = download_file(manifest_url).decode("utf-8")
-
-    # Step 4: Get checksum for platform
-    print("Extracting checksum...")
-    expected_checksum = get_checksum_from_manifest(manifest_json, platform)
-
-    # Step 5: Check cache or download binary
-    binary_data = get_cached_binary(version, platform, expected_checksum)
-
-    if binary_data is None:
-        # Not in cache or invalid, need to download
-        print(f"Downloading Claude binary for {platform}...")
-        binary_url = f"{gcs_bucket}/{version}/{platform}/claude"
-        binary_data = download_file(binary_url)
-
-        # Step 6: Verify checksum
-        print("Verifying checksum...")
-        if not verify_checksum(binary_data, expected_checksum):
-            raise ValueError("Checksum verification failed")
-        print("Checksum verified successfully")
-
-        # Save to cache for future use
-        save_to_cache(binary_data, version, platform)
-    else:
-        print("Checksum already verified for cached binary")
-
-    # Step 7: Transfer binary to container
-    print("Transferring binary to container...")
-    binary_path = f"/tmp/claude-{version}-{platform}"
-    transfer_binary(container_name, binary_data, binary_path)
-
-    # Step 8: Install
-    print("Installing Claude Code...")
-    install_claude(container_name, binary_path)
-
-    print("\n✅ Installation complete!")
-
-
-if __name__ == "__main__":
-    # Test code - replace with your actual container name
-    test_container = "inspect-intervention-izedw74-default-1"
-
-    # You can test with different targets
-    # main(test_container, "stable")
-    # main(test_container, "latest")
-    # main(test_container, "1.0.0")
-
-    # Default test
-    main(test_container, "stable")

inspect_swe-0.2.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-inspect_swe/__init__.py,sha256=6F52dddUoPvJA7RugtyDaswUqliDGgeaTK_OXWplvI0,185
-inspect_swe/_registry.py,sha256=jM37ysrY39Ufd67GRKbiwfSViOLlm-82lm_JEaWKshw,97
-inspect_swe/_version.py,sha256=vYqoJTG51NOUmYyL0xt8asRK8vUT4lGAdal_EZ59mvw,704
-inspect_swe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-inspect_swe/_claude_code/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-inspect_swe/_claude_code/claude_code.py,sha256=iE_-6Wv0m7hO1Tj-d21K8iZHgBIcTcfSqLHPVS1whMM,1788
-inspect_swe/_claude_code/install_claude.py,sha256=g5nHIY-JVKDQFgm0IIhpCsCX5B6MadYj8-CtKpKU4YE,11796
-inspect_swe-0.2.1.dist-info/METADATA,sha256=56Fjle-9IWwx-k0AHCbxPPH7443KE1JqdSX4_s_dFCc,1526
-inspect_swe-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-inspect_swe-0.2.1.dist-info/entry_points.txt,sha256=OzpvUhd7M3T2Rog4MjwJAxIKeX5ljiR0mVYM9GefBKg,49
-inspect_swe-0.2.1.dist-info/licenses/LICENSE,sha256=Hi3UDcbD6yCKZ1mcgt7pprzSG0rDEnSrbrm3XinyiDA,1070
-inspect_swe-0.2.1.dist-info/RECORD,,