agentcap-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentcap-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: API-key spend guard for unattended Codex CLI and Gemini CLI runs: hard per-run cap, kills the process at the limit.
 Project-URL: Homepage, https://agentcap.launchbench.studio
 Project-URL: Repository, https://github.com/Blitz00X/agentcap
@@ -71,6 +71,8 @@ pipx install agentcap-cli
 pip install agentcap-cli
 ```
 
+No pipx? macOS: `brew install pipx && pipx ensurepath`; Linux: `python3 -m pip install --user pipx && python3 -m pipx ensurepath`.
+
 From a checkout:
 
 ```bash
@@ -187,6 +189,8 @@ Tested with a real Gemini API key on Gemini CLI 0.66 (spend metered from Google'
 usageMetadata, output clamped to the cap); Gemini CLI 0.58 and Codex CLI 0.163 are
 tested end-to-end against a local fake API only, not yet with real paid keys.
 
+**Platforms:** Linux and macOS. Windows: not yet (use WSL2).
+
 ## How it works
 
 1. `agentcap run` starts the proxy on a random free port, bound **only** to
@@ -348,6 +352,8 @@ Pick what matches your setup — these tools can also be combined.
 
 MIT — see [LICENSE](LICENSE). Copyright (c) 2026 Kutay Karahan.
 
+After purchase, copy your license key from your Polar order (purchase email / Polar customer portal), then run `agentcap license activate "YOUR_LICENSE_KEY"` and check with `agentcap license status` (expect `tier: pro`).
+
 The Pro licence key is separate from the source licence. How it is checked:
 
 - On activation the key is validated against Polar's public licence API

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/README.md

@@ -41,6 +41,8 @@ pipx install agentcap-cli
 pip install agentcap-cli
 ```
 
+No pipx? macOS: `brew install pipx && pipx ensurepath`; Linux: `python3 -m pip install --user pipx && python3 -m pipx ensurepath`.
+
 From a checkout:
 
 ```bash
@@ -157,6 +159,8 @@ Tested with a real Gemini API key on Gemini CLI 0.66 (spend metered from Google'
 usageMetadata, output clamped to the cap); Gemini CLI 0.58 and Codex CLI 0.163 are
 tested end-to-end against a local fake API only, not yet with real paid keys.
 
+**Platforms:** Linux and macOS. Windows: not yet (use WSL2).
+
 ## How it works
 
 1. `agentcap run` starts the proxy on a random free port, bound **only** to
@@ -318,6 +322,8 @@ Pick what matches your setup — these tools can also be combined.
 
 MIT — see [LICENSE](LICENSE). Copyright (c) 2026 Kutay Karahan.
 
+After purchase, copy your license key from your Polar order (purchase email / Polar customer portal), then run `agentcap license activate "YOUR_LICENSE_KEY"` and check with `agentcap license status` (expect `tier: pro`).
+
 The Pro licence key is separate from the source licence. How it is checked:
 
 - On activation the key is validated against Polar's public licence API

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentcap-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "API-key spend guard for unattended Codex CLI and Gemini CLI runs: hard per-run cap, kills the process at the limit."
 readme = "README.md"
 requires-python = ">=3.11"

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/src/agentcap/__init__.py

@@ -2,6 +2,6 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 __all__ = ["__version__"]

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/src/agentcap/cli.py

@@ -33,11 +33,33 @@ from .upstreams import UpstreamConfigError, resolve_upstreams
 
 DEFAULT_SERVE_PORT = 8787
 
