code-aide 1.18.4__tar.gz → 1.19.0__tar.gz

{code_aide-1.18.4 → code_aide-1.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-aide
-Version: 1.18.4
+Version: 1.19.0
 Summary: Manage AI coding CLI tools (Claude, Antigravity, Copilot, Cursor, Gemini, Amp, Codex)
 Project-URL: Homepage, https://github.com/dajobe/code-aide
 Project-URL: Repository, https://github.com/dajobe/code-aide
@@ -234,3 +234,21 @@ uv run pytest tests/test_install.py::TestDetectOsArch -v
 ## License
 
 Apache-2.0
+
+## npm download cache lifetime
+
+Standalone install, upgrade, removal (including migration), and installation
+scripts use private download caches under
+`~/.cache/code-aide/npm-operations/operation-*`. Each invocation gets its own
+directory on the home filesystem instead of the temporary filesystem. npm
+authentication, user configuration and install prefixes remain in effect; only
+the download-cache setting is overridden in the child environment.
+
+Downloads and npm logs in that directory are removed after success, failure,
+timeouts supported by the command runner, and normal Python interruption.
+Captured command errors are still reported. Existing user caches are preserved.
+Dry runs create no operation cache. Concurrent operations never clean another
+operation's cache. A hard kill or machine crash can leave an operation
+directory; inspect it and establish that its operation has stopped before
+explicitly removing it. There is no automatic age-based cleanup of these
+directories.

{code_aide-1.18.4 → code_aide-1.19.0}/README.md

@@ -207,3 +207,21 @@ uv run pytest tests/test_install.py::TestDetectOsArch -v
 ## License
 
 Apache-2.0
+
+## npm download cache lifetime
+
+Standalone install, upgrade, removal (including migration), and installation
+scripts use private download caches under
+`~/.cache/code-aide/npm-operations/operation-*`. Each invocation gets its own
+directory on the home filesystem instead of the temporary filesystem. npm
+authentication, user configuration and install prefixes remain in effect; only
+the download-cache setting is overridden in the child environment.
+
+Downloads and npm logs in that directory are removed after success, failure,
+timeouts supported by the command runner, and normal Python interruption.
+Captured command errors are still reported. Existing user caches are preserved.
+Dry runs create no operation cache. Concurrent operations never clean another
+operation's cache. A hard kill or machine crash can leave an operation
+directory; inspect it and establish that its operation has stopped before
+explicitly removing it. There is no automatic age-based cleanup of these
+directories.

{code_aide-1.18.4 → code_aide-1.19.0}/src/code_aide/__init__.py

@@ -1,3 +1,3 @@
 """code-aide - Manage AI coding CLI tools."""
 
-__version__ = "1.18.4"
+__version__ = "1.19.0"

{code_aide-1.18.4 → code_aide-1.19.0}/src/code_aide/console.py

@@ -1,10 +1,13 @@
 """Console output and subprocess helpers for CLI modules."""
 
+from contextlib import nullcontext
+from pathlib import Path
 import shutil
 import subprocess
-from typing import List
+from typing import Any, List
 
 from code_aide.constants import Colors
+from code_aide.npm_cache import npm_cache_environment, run_npm_process
 
 
 def info(message: str) -> None:
@@ -33,7 +36,10 @@ def command_exists(command: str) -> bool:
 
 
 def run_command(
-    cmd: List[str], check: bool = True, capture: bool = True
+    cmd: List[str],
+    check: bool = True,
+    capture: bool = True,
+    timeout: float | None = None,
 ) -> subprocess.CompletedProcess:
     """Run a tool-mutating command with consistent hardening.
 
@@ -47,19 +53,34 @@ def run_command(
     Defaults to capture+text mode. With ``check=True`` (default) a
     non-zero exit raises ``CalledProcessError``.
     """
-    if capture:
-        return subprocess.run(
+    is_npm = bool(cmd) and Path(cmd[0]).name == "npm"
+    if is_npm and any(
+        arg == "--cache" or arg.startswith("--cache=") for arg in cmd[1:]
+    ):
+        raise ValueError("npm cache overrides are managed by code-aide")
+    context = npm_cache_environment() if is_npm else nullcontext(None)
+    with context as env:
+        kwargs: dict[str, Any] = {}
+        if env is not None:
+            kwargs["env"] = env
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        runner = run_npm_process if is_npm else subprocess.run
+        if capture:
+            return runner(
+                cmd,
+                check=check,
+                capture_output=True,
+                text=True,
+                stdin=subprocess.DEVNULL,
+                **kwargs,
+            )
+        return runner(
             cmd,
             check=check,
-            capture_output=True,
-            text=True,
             stdin=subprocess.DEVNULL,
+            **kwargs,
         )
-    return subprocess.run(
-        cmd,
-        check=check,
-        stdin=subprocess.DEVNULL,
-    )
 
 
 def called_process_error_message(exc: subprocess.CalledProcessError) -> str:

{code_aide-1.18.4 → code_aide-1.19.0}/src/code_aide/install.py

@@ -6,6 +6,7 @@ import os
 import platform
 import shutil
 import subprocess
+
 import tarfile
 import tempfile
 from dataclasses import dataclass
@@ -21,6 +22,7 @@ from code_aide.console import (
     success,
     warning,
 )
+from code_aide.npm_cache import npm_cache_environment, stop_process_group
 from code_aide.install_types import InstallType, get_tool_install_type
 from code_aide.versions import check_script_tool, fetch_url
 
@@ -113,13 +115,20 @@ def run_install_script(
         warning(f"About to execute install script for {tool_name}")
         warning("This will run with your user privileges. Press Ctrl+C to cancel.")
 
-        bash_process = subprocess.Popen(
-            ["bash"],
-            stdin=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            env=env,
-        )
-        _, stderr = bash_process.communicate(input=script_content)
+        # Scripts may invoke npm themselves; inherit the same bounded cache.
+        with npm_cache_environment(env) as script_env:
+            bash_process = subprocess.Popen(
+                ["bash"],
+                stdin=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=script_env,
+                start_new_session=True,
+            )
+            try:
+                _, stderr = bash_process.communicate(input=script_content)
+            except BaseException:
+                stop_process_group(bash_process)
+                raise
 
         if bash_process.returncode == 0:
             return True

code_aide-1.19.0/src/code_aide/npm_cache.py

@@ -0,0 +1,61 @@
+"""Private download-cache lifetimes for npm commands and installer scripts."""
+
+from contextlib import contextmanager
+import os
+import signal
+import subprocess
+from pathlib import Path
+import tempfile
+from typing import Any, Iterator, Mapping
+
+
+@contextmanager
+def npm_cache_environment(
+    env: Mapping[str, str] | None = None,
+) -> Iterator[dict[str, str]]:
+    """Keep downloads on the home filesystem and remove only this invocation."""
+    root = Path.home() / ".cache" / "code-aide" / "npm-operations"
+    current = Path.home()
+    for component in (".cache", "code-aide", "npm-operations"):
+        current = current / component
+        if current.is_symlink():
+            raise ValueError(f"npm operation cache parent is a symlink: {current}")
+        current.mkdir(exist_ok=True, mode=0o700)
+        if current.stat().st_uid != os.getuid():
+            raise ValueError(f"npm operation cache parent has another owner: {current}")
+    with tempfile.TemporaryDirectory(prefix="operation-", dir=root) as directory:
+        child_env = dict(os.environ if env is None else env)
+        # npm treats config environment keys case-insensitively.
+        for key in list(child_env):
+            if key.lower() == "npm_config_cache":
+                del child_env[key]
+        child_env["npm_config_cache"] = directory
+        yield child_env
+
+
+def stop_process_group(process: subprocess.Popen) -> None:
+    """Stop the entire private process group before its cache is removed."""
+    try:
+        os.killpg(process.pid, signal.SIGKILL)
+    except ProcessLookupError:
+        pass
+    process.communicate(timeout=5)
+
+
+def run_npm_process(cmd: list[str], **kwargs: Any) -> subprocess.CompletedProcess:
+    """Run npm in its own session and reap its children on cancellation."""
+    check = kwargs.pop("check", True)
+    timeout = kwargs.pop("timeout", None)
+    if kwargs.pop("capture_output", False):
+        kwargs["stdout"] = subprocess.PIPE
+        kwargs["stderr"] = subprocess.PIPE
+    with subprocess.Popen(cmd, start_new_session=True, **kwargs) as process:
+        try:
+            stdout, stderr = process.communicate(timeout=timeout)
+        except BaseException:
+            stop_process_group(process)
+            raise
+        result = subprocess.CompletedProcess(cmd, process.returncode, stdout, stderr)
+        if check:
+            result.check_returncode()
+        return result

{code_aide-1.18.4 → code_aide-1.19.0}/tests/test_install.py

@@ -200,20 +200,22 @@ class TestInstallScriptEnv(unittest.TestCase):
         mock_fetch.return_value = (script_content, None)
         env = {"PATH": "/tmp/bin:/usr/bin"}
 
-        result = cli_install.run_install_script(
-            "https://example.com/install.sh",
-            "Example",
-            expected_sha256,
-            env=env,
-        )
+        with tempfile.TemporaryDirectory() as home:
+            with mock.patch.dict(os.environ, {"HOME": home}):
+                result = cli_install.run_install_script(
+                    "https://example.com/install.sh",
+                    "Example",
+                    expected_sha256,
+                    env=env,
+                )
 
         self.assertTrue(result)
-        mock_popen.assert_called_once_with(
-            ["bash"],
-            stdin=cli_install.subprocess.PIPE,
-            stderr=cli_install.subprocess.PIPE,
-            env=env,
-        )
+        mock_popen.assert_called_once()
+        actual_env = mock_popen.call_args.kwargs["env"]
+        self.assertEqual(actual_env["PATH"], env["PATH"])
+        self.assertIn("npm_config_cache", actual_env)
+        self.assertFalse(os.path.exists(actual_env["npm_config_cache"]))
+        self.assertEqual(env, {"PATH": "/tmp/bin:/usr/bin"})
 
 
 class TestInstallDirectDownloadDryrun(unittest.TestCase):

code_aide-1.19.0/tests/test_npm_cache.py

@@ -0,0 +1,204 @@
+"""Cache lifetime regressions through standalone operation dispatch."""
+
+from concurrent.futures import ThreadPoolExecutor
+import os
+from pathlib import Path
+import subprocess
+import threading
+
+import pytest
+
+from code_aide import console, constants, install, operations
+from code_aide.npm_cache import npm_cache_environment
+
+
+@pytest.fixture
+def cache_home(tmp_path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    return tmp_path
+
+
+@pytest.mark.parametrize("route", ["install", "upgrade", "remove"])
+@pytest.mark.parametrize("fail", [False, True])
+def test_operation_downloads_removed(cache_home, monkeypatch, route, fail):
+    user_cache = cache_home / "existing-cache"
+    user_cache.mkdir()
+    marker = user_cache / "keep"
+    marker.write_text("existing")
+    monkeypatch.setenv("NPM_CONFIG_CACHE", str(user_cache))
+    monkeypatch.setenv("npm_config_prefix", "/example/prefix")
+    monkeypatch.setenv("NPM_TOKEN", "fake-token")
+    original = os.environ.copy()
+    seen = []
+
+    def run(cmd, **kwargs):
+        env = kwargs["env"]
+        cache = Path(env["npm_config_cache"])
+        assert cache.stat().st_mode & 0o777 == 0o700
+        assert "NPM_CONFIG_CACHE" not in env
+        assert env["npm_config_prefix"] == "/example/prefix"
+        assert env["NPM_TOKEN"] == "fake-token"
+        (cache / "download").write_bytes(b"synthetic tarball")
+        seen.append(cache)
+        if fail:
+            raise subprocess.CalledProcessError(1, cmd, stderr="fake failure")
+        return subprocess.CompletedProcess(cmd, 0, stdout="/example/prefix")
+
+    cfg = dict(
+        name="Fake Tool",
+        command="fake-tool",
+        install_type="npm",
+        npm_package="fake-tool",
+        next_steps="Run fake-tool",
+    )
+    monkeypatch.setitem(constants._TOOLS_DATA, "fake", cfg)
+    monkeypatch.setattr(console, "run_npm_process", run)
+    monkeypatch.setattr(install, "command_exists", lambda _: False)
+    monkeypatch.setattr(install.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(operations, "is_tool_installed", lambda _: True)
+    monkeypatch.setattr(operations, "is_deprecated_install", lambda _: False)
+    monkeypatch.setattr(
+        operations,
+        "detect_install_method",
+        lambda _: {"method": "npm", "detail": "fake-tool"},
+    )
+    monkeypatch.setattr(operations, "_get_upgrade_snapshot", lambda *a: {})
+    monkeypatch.setattr(
+        operations,
+        "_upgrade_result_from_snapshots",
+        lambda *a: operations.UpgradeResult.CHANGED,
+    )
+    if route == "install":
+        assert bool(install.install_tool("fake")) is not fail
+    elif route == "upgrade":
+        result = operations.upgrade_tool("fake")
+        assert (result == operations.UpgradeResult.FAILED) is fail
+    else:
+        assert operations.remove_tool("fake") is not fail
+    assert seen and all(not p.exists() for p in seen)
+    assert marker.read_text() == "existing"
+    assert os.environ == original
+
+
+def test_concurrent_operations_keep_each_others_downloads(cache_home):
+    barrier = threading.Barrier(2)
+
+    def operation(_):
+        with npm_cache_environment() as env:
+            path = Path(env["npm_config_cache"])
+            (path / "download").write_text("data")
+            barrier.wait(timeout=5)
+            assert len(list(path.parent.iterdir())) == 2
+            barrier.wait(timeout=5)
+            return path
+
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        paths = list(pool.map(operation, range(2)))
+    assert paths[0] != paths[1]
+    assert all(not path.exists() for path in paths)
+
+
+@pytest.mark.parametrize("exception", [KeyboardInterrupt, subprocess.TimeoutExpired])
+def test_exception_cleanup(cache_home, monkeypatch, exception):
+    seen = []
+
+    def run(cmd, **kwargs):
+        seen.append(Path(kwargs["env"]["npm_config_cache"]))
+        if exception is subprocess.TimeoutExpired:
+            raise exception(cmd, 0.01)
+        raise exception()
+
+    monkeypatch.setattr(console, "run_npm_process", run)
+    with pytest.raises(exception):
+        console.run_command(["npm", "install", "fake"], timeout=0.01)
+    assert not seen[0].exists()
+
+
+def test_non_npm_and_dryrun_do_not_create_cache(cache_home, monkeypatch):
+    monkeypatch.setattr(
+        console.subprocess, "run", lambda cmd, **kw: subprocess.CompletedProcess(cmd, 0)
+    )
+    console.run_command(["example", "install"])
+    monkeypatch.setattr(install, "command_exists", lambda _: False)
+    monkeypatch.setattr(install.platform, "system", lambda: "Linux")
+    assert install.install_tool("codex", dryrun=True)
+    assert not (cache_home / ".cache").exists()
+
+
+@pytest.mark.parametrize("returncode", [0, 1])
+def test_script_downloads_removed(cache_home, monkeypatch, returncode):
+    # Real bash exercises an installer subprocess rather than mocking its env.
+    fake_bin = cache_home / "bin"
+    fake_bin.mkdir()
+    fake_npm = fake_bin / "npm"
+    fake_npm.write_text(
+        "#!/bin/sh\n"
+        'mkdir -p "$npm_config_cache/nested"\n'
+        'printf download > "$npm_config_cache/nested/archive"\n'
+        'printf "%s" "$npm_config_cache" > "$HOME/observed-cache"\n'
+        f"exit {returncode}\n"
+    )
+    fake_npm.chmod(0o755)
+    monkeypatch.setenv("PATH", str(fake_bin) + os.pathsep + os.environ["PATH"])
+    script = b"npm install -g fake-tool\n"
+    monkeypatch.setattr(install, "fetch_url", lambda _: (script, None))
+    assert install.run_install_script("https://example.invalid", "Fake") is (
+        returncode == 0
+    )
+    observed = Path((cache_home / "observed-cache").read_text())
+    assert not observed.exists()
+
+
+def test_explicit_cache_override_rejected_before_cache_creation(cache_home):
+    with pytest.raises(ValueError, match="cache overrides"):
+        console.run_command(["npm", "install", "--cache=/example"])
+    assert not (cache_home / ".cache").exists()
+
+
+def test_symlink_cache_parent_rejected(cache_home, tmp_path):
+    target = tmp_path / "outside"
+    target.mkdir(mode=0o755)
+    (cache_home / ".cache").symlink_to(target)
+    with pytest.raises(ValueError, match="symlink"):
+        with npm_cache_environment():
+            pytest.fail("must reject symlink")
+    assert not list(target.iterdir())
+    assert target.stat().st_mode & 0o777 == 0o755
+
+
+def test_real_timeout_stops_descendant_before_cleanup(cache_home, monkeypatch):
+    import sys
+    import time
+
+    fake_bin = cache_home / "bin"
+    fake_bin.mkdir()
+    cache_record = cache_home / "cache-path"
+    ready = cache_home / "ready"
+    child = cache_home / "writer.py"
+    child.write_text(
+        "import os, pathlib, time\n"
+        "p = pathlib.Path(os.environ['npm_config_cache'])\n"
+        "pathlib.Path(os.environ['HOME'], 'ready').write_text('ready')\n"
+        "while True:\n"
+        " p.mkdir(parents=True, exist_ok=True)\n"
+        " (p / 'download').write_text('data')\n"
+        " time.sleep(0.01)\n"
+    )
+    fake_npm = fake_bin / "npm"
+    fake_npm.write_text(
+        f"#!{sys.executable}\n"
+        "import os, pathlib, subprocess, sys, time\n"
+        "pathlib.Path(os.environ['HOME'], 'cache-path').write_text(os.environ['npm_config_cache'])\n"
+        f"subprocess.Popen([sys.executable, {str(child)!r}])\n"
+        "time.sleep(30)\n"
+    )
+    fake_npm.chmod(0o755)
+    monkeypatch.setenv("PATH", str(fake_bin) + os.pathsep + os.environ["PATH"])
+    with pytest.raises(subprocess.TimeoutExpired):
+        console.run_command(["npm", "install", "fake"], timeout=0.5)
+    assert ready.exists()
+    cache = Path(cache_record.read_text())
+    assert not cache.exists()
+    # The descendant would recreate its directory within 10ms if still alive.
+    time.sleep(0.1)
+    assert not cache.exists()