+WINDOWS_UNSUPPORTED = (
+    "agentcap: Windows is not supported yet (process-group stop is POSIX-only). "
+    "Use WSL2, macOS or Linux."
+)
+PRO_CAP_MESSAGE = (
+    "agentcap: --hour-cap/--day-cap require an active Pro license; "
+    "command was not started. Run `agentcap license status`, then "
+    '`agentcap license activate "YOUR_LICENSE_KEY"`.'
+)
+LICENSE_USAGE_MESSAGE = (
+    'Usage: agentcap license activate "YOUR_LICENSE_KEY" '
+    "(copy the key from your Polar purchase / customer portal)"
+)
+LICENSE_INVALID_MESSAGE = (
+    "License key not found or no longer valid. Check the copied key; "
+    "if it still fails, email kutaykarahan6@gmail.com."
+)
+
+
+def _windows_unsupported() -> bool:
+    return os.name == "nt" or sys.platform.startswith("win")
+
 
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="agentcap",
-        description="Local, hard USD cap for AI agent runs.",
+        description="Local USD spend cap for AI agent runs.",
     )
     parser.add_argument("--version", action="version", version=f"agentcap {__version__}")
     subparsers = parser.add_subparsers(dest="subcommand")
@@ -166,19 +188,41 @@ def _license_manager() -> LicenseManager:
     return LicenseManager()
 
 
+def _license_persist_error(exc: OSError, path) -> str:
+    detail = exc.strerror or str(exc)
+    return (
+        "agentcap: license validated, but could not save activation to "
+        f"{path}: {detail}. Check write permission and free disk space."
+    )
+
+
 def _license(args: argparse.Namespace) -> int:
+    manager = _license_manager()
     if args.action == "activate":
         if not args.key:
-            print("agentcap: license activate requires a key", file=sys.stderr)
+            print(LICENSE_USAGE_MESSAGE, file=sys.stderr)
             return 2
-        status = _license_manager().activate(args.key)
+        try:
+            status = manager.activate(args.key)
+        except OSError as exc:
+            print(_license_persist_error(exc, manager.path), file=sys.stderr)
+            return 1
         print(f"tier: {status.tier}")
         print(f"valid: {status.valid}")
         print(f"reason: {status.reason}")
+        if (
+            not status.valid
+            and "could not reach the license server" not in status.reason
+        ):
+            print(LICENSE_INVALID_MESSAGE, file=sys.stderr)
         return 0 if status.valid else 1
 
     if args.action == "deactivate":
-        _license_manager().clear()
+        try:
+            manager.clear()
+        except OSError as exc:
+            print(_license_persist_error(exc, manager.path), file=sys.stderr)
+            return 1
         print("license cache cleared")
         return 0
 
@@ -189,6 +233,7 @@ def _license(args: argparse.Namespace) -> int:
         print(f"tier: {status.tier}")
         print(f"valid: {status.valid}")
         print(f"reason: {status.reason}")
+        print(f"cache path: {manager.path}")
     return 0
 
 
@@ -219,6 +264,9 @@ def _upstream_overrides() -> dict[str, str] | None:
 
 
 def _run(args: argparse.Namespace) -> int:
+    if _windows_unsupported():
+        print(WINDOWS_UNSUPPORTED, file=sys.stderr)
+        return 2
     argv = list(args.argv)
     if argv and argv[0] == "--":
         argv = argv[1:]
@@ -244,18 +292,12 @@ def _run(args: argparse.Namespace) -> int:
         return 2
 
     active_features = set(features(status_from_environment().tier))
-    if hour_cap is not None and "hour_cap" not in active_features:
-        print(
-            "agentcap: --hour-cap requires AgentCap Pro; ignoring it on the free tier.",
-            file=sys.stderr,
-        )
-        hour_cap = None
-    if day_cap is not None and "day_cap" not in active_features:
-        print(
-            "agentcap: --day-cap requires AgentCap Pro; ignoring it on the free tier.",
-            file=sys.stderr,
-        )
-        day_cap = None
+    if (
+        (hour_cap is not None and "hour_cap" not in active_features)
+        or (day_cap is not None and "day_cap" not in active_features)
+    ):
+        print(PRO_CAP_MESSAGE, file=sys.stderr)
+        return 2
 
     try:
         runner = Runner(
@@ -327,6 +369,9 @@ def _serve(args: argparse.Namespace) -> int:
 
 # ------------------------------------------------------------------------ demo
 def _demo(_args: argparse.Namespace) -> int:
+    if _windows_unsupported():
+        print(WINDOWS_UNSUPPORTED, file=sys.stderr)
+        return 2
     from .demo import run_demo
 
     return run_demo()

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/src/agentcap/license.py

@@ -569,16 +569,23 @@ class LicenseManager:
 
         if status.valid:
             if self.persists:
-                self._write(
-                    effective_key,
-                    status,
-                    now,
-                    activation_id,
-                    last_attempt_at=now,
-                )
+                try:
+                    self._write(
+                        effective_key,
+                        status,
+                        now,
+                        activation_id,
+                        last_attempt_at=now,
+                    )
+                except OSError:
+                    # A read-only cache must not break a validated run.
+                    pass
         elif same_key is not None and self.persists:
             # Definitive rejection: make sure a stale Pro cache cannot survive.
-            self.clear()
+            try:
+                self.clear()
+            except OSError:
+                pass
         return status
 
     def _offline(

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/src/agentcap/proxy.py

@@ -8,8 +8,10 @@ Design rules that this module enforces:
   the request (HTTP 403/400) instead of forwarding it unmetered.
 * Credentials (``Authorization``, ``x-goog-api-key``, ``?key=``) are forwarded
   untouched but never parsed, logged, stored or emitted in events.
-* Failures to meter (client disconnect, missing usage block) settle the whole
-  reservation: over-charging a run is safe, under-charging is not.
+* Failures to meter settle the reservation conservatively: a mid-stream
+  disconnect or a missing usage block charges the whole reservation, while a
+  disconnect before upstream headers charges only the estimated input (output
+  was never delivered).
 
 Endpoint contract::
 
@@ -112,6 +114,10 @@ class _Settlement:
     requested_tier: str | None = None
     multiplier: Decimal = Decimal("1")
     now: datetime | None = None
+    #: Padded input-token estimate used to reserve this request.  If the client
+    #: disconnects before the upstream answers, this is the part the provider
+    #: may already have billed.
+    input_tokens: int = 0
 
 
 @dataclass(frozen=True)
@@ -851,6 +857,7 @@ class _Proxy:
             requested_tier=requested_tier,
             multiplier=tier_multiplier,
             now=now,
+            input_tokens=input_tokens,
         )
 
         if streaming:
@@ -966,9 +973,18 @@ class _Proxy:
                 "agentcap: upstream request failed; reservation released.",
                 "agentcap_upstream_error",
             )
+        except BaseException:
+            # The client went away (or the handler was cancelled) while waiting
+            # for the upstream: charge only the input the provider may already
+            # have billed, then let the cancellation propagate.
+            await self._abort_response(response)
+            self._settle_client_disconnect(
+                reservation_id, reserved, settlement, model, provider
+            )
+            raise
         finally:
             if response is not None:
-                with contextlib.suppress(Exception):
+                with contextlib.suppress(BaseException):
                     await response.aclose()
 
         assert response is not None
@@ -1006,6 +1022,7 @@ class _Proxy:
         kind: str,
         provider: str,
     ) -> Response:
+        response: httpx.Response | None = None
         try:
             response = await self._client.send(upstream, stream=True)
         except httpx.HTTPError:
@@ -1015,6 +1032,14 @@ class _Proxy:
                 "agentcap: upstream request failed; reservation released.",
                 "agentcap_upstream_error",
             )
+        except BaseException:
+            # Cancelled (or the client disconnected) before the upstream
+            # produced headers.  Abort and charge the estimated input only.
+            await self._abort_response(response)
+            self._settle_client_disconnect(
+                reservation_id, reserved, settlement, model, provider
+            )
+            raise
 
         if response.status_code >= 400:
             # Errors are not streams; drain, release, and replay as a response.
@@ -1027,8 +1052,14 @@ class _Proxy:
                     "agentcap: upstream request failed; reservation released.",
                     "agentcap_upstream_error",
                 )
+            except BaseException:
+                await self._abort_response(response)
+                self._settle_client_disconnect(
+                    reservation_id, reserved, settlement, model, provider
+                )
+                raise
             finally:
-                with contextlib.suppress(Exception):
+                with contextlib.suppress(BaseException):
                     await response.aclose()
             self._release_quietly(reservation_id)
             return Response(
@@ -1105,6 +1136,71 @@ class _Proxy:
         except Exception:
             pass
 
+    @staticmethod
+    async def _abort_response(response: httpx.Response | None) -> None:
+        """Close an in-flight upstream response without hiding cancellation."""
+
+        if response is None:
+            return
+        with contextlib.suppress(BaseException):
+            await response.aclose()
+
+    def _input_only_cost(self, settlement: _Settlement) -> Decimal | None:
+        """Cost of the prompt alone: provider may have billed it before close."""
+
+        try:
+            charged = pricing_cost(
+                settlement.price,
+                settlement.input_tokens,
+                0,
+                0,
+                now=settlement.now,
+                cache_write=settlement.cache_write,
+            )
+            if settlement.multiplier != 1:
+                charged = (charged * settlement.multiplier).quantize(
+                    MICRO_USD, rounding=ROUND_CEILING
+                )
+            return charged
+        except Exception:
+            return None
+
+    def _settle_client_disconnect(
+        self,
+        reservation_id: str,
+        reserved: Decimal,
+        settlement: _Settlement,
+        model: str,
+        provider: str,
+    ) -> None:
+        """Settle a reservation after a client disconnect / cancellation.
+
+        Output is assumed to be zero because the connection was closed; the
+        provider may still have billed the input.  The reservation must never
+        be left open, so a fallback charge (the full reservation) is used if
+        the input cost cannot be computed, and a failed settle is released.
+        """
+
+        charged = self._input_only_cost(settlement)
+        if charged is None:
+            charged = reserved
+        try:
+            self.ledger.settle(reservation_id, charged)
+        except Exception:
+            self._release_quietly(reservation_id)
+        self._emit(
+            {
+                "type": "client_disconnect",
+                "reserved_usd": str(reserved),
+                "charged_usd": str(charged),
+            }
+        )
+        try:
+            self._check_thresholds()
+        except Exception:
+            pass
+        self._trip_if_cap_reached(model, provider)
+
     def _settle_actual(
         self,
         reservation_id: str,

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/src/agentcap/runner.py

@@ -192,6 +192,9 @@ class Runner:
         self.kill_reason: str | None = None
         self._kill_lock = threading.Lock()
         self.child: subprocess.Popen | None = None
+        #: Process-group id captured at spawn, so the group can still be
+        #: signalled after the leader has exited (orphaned grandchildren).
+        self._pgid: int | None = None
         self.summary: RunSummary | None = None
 
         self.alerts = alerts or dispatcher_from_env(
@@ -361,28 +364,41 @@ class Runner:
     def _spawn(
         self, argv: Sequence[str] | None = None, env: Mapping[str, str] | None = None
     ) -> subprocess.Popen:
-        return self.popen_factory(
+        child = self.popen_factory(
             self.argv if argv is None else argv,
             self.child_env() if env is None else env,
         )
+        # Capture the group now: once the leader exits, os.getpgid(pid) fails
+        # even though the group (and its children) may still be alive.
+        try:
+            self._pgid = os.getpgid(child.pid)
+        except (ProcessLookupError, OSError):
+            self._pgid = None
+        return child
 
     def _signal_group(self, sig: int) -> None:
         child = self.child
-        if child is None or child.poll() is not None:
-            return
-        try:
-            pgid = os.getpgid(child.pid)
-        except (ProcessLookupError, OSError):
-            pgid = None
-        try:
-            if pgid is not None and pgid != os.getpgrp():
+        pgid = self._pgid
+        if pgid is None and child is not None and child.poll() is None:
+            try:
+                pgid = os.getpgid(child.pid)
+            except (ProcessLookupError, OSError):
+                pgid = None
+
+        if pgid is not None and pgid != os.getpgrp():
+            try:
                 os.killpg(pgid, sig)
-            else:
-                # A custom popen factory may not have created a new session;
-                # never signal our own process group.
+                return
+            except (ProcessLookupError, PermissionError, OSError):
+                pass
+
+        # A custom popen factory may not have created a new session; never
+        # signal our own process group, and only signal a live leader.
+        if child is not None and child.poll() is None:
+            try:
                 child.send_signal(sig)
-        except (ProcessLookupError, PermissionError, OSError):
-            pass
+            except (ProcessLookupError, PermissionError, OSError):
+                pass
 
     def _terminate(self) -> None:
         self._signal_group(signal.SIGTERM)
@@ -391,9 +407,10 @@ class Runner:
             return
         try:
             child.wait(timeout=self.term_timeout)
-            return
         except subprocess.TimeoutExpired:
             pass
+        # Even if the leader exited within the grace period, grandchildren may
+        # still be running in its process group: SIGKILL the saved group too.
         self._signal_group(signal.SIGKILL)
         try:
             child.wait(timeout=5.0)

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/tests/test_cli.py

@@ -69,16 +69,22 @@ def test_run_cap_comes_from_env(fake_runner, monkeypatch):
     assert fake_runner.instances[1].kwargs["cap"] == Decimal("0.25")
 
 
-def test_free_tier_ignores_hour_and_day_caps_with_one_line_notice(fake_runner, capsys):
+def test_free_tier_refuses_hour_and_day_caps_without_starting(fake_runner, capsys):
     assert cli.main(
         ["run", "--hour-cap", "1", "--day-cap", "2", "--", "true"]
-    ) == 0
-    runner = fake_runner.instances[0]
-    assert runner.kwargs["hour_cap"] is None
-    assert runner.kwargs["day_cap"] is None
+    ) == 2
+    assert fake_runner.instances == []
     err = capsys.readouterr().err
-    assert "--hour-cap requires AgentCap Pro" in err
-    assert "--day-cap requires AgentCap Pro" in err
+    assert "--hour-cap/--day-cap require an active Pro license" in err
+    assert "command was not started" in err
+    assert 'agentcap license activate "YOUR_LICENSE_KEY"' in err
+
+
+@pytest.mark.parametrize("flag", ["--hour-cap", "--day-cap"])
+def test_free_tier_refuses_each_pro_cap_individually(fake_runner, capsys, flag):
+    assert cli.main(["run", flag, "1", "--", "true"]) == 2
+    assert fake_runner.instances == []
+    assert "require an active Pro license" in capsys.readouterr().err
 
 
 def test_pro_license_enables_hour_and_day_caps(fake_runner, tmp_path, capsys):
@@ -234,7 +240,127 @@ def test_license_deactivate_clears_local_cache(monkeypatch, tmp_path, capsys):
 def test_license_activate_without_key_fails(monkeypatch, tmp_path, capsys):
     monkeypatch.setenv("AGENTCAP_LICENSE_FILE", str(tmp_path / "license.json"))
     assert cli.main(["license", "activate"]) == 2
-    assert "requires a key" in capsys.readouterr().err
+    err = capsys.readouterr().err
+    assert 'Usage: agentcap license activate "YOUR_LICENSE_KEY"' in err
+    assert "Polar purchase / customer portal" in err
+
+
+def test_license_activate_invalid_key_prints_actionable_message(
+    monkeypatch, tmp_path, capsys
+):
+    monkeypatch.setenv("AGENTCAP_LICENSE_FILE", str(tmp_path / "license.json"))
+
+    class DenyingPolar:
+        persist = True
+
+        def activate(self, key):
+            return LicenseStatus(False, "free", "license key not found"), None
+
+        def validate(self, key, activation_id=None):
+            return LicenseStatus(False, "free", "license key not found")
+
+    monkeypatch.setattr(license_module, "PolarLicenseValidator", DenyingPolar)
+
+    assert cli.main(["license", "activate", "wrong-key"]) == 1
+    captured = capsys.readouterr()
+    assert "tier: free" in captured.out
+    assert "License key not found or no longer valid" in captured.err
+    assert "kutaykarahan6@gmail.com" in captured.err
+    assert "wrong-key" not in captured.out + captured.err
+
+
+def test_license_status_prints_cache_path_but_never_the_key(
+    monkeypatch, tmp_path, capsys
+):
+    path = tmp_path / "license.json"
+    write_pro_cache(path)
+    monkeypatch.setenv("AGENTCAP_LICENSE_FILE", str(path))
+
+    assert cli.main(["license", "status"]) == 0
+    out = capsys.readouterr().out
+    assert f"cache path: {path}" in out
+    assert "polar-key" not in out
+
+
+def test_license_activate_save_error_is_reported_without_traceback(
+    monkeypatch, tmp_path, capsys
+):
+    path = tmp_path / "license.json"
+    monkeypatch.setenv("AGENTCAP_LICENSE_FILE", str(path))
+
+    class GrantingPolar:
+        persist = True
+
+        def activate(self, key):
+            return LicenseStatus(True, "pro", "license valid"), "act_123"
+
+        def validate(self, key, activation_id=None):
+            return LicenseStatus(True, "pro", "license valid")
+
+    monkeypatch.setattr(license_module, "PolarLicenseValidator", GrantingPolar)
+
+    def fail_write(*args, **kwargs):
+        raise OSError(28, "No space left on device")
+
+    monkeypatch.setattr(license_module.LicenseManager, "_write", fail_write)
+
+    assert cli.main(["license", "activate", "polar-key-secret"]) == 1
+    captured = capsys.readouterr()
+    assert captured.err.startswith("agentcap: license validated, but could not save"
+                                   " activation to ")
+    assert str(path) in captured.err
+    assert "No space left on device" in captured.err
+    assert "Check write permission and free disk space." in captured.err
+    assert "Traceback" not in captured.err
+    assert "polar-key-secret" not in captured.out + captured.err
+
+
+def test_license_deactivate_clear_error_is_reported_without_traceback(
+    monkeypatch, tmp_path, capsys
+):
+    path = tmp_path / "license.json"
+    monkeypatch.setenv("AGENTCAP_LICENSE_FILE", str(path))
+
+    def fail_clear(self):
+        raise OSError(13, "Permission denied")
+
+    monkeypatch.setattr(license_module.LicenseManager, "clear", fail_clear)
+
+    assert cli.main(["license", "deactivate"]) == 1
+    captured = capsys.readouterr()
+    assert "license validated, but could not save activation" in captured.err
+    assert str(path) in captured.err
+    assert "Permission denied" in captured.err
+    assert "Traceback" not in captured.err
+
+
+@pytest.mark.parametrize("platform_name", ["nt"])
+def test_run_refuses_windows_before_starting(
+    monkeypatch, fake_runner, capsys, platform_name
+):
+    monkeypatch.setattr(cli.os, "name", platform_name)
+    assert cli.main(["run", "--", "true"]) == 2
+    assert fake_runner.instances == []
+    err = capsys.readouterr().err
+    assert "Windows is not supported yet" in err
+    assert "Use WSL2, macOS or Linux." in err
+
+
+def test_run_refuses_windows_when_only_sys_platform_is_win(
+    monkeypatch, fake_runner, capsys
+):
+    monkeypatch.setattr(cli.sys, "platform", "win32")
+    assert cli.main(["run", "--", "true"]) == 2
+    assert fake_runner.instances == []
+    assert "Windows is not supported yet" in capsys.readouterr().err
+
+
+def test_demo_refuses_windows_before_starting(monkeypatch, capsys):
+    monkeypatch.setattr(cli.os, "name", "nt")
+    assert cli.main(["demo"]) == 2
+    captured = capsys.readouterr()
+    assert "Windows is not supported yet" in captured.err
+    assert "SIMULATED DEMO" not in captured.out
 
 
 def test_license_activate_network_failure_exits_one_without_traceback(

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/tests/test_license.py

@@ -810,6 +810,45 @@ def test_clear_removes_license(tmp_path):
     assert manager.tier() == "free"
 
 
+def test_activate_propagates_oserror_when_activation_cannot_be_saved(
+    tmp_path, monkeypatch
+):
+    class PersistingValidator:
+        persist = True
+
+        def activate(self, key):
+            return LicenseStatus(True, "pro", "static license accepted"), None
+
+        def validate(self, key, activation_id=None):
+            return LicenseStatus(True, "pro", "static license accepted")
+
+    manager = LicenseManager(
+        PersistingValidator(),
+        tmp_path / "license.json",
+        clock=FakeClock(),
+    )
+
+    def fail_write(*args, **kwargs):
+        raise OSError(28, "No space left on device")
+
+    monkeypatch.setattr(manager, "_write", fail_write)
+    with pytest.raises(OSError) as excinfo:
+        manager.activate("secret-key")
+    assert excinfo.value.strerror == "No space left on device"
+
+
+def test_clear_propagates_oserror(tmp_path):
+    # A directory cannot be unlinked with Path.unlink(), which raises OSError
+    # (IsADirectoryError/PermissionError depending on platform).
+    manager = LicenseManager(
+        StaticValidator(LicenseStatus(True, "pro", "static license accepted")),
+        tmp_path,
+        clock=FakeClock(),
+    )
+    with pytest.raises(OSError):
+        manager.clear()
+
+
 def test_key_never_appears_in_reasons():
     clock = FakeClock()
     scenarios = [

agentcap_cli-0.1.3/tests/test_proxy_cancel.py

@@ -0,0 +1,98 @@
+"""Client disconnects must never leave a reservation open."""
+
+from __future__ import annotations
+
+import asyncio
+from decimal import Decimal
+
+import httpx
+import pytest
+
+from agentcap.estimate import (
+    apply_input_safety_factor,
+    estimate_input_tokens,
+)
+from agentcap.ledger import Caps, Ledger
+from agentcap.pricing import cost as pricing_cost
+from agentcap.pricing import load_pricing
+from agentcap.proxy import ProxyConfig, create_app
+
+from proxy_support import D, costs, openai_chat_body
+
+STORE = load_pricing()
+CHAT_URL = "/openai/v1/chat/completions"
+
+
+class SlowTransport(httpx.AsyncBaseTransport):
+    """Blocks after the reservation is made, before upstream headers arrive."""
+
+    def __init__(self) -> None:
+        self.started = asyncio.Event()
+        self.release = asyncio.Event()
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        self.started.set()
+        await self.release.wait()
+        return httpx.Response(
+            200,
+            json={
+                "choices": [],
+                "usage": {"prompt_tokens": 1000, "completion_tokens": 500},
+            },
+        )
+
+
+def _expected_input_only(body: dict) -> Decimal:
+    price = STORE.get("openai/gpt-4o-mini")
+    input_tokens = apply_input_safety_factor(
+        estimate_input_tokens(body), Decimal("1.25")
+    )
+    return pricing_cost(price, input_tokens, 0, 0)
+
+
+@pytest.mark.parametrize("stream", [False, True])
+def test_cancelled_request_settles_input_only_and_leaves_no_reservation(
+    tmp_path, stream
+):
+    body = openai_chat_body(max_completion_tokens=200, stream=stream)
+    expected = _expected_input_only(body)
+
+    async def scenario():
+        transport = SlowTransport()
+        ledger = Ledger(tmp_path / f"cancel-{stream}.db")
+        events: list[dict] = []
+        config = ProxyConfig(run_id="run-1", caps=Caps(run_usd=D("1")))
+        app = create_app(
+            config,
+            ledger,
+            upstream_transport=transport,
+            events=events.append,
+        )
+        proxy = app.state.proxy
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://proxy"
+        ) as client:
+            task = asyncio.create_task(client.post(CHAT_URL, json=body))
+            await asyncio.wait_for(transport.started.wait(), timeout=5)
+            task.cancel()
+            with pytest.raises(asyncio.CancelledError):
+                await task
+        await app.state.http_client.aclose()
+        return ledger, events, proxy
+
+    ledger, events, proxy = asyncio.run(scenario())
+
+    summary = ledger.summary("run-1")
+    assert summary["open"] == 0
+    assert summary["settled"] == 1
+    assert summary["actual_usd"] == expected
+    assert ledger.spent("run-1") == expected
+
+    disconnect = costs(events, "client_disconnect")
+    assert len(disconnect) == 1
+    assert Decimal(disconnect[0]["charged_usd"]) == expected
+    assert Decimal(disconnect[0]["reserved_usd"]) >= expected
+
+    # The input-only charge is far below the cap: no false kill.
+    assert proxy.killed is False
+    assert "cap_exceeded" not in [event["type"] for event in events]

{agentcap_cli-0.1.2 → agentcap_cli-0.1.3}/tests/test_runner.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import io
 import json
+import os
 import sys
 import time
 from decimal import Decimal
@@ -372,3 +373,56 @@ def test_cap_from_env(monkeypatch):
     assert cap_from_env() == Decimal("0.25")
     monkeypatch.setenv("AGENTCAP_CAP", "not-money")
     assert cap_from_env() == Decimal("5")
+
+
+def _process_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    # A zombie is already dead for our purposes; the important thing is that
+    # it no longer runs (and will be reaped by init/subreaper).
+    try:
+        stat = Path(f"/proc/{pid}/stat").read_text()
+    except OSError:
+        return True
+    return stat.split()[2] != "Z"
+
+
+@pytest.mark.skipif(os.name == "nt", reason="process groups are POSIX-only")
+def test_terminate_kills_grandchild_after_leader_already_exited(tmp_path):
+    """The saved PGID must still kill descendants when the leader is gone."""
+
+    pidfile = tmp_path / "grandchild.pid"
+    leader = (
+        "import subprocess, sys, time\n"
+        "child = subprocess.Popen([\n"
+        "    sys.executable, '-c',\n"
+        "    'import signal, time; "
+        "signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(60)',\n"
+        "])\n"
+        f"open({str(pidfile)!r}, 'w').write(str(child.pid))\n"
+        "time.sleep(0.3)\n"
+        "sys.exit(0)\n"
+    )
+    runner, _ = _runner(tmp_path, [sys.executable, "-c", "pass"])
+    runner.child = runner._spawn([sys.executable, "-c", leader], env=dict(os.environ))
+
+    runner.child.wait(timeout=5)
+    assert runner.child.poll() is not None
+    assert runner._pgid is not None
+
+    deadline = time.monotonic() + 5
+    while time.monotonic() < deadline and not pidfile.exists():
+        time.sleep(0.02)
+    grandchild = int(pidfile.read_text())
+    assert _process_alive(grandchild)
+
+    runner._terminate()
+
+    deadline = time.monotonic() + 5
+    while time.monotonic() < deadline and _process_alive(grandchild):
+        time.sleep(0.02)
+    assert not _process_alive(grandchild)