ai-limits 0.1.0__py3-none-any.whl

ai_limits/__init__.py

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

ai_limits/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

ai_limits/cli.py

@@ -0,0 +1,129 @@
+"""ai-limits: AI subscription usage limits, offline by default.
+
+  ai-limits                 human-readable summary
+  ai-limits --version       installed version
+  ai-limits json            state JSON (docs/state-schema.md), also saved to ~/.cache/ai-limits/state.json
+  ai-limits accounts        configured / detected accounts
+  ai-limits tap claude      for Claude Code's statusLine: saves rate_limits from stdin, passes stdin through
+  ai-limits tap claude --print   same, but prints a short status line instead of passing stdin through
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import sys
+import time
+from datetime import datetime
+
+from . import __version__, config
+from .core import build_state, format_duration, write_state
+from .model import normalise_home
+from .providers import claude
+
+DIM, RESET = "\033[2m", "\033[0m"
+
+
+def main(argv: list[str] | None = None) -> int:
+    # JSON and Claude's status-line protocol are UTF-8, including redirected Windows streams.
+    for stream in (sys.stdout, sys.stderr):
+        if isinstance(stream, io.TextIOWrapper):
+            stream.reconfigure(encoding="utf-8")
+    args = sys.argv[1:] if argv is None else argv
+    cmd = args[0] if args else "show"
+
+    if args == ["--version"]:
+        print(f"ai-limits {__version__}")
+        return 0
+    if cmd in ("-h", "--help", "help"):
+        print(__doc__.strip())
+        return 0
+    if cmd == "tap":
+        return _tap(args[1:])
+    if cmd not in ("show", "json", "accounts") or len(args) > 1:
+        # before loading config or providers: a typo must never trigger collection (or network)
+        print(f"ai-limits: unknown command {' '.join(args)!r} (see --help)", file=sys.stderr)
+        return 2
+
+    try:
+        cfg = config.load()
+    except config.ConfigError as e:
+        print(f"ai-limits: {e}", file=sys.stderr)
+        return 2
+
+    if cmd == "accounts":
+        print(f"config: {cfg.path or '(none, auto-detected)'}")
+        net = cfg.network
+        print(f"network: {'on via ' + net.require_interface if net.active else 'off'}")
+        for acc in cfg.accounts:
+            print(f"  {acc.id:22} {acc.provider:7} {acc.label!r:24} {acc.home}")
+        return 0
+
+    state = build_state(cfg)
+    write_state(state)
+    if cmd == "json":
+        json.dump(state, sys.stdout, ensure_ascii=False, indent=1, allow_nan=False)
+        print()
+    else:
+        _show(state, color=sys.stdout.isatty())
+    return 0
+
+
+def _tap(args: list[str]) -> int:
+    if not args or args[0] != "claude":
+        print("usage: ai-limits tap claude [--print]", file=sys.stderr)
+        return 2
+    if isinstance(sys.stdin, io.TextIOWrapper):
+        sys.stdin.reconfigure(encoding="utf-8")
+    raw = sys.stdin.read()
+    claude.tap_from_stdin(normalise_home(os.environ.get("CLAUDE_CONFIG_DIR") or "~/.claude"), raw)
+    if "--print" in args:
+        try:
+            rl = json.loads(raw).get("rate_limits") or {}
+        except (ValueError, AttributeError):
+            rl = {}
+        parts = [f"{label} {rl[key]['used_percentage']:.0f}%" for key, label in (("five_hour", "5h"), ("seven_day", "7d"))
+                 if isinstance(rl.get(key), dict) and rl[key].get("used_percentage") is not None]
+        print(" · ".join(parts) or "no limit data yet")
+    else:
+        sys.stdout.write(raw)
+    return 0
+
+
+def _show(state: dict, color: bool) -> None:
+    dim, reset = (DIM, RESET) if color else ("", "")
+    now = int(time.time())
+    if not state["accounts"]:
+        print("No accounts found (no ~/.claude or ~/.codex). See ~/.config/ai-limits/config.toml.")
+    for acc in state["accounts"]:
+        head = acc["label"] + (f" {dim}{acc['plan']}{reset}" if acc["plan"] else "")
+        if acc["recommended"]:
+            head += "  ★ most headroom"
+        if acc["status"] == "stale" and acc["updated_at"]:
+            head += f"  {dim}[updated {format_duration(now - acc['updated_at'])} ago]{reset}"
+        elif acc["status"] != "ok":
+            head += f"  {dim}[{acc['status']}{': ' + acc['message'] if acc['message'] else ''}]{reset}"
+        print(head)
+        for lim in acc["limits"]:
+            pct = f"{'~' if lim['estimated'] else ''}{lim['used_percent']:.0f}%"
+            bar = _bar(lim["used_percent"])
+            print(f"  {lim['label']:16} {bar} {pct:>5}  {dim}{_reset_text(lim['resets_at'], now)}{reset}")
+    net = state["network"]
+    print(f"{dim}network: {'on via ' + net['interface'] if net['enabled'] else 'off (offline mode)'}{reset}")
+
+
+def _bar(pct: float, width: int = 12) -> str:
+    filled = round(min(max(pct, 0), 100) / 100 * width)
+    return "█" * filled + "░" * (width - filled)
+
+
+def _reset_text(resets_at: int | None, now: int) -> str:
+    if not resets_at:
+        return ""
+    try:
+        when = datetime.fromtimestamp(resets_at)
+    except (ValueError, OverflowError, OSError):
+        return "reset time out of range"
+    same_day = when.date() == datetime.fromtimestamp(now).date()
+    return f"↻ {when.strftime('%H:%M' if same_day else '%a %H:%M')} (in {format_duration(resets_at - now)})"

ai_limits/config.py

@@ -0,0 +1,124 @@
+"""~/.config/ai-limits/config.toml, with auto-detection when no accounts are listed.
+
+    stale_after_hours = 6
+
+    [network]                      # off unless enabled AND require_interface is set
+    enabled = false
+    require_interface = "tun0"
+    min_interval_seconds = 300
+
+    [[account]]
+    provider = "codex"
+    label = "Codex · work"
+    home = "~/.codex-work"
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .model import AccountConfig, normalise_home
+
+PROVIDERS = ("claude", "codex")
+DEFAULT_HOMES = {
+    "claude": ("CLAUDE_CONFIG_DIR", "~/.claude", "Claude"),
+    "codex": ("CODEX_HOME", "~/.codex", "Codex"),
+}
+
+
+@dataclass
+class NetworkConfig:
+    enabled: bool = False
+    require_interface: str | None = None
+    min_interval_seconds: int = 300
+
+    @property
+    def active(self) -> bool:
+        # without a required interface there is nothing to check against -> stay offline
+        return self.enabled and bool(self.require_interface)
+
+
+@dataclass
+class Config:
+    accounts: list[AccountConfig] = field(default_factory=list)
+    network: NetworkConfig = field(default_factory=NetworkConfig)
+    stale_after_hours: float = 6.0
+    path: Path | None = None
+
+
+def config_dir() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "ai-limits"
+
+
+def cache_dir() -> Path:
+    return Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache") / "ai-limits"
+
+
+class ConfigError(Exception):
+    pass
+
+
+def load(path: Path | None = None) -> Config:
+    path = path or config_dir() / "config.toml"
+    raw: dict = {}
+    if path.exists():
+        try:
+            raw = tomllib.loads(path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, tomllib.TOMLDecodeError) as e:
+            raise ConfigError(f"{path}: {e}") from e
+
+    net = raw.get("network", {})
+    if not isinstance(net, dict):
+        raise ConfigError(f"{path}: [network] must be a table")
+    cfg = Config(
+        network=NetworkConfig(
+            # strict types: `enabled = "false"` must not switch the network on
+            enabled=_typed(path, "network.enabled", net.get("enabled", False), bool),
+            require_interface=_typed(path, "network.require_interface", net.get("require_interface"), str, None) or None,
+            min_interval_seconds=_typed(path, "network.min_interval_seconds", net.get("min_interval_seconds", 300), int),
+        ),
+        stale_after_hours=float(_typed(path, "stale_after_hours", raw.get("stale_after_hours", 6), (int, float))),
+        path=path if path.exists() else None,
+    )
+    if cfg.network.min_interval_seconds < 60:
+        raise ConfigError(f"{path}: network.min_interval_seconds must be at least 60")
+    if not (math.isfinite(cfg.stale_after_hours) and cfg.stale_after_hours > 0):
+        raise ConfigError(f"{path}: stale_after_hours must be a positive number")
+
+    accounts = raw.get("account", [])
+    if not isinstance(accounts, list) or not all(isinstance(e, dict) for e in accounts):
+        raise ConfigError(f"{path}: accounts must be [[account]] tables")
+    for i, entry in enumerate(accounts):
+        provider = entry.get("provider")
+        if provider not in PROVIDERS:
+            raise ConfigError(f"{path}: account #{i + 1}: provider must be one of {', '.join(PROVIDERS)}")
+        env, default_home, default_label = DEFAULT_HOMES[provider]
+        home = entry.get("home") or os.environ.get(env) or default_home
+        acc = AccountConfig(provider, _typed(path, "account.label", entry.get("label"), str, None) or default_label,
+                            normalise_home(_typed(path, "account.home", home, str)))
+        if any(a.id == acc.id for a in cfg.accounts):
+            raise ConfigError(f"{path}: account #{i + 1}: {provider} {acc.home} is listed twice")
+        cfg.accounts.append(acc)
+
+    if not cfg.accounts:
+        cfg.accounts = detect_accounts()
+    return cfg
+
+
+def _typed(path, key, value, types, *allowed):
+    if value in allowed or (isinstance(value, types) and not (isinstance(value, bool) and types is not bool)):
+        return value
+    raise ConfigError(f"{path}: {key} has the wrong type ({type(value).__name__})")
+
+
+def detect_accounts() -> list[AccountConfig]:
+    found = []
+    for provider, (env, default_home, label) in DEFAULT_HOMES.items():
+        home = normalise_home(os.environ.get(env) or default_home)
+        if os.path.isdir(home):
+            found.append(AccountConfig(provider, label, home))
+    return found

ai_limits/core.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import time
+
+from . import netguard, providers
+from .config import Config, cache_dir
+from .model import SCHEMA, Snapshot, account_json, roll_forward
+from .providers import write_json
+
+USABLE = ("ok", "stale", "vpn_off")
+
+
+def build_state(cfg: Config, now: int | None = None) -> dict:
+    now = now or int(time.time())
+    netguard.last_check = None
+    results = []
+    for acc in cfg.accounts:
+        try:
+            snap = providers.get(acc.provider).collect(acc, cfg, now)
+        except Exception as e:  # one broken account must not hide the others
+            snap = Snapshot(status="error", message=f"{type(e).__name__}: {e}")
+        _age(snap, cfg, now)
+        snap.limits = [roll_forward(lim, now) for lim in snap.limits]
+        results.append((acc, snap))
+
+    recommended = _recommended(results)
+    return {
+        "schema": SCHEMA,
+        "generated_at": now,
+        "network": {
+            "enabled": cfg.network.active,
+            "interface": cfg.network.require_interface,
+            "vpn_ok": netguard.last_check,  # only checks made during this run
+        },
+        "accounts": [account_json(acc, snap, acc.id in recommended) for acc, snap in results],
+    }
+
+
+def write_state(state: dict) -> None:
+    write_json(cache_dir() / "state.json", state)
+
+
+def _age(snap: Snapshot, cfg: Config, now: int) -> None:
+    if snap.status != "ok" or not snap.updated_at:
+        return
+    if now - snap.updated_at > cfg.stale_after_hours * 3600:
+        snap.status = "stale"  # UIs show the age from updated_at themselves
+
+
+def _recommended(results) -> set[str]:
+    """Per provider with 2+ accounts: the usable account whose busiest limit is lowest."""
+    by_provider: dict[str, list] = {}
+    for acc, snap in results:
+        by_provider.setdefault(acc.provider, []).append((acc, snap))
+    picked = set()
+    for accounts in by_provider.values():
+        if len(accounts) < 2:
+            continue
+        usable = [(max(lim.used_percent for lim in s.limits), -(s.updated_at or 0), a.id)
+                  for a, s in accounts if s.status in USABLE and s.limits]
+        if usable:
+            picked.add(min(usable)[2])
+    return picked
+
+
+def format_duration(seconds: int) -> str:
+    seconds = max(0, int(seconds))
+    if seconds < 3600:
+        return f"{seconds // 60}m"
+    if seconds < 86400:
+        return f"{seconds // 3600}h{(seconds % 3600) // 60:02d}m"
+    return f"{seconds // 86400}d{(seconds % 86400) // 3600}h"

ai_limits/model.py

@@ -0,0 +1,110 @@
+"""Data model shared by providers and the output (see docs/state-schema.md)."""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+
+SCHEMA = 1
+
+
+@dataclass
+class Limit:
+    id: str  # "5h" | "7d" | "7d:<model>" | ...
+    label: str
+    used_percent: float
+    resets_at: int | None = None
+    window_minutes: int | None = None
+    estimated: bool = False
+
+
+@dataclass
+class AccountConfig:
+    provider: str  # "claude" | "codex"
+    label: str
+    home: str  # absolute, normalised
+
+    @property
+    def id(self) -> str:
+        return f"{self.provider}-{home_key(self.home)}"
+
+
+@dataclass
+class Snapshot:
+    """What a provider found for one account."""
+
+    limits: list[Limit] = field(default_factory=list)
+    source: str | None = None  # "tap" | "sessions" | "network"
+    updated_at: int | None = None
+    plan: str | None = None
+    status: str = "ok"  # "ok" | "stale" | "no_data" | "vpn_off" | "error"
+    message: str | None = None
+
+
+def home_key(home: str) -> str:
+    """Stable 12-char key for a config dir; the statusline tap uses the same one."""
+    return hashlib.sha1(home.encode()).hexdigest()[:12]
+
+
+def normalise_home(path: str) -> str:
+    return os.path.realpath(os.path.expanduser(path))
+
+
+def percent(value) -> float | None:
+    """A usable percentage (finite, >= 0) or None; rejects NaN/inf/strings so the JSON stays valid."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    value = float(value)
+    return value if math.isfinite(value) and value >= 0 else None
+
+
+def to_epoch(value) -> int | None:
+    """Epoch seconds/milliseconds or ISO-8601 -> epoch seconds; naive ISO times mean UTC."""
+    if value is None or value == "":
+        return None
+    if isinstance(value, bool):
+        return None
+    try:
+        if isinstance(value, (int, float)):
+            if not math.isfinite(value):
+                return None
+            return int(value / 1000) if value > 1e11 else int(value)
+        when = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+        if when.tzinfo is None:
+            when = when.replace(tzinfo=timezone.utc)
+        return int(when.timestamp())
+    except (ValueError, OverflowError, OSError):
+        return None
+
+
+def roll_forward(limit: Limit, now: int) -> Limit:
+    """A window that already reset is at 0 % now; move resets_at to the next window if we know its length."""
+    if limit.resets_at is None or limit.resets_at > now:
+        return limit
+    limit.used_percent = 0.0
+    limit.estimated = True
+    if limit.window_minutes and limit.window_minutes > 0:
+        step = limit.window_minutes * 60
+        limit.resets_at += ((now - limit.resets_at) // step + 1) * step
+    else:
+        limit.resets_at = None
+    return limit
+
+
+def account_json(acc: AccountConfig, snap: Snapshot, recommended: bool) -> dict:
+    return {
+        "id": acc.id,
+        "provider": acc.provider,
+        "label": acc.label,
+        "home": acc.home,
+        "plan": snap.plan,
+        "source": snap.source,
+        "updated_at": snap.updated_at,
+        "status": snap.status,
+        "message": snap.message,
+        "recommended": recommended,
+        "limits": [asdict(lim) for lim in snap.limits],
+    }

ai_limits/netguard.py

@@ -0,0 +1,147 @@
+"""Fail-closed network access: a credentialed request leaves only through the VPN interface.
+
+Order matters:
+1. the interface must exist, checked before any DNS lookup;
+2. the resolved IP must route via the interface (`ip route get` honours policy routing,
+   e.g. sing-box/xray TUN tables);
+3. an anonymous probe to the same host and IP must get the exact answer an allowed region gets;
+4. only then the real request, to exactly that IP.
+Every socket is also bound to the interface (SO_BINDTODEVICE, unprivileged since Linux 5.7), so if
+the VPN drops between the checks and the request, the kernel refuses to send it elsewhere.
+Environment proxies are ignored and redirects are not followed.
+"""
+
+from __future__ import annotations
+
+import http.client
+import json
+import os
+import socket
+import ssl
+import subprocess
+import sys
+import time
+
+PROBE_ATTEMPTS = 2
+TIMEOUT = 5  # per connection; worst case (route + 2 probes + request) stays under the extension's 30 s
+SUBPROCESS_ENV = {"PATH": "/usr/sbin:/usr/bin:/sbin:/bin", "LC_ALL": "C"}  # no inherited secrets
+
+# Result of the last check in this process: None = no check ran, True/False otherwise.
+last_check: bool | None = None
+
+
+class VpnCheckFailed(Exception):
+    pass
+
+
+def require_supported_platform() -> None:
+    """Do not substitute an unguarded transport on non-Linux platforms."""
+    if sys.platform != "linux" or not hasattr(socket, "SO_BINDTODEVICE"):
+        raise VpnCheckFailed("network mode requires Linux with SO_BINDTODEVICE; use offline mode on this platform")
+
+
+def check_route(host: str, interface: str) -> str:
+    """Return the IPv4 address to use for `host`, or raise VpnCheckFailed."""
+    require_supported_platform()
+    if not interface or not os.path.exists(f"/sys/class/net/{interface}"):
+        raise VpnCheckFailed(f"interface {interface or '?'} is down")
+    try:
+        ip = socket.getaddrinfo(host, 443, socket.AF_INET, socket.SOCK_STREAM)[0][4][0]
+    except (OSError, IndexError) as e:
+        raise VpnCheckFailed(f"cannot resolve {host}: {e}") from e
+    try:
+        out = subprocess.run(["ip", "route", "get", ip], capture_output=True, text=True, timeout=5,
+                             encoding="ascii", errors="replace", check=True, env=SUBPROCESS_ENV).stdout
+    except (OSError, subprocess.SubprocessError) as e:
+        raise VpnCheckFailed(f"cannot check route: {e}") from e
+    tokens = out.split()
+    dev = tokens[tokens.index("dev") + 1] if "dev" in tokens[:-1] else None
+    if dev != interface:
+        raise VpnCheckFailed(f"{host} would go via {dev or '?'}, not {interface}")
+    return ip
+
+
+class _PinnedHTTPSConnection(http.client.HTTPSConnection):
+    """Connects to a fixed IP through a fixed interface, verifying TLS for the real host name."""
+
+    def __init__(self, host: str, ip: str, interface: str, **kw):
+        super().__init__(host, **kw)
+        self._ip = ip
+        self._interface = interface
+
+    def connect(self):
+        require_supported_platform()
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, self._interface.encode())
+            sock.settimeout(self.timeout)
+            sock.connect((self._ip, self.port))
+            self.sock = self._context.wrap_socket(sock, server_hostname=self.host)
+        except OSError:
+            sock.close()
+            raise
+
+
+def _tls_context() -> ssl.SSLContext:
+    ctx = ssl.create_default_context()
+    ctx.keylog_filename = None  # ignore an inherited SSLKEYLOGFILE: it would write session keys to disk
+    return ctx
+
+
+def _get(host: str, ip: str, interface: str, path: str, headers: dict, timeout: float) -> tuple[int, bytes]:
+    conn = _PinnedHTTPSConnection(host, ip, interface, timeout=timeout, context=_tls_context())
+    try:
+        conn.request("GET", path, headers={"Accept": "application/json", **headers})
+        resp = conn.getresponse()
+        return resp.status, resp.read()
+    finally:
+        conn.close()
+
+
+def probe(host: str, ip: str, interface: str, path: str, expect_status: int, expect_error: str,
+          timeout: float = TIMEOUT) -> None:
+    """Anonymous request (no token, no cookies) to the same host and IP the real request will use.
+
+    Being the same domain, it takes the same VPN routing rule. Only the exact answer an allowed
+    region gets for a missing token counts; a region block (403) or anything unexpected raises.
+    """
+    for attempt in range(PROBE_ATTEMPTS):  # anonymous, so retrying a flaky tunnel is harmless
+        try:
+            status, body = _get(host, ip, interface, path, {}, timeout)
+            break
+        except (OSError, http.client.HTTPException) as e:
+            if attempt == PROBE_ATTEMPTS - 1:
+                raise VpnCheckFailed(f"probe to {host} failed: {e}") from e
+            time.sleep(1)
+    try:
+        error_type = json.loads(body)["error"]["type"]
+    except (ValueError, KeyError, TypeError):
+        error_type = None
+    if status != expect_status or error_type != expect_error:
+        raise VpnCheckFailed(f"probe to {host} got HTTP {status} {error_type or ''}".strip())
+
+
+def get_json_authenticated(host: str, path: str, headers: dict, interface: str,
+                           probe_expect: tuple[str, int, str], timeout: float = TIMEOUT) -> dict:
+    """GET https://host/path with credentials in `headers`, only after all checks pass.
+
+    probe_expect = (probe path, status, error type) and is mandatory.
+    Raises VpnCheckFailed (nothing with credentials was sent) or OSError/ValueError.
+    """
+    global last_check
+    if not probe_expect:
+        raise ValueError("an anonymous probe is required before sending credentials")
+    try:
+        ip = check_route(host, interface)
+        probe(host, ip, interface, *probe_expect, timeout=timeout)
+    except VpnCheckFailed:
+        last_check = False
+        raise
+    except Exception as e:  # any surprise during the checks counts as a failed check
+        last_check = False
+        raise VpnCheckFailed(f"check failed: {type(e).__name__}") from e
+    last_check = True
+    status, body = _get(host, ip, interface, path, headers, timeout)
+    if status != 200:
+        raise OSError(f"HTTP {status} from {host}")
+    return json.loads(body)

ai_limits/providers/__init__.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+
+def read_json(path) -> dict | None:
+    try:
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def private_dir(path) -> Path:
+    """Create a cache directory; restrict it to its owner on POSIX.
+
+    Windows uses ACLs, not POSIX mode bits.
+    """
+    path = Path(path)
+    path.mkdir(mode=0o700, parents=True, exist_ok=True)
+    if hasattr(os, "getuid") and path.stat().st_uid == os.getuid():
+        path.chmod(0o700)
+    return path
+
+
+def write_json(path, data: dict) -> None:
+    """Atomic write through an exclusive temp file (0600 on POSIX, inherited ACLs on Windows)."""
+    path = Path(path)
+    fd, tmp = tempfile.mkstemp(dir=private_dir(path.parent), prefix=f".{path.name}.", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, allow_nan=False)
+        os.replace(tmp, path)
+    except BaseException:
+        os.unlink(tmp)
+        raise
+
+
+def get(provider: str):
+    from . import claude, codex
+
+    return {"claude": claude, "codex": codex}[provider]

ai_limits/providers/claude.py

@@ -0,0 +1,209 @@
+"""Claude Code (claude.ai subscription).
+
+Offline source ("tap"): Claude Code passes `rate_limits` to the status line command on stdin;
+`ai-limits tap claude` (or a custom status line) saves it to
+$XDG_CACHE_HOME/ai-limits/taps/claude-<home_key>.json. Nothing is read from the credentials file.
+
+Network source (opt-in): the OAuth usage endpoint used by Claude Code's /usage. Undocumented and
+may change. It also reports per-model weekly limits. The token is only read, never refreshed:
+refreshing it here would race with Claude Code's own refresh.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from dataclasses import asdict
+
+from .. import netguard
+from ..config import Config, cache_dir
+from ..model import AccountConfig, Limit, Snapshot, home_key, percent, to_epoch
+from . import private_dir, read_json, write_json
+
+USAGE_HOST = "api.anthropic.com"
+USAGE_PATH = "/api/oauth/usage"
+# what an allowed region gets without a token; /v1/models because the usage path rate-limits anonymous calls
+PROBE_EXPECT = ("/v1/models", 401, "authentication_error")
+TOKEN_RE = re.compile(r"[A-Za-z0-9._~+/=-]{20,4096}")
+
+
+def tap_path(acc: AccountConfig):
+    return cache_dir() / "taps" / f"claude-{home_key(acc.home)}.json"
+
+
+def write_tap(home: str, status_input: dict, now: int) -> bool:
+    rate_limits = status_input.get("rate_limits")
+    if not rate_limits:
+        return False
+    if not isinstance(rate_limits, dict):
+        return False
+    kept = {key: {"used_percentage": w.get("used_percentage"), "resets_at": w.get("resets_at")}
+            for key, w in rate_limits.items() if key in ("five_hour", "seven_day") and isinstance(w, dict)}
+    write_json(cache_dir() / "taps" / f"claude-{home_key(home)}.json",
+               {"home": home, "captured_at": now, "rate_limits": kept})
+    return True
+
+
+def collect(acc: AccountConfig, cfg: Config, now: int) -> Snapshot:
+    tap = _from_tap(acc)
+    net = _from_network(acc, cfg, now) if cfg.network.active else None
+
+    if tap is None and net is None:
+        return Snapshot(status="no_data", message="no data yet: add `ai-limits tap claude` to your status line")
+    sources = sorted((s for s in (tap, net) if s is not None and s.limits),
+                     key=lambda s: s.updated_at or 0, reverse=True)
+    if not sources:  # network failed and nothing offline
+        return net if net is not None else tap
+    # Merge by limit id, newest source first; an older source only adds limits the newer one lacks
+    # (e.g. per-model weeks). Nothing is dropped (a 99 % week still constrains the account even if old),
+    # but updated_at is the oldest contributing source, so old numbers make the account stale, not fresh.
+    merged = Snapshot(source=sources[0].source, plan=net.plan if net else None)
+    for src in sources:
+        known = {lim.id for lim in merged.limits}
+        extra = [lim for lim in src.limits if lim.id not in known]
+        if extra:
+            merged.limits += extra
+            merged.updated_at = min(filter(None, (merged.updated_at, src.updated_at)), default=None)
+    merged.limits.sort(key=lambda lim: ({"5h": 0, "7d": 1}.get(lim.id, 2), lim.id))
+    if net is not None and net.status != "ok":  # keep the network problem visible next to offline data
+        merged.status, merged.message = net.status, net.message
+    return merged
+
+
+def _from_tap(acc: AccountConfig) -> Snapshot | None:
+    data = read_json(tap_path(acc))
+    if not data:
+        return None
+    rl = data.get("rate_limits") or {}
+    limits = []
+    for key, lid, label, window in (("five_hour", "5h", "Session (5h)", 300), ("seven_day", "7d", "Week", 10080)):
+        w = rl.get(key)
+        used = percent(w.get("used_percentage")) if isinstance(w, dict) else None
+        if used is not None:
+            limits.append(Limit(lid, label, used, to_epoch(w.get("resets_at")), window))
+    return Snapshot(limits=limits, source="tap", updated_at=to_epoch(data.get("captured_at")))
+
+
+def _from_network(acc: AccountConfig, cfg: Config, now: int) -> Snapshot:
+    """Cached network result, refreshed at most every min_interval_seconds (successful or not)."""
+    try:
+        netguard.require_supported_platform()
+    except netguard.VpnCheckFailed as e:
+        netguard.last_check = False
+        snap = _cached_snapshot(read_json(cache_dir() / "net" / f"{acc.id}.json") or {})
+        snap.status, snap.message = "vpn_off", str(e)
+        return snap
+
+    # Network mode is Linux-only. Offline imports and taps must also work without fcntl.
+    import fcntl
+
+    net_dir = private_dir(cache_dir() / "net")
+    cache_file = net_dir / f"{acc.id}.json"
+    with os.fdopen(os.open(net_dir / f"{acc.id}.lock", os.O_WRONLY | os.O_CREAT, 0o600), "w") as lock:
+        try:  # one fetcher per account across processes (extension, status line, terminal)
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            return _cached_snapshot(read_json(cache_file) or {})
+        return _fetch_locked(acc, cfg, now, cache_file)
+
+
+def _cached_snapshot(cache: dict) -> Snapshot:
+    snap = Snapshot(limits=_cached_limits(cache.get("limits")), source="network",
+                    updated_at=to_epoch(cache.get("fetched_at")), plan=cache.get("plan"))
+    snap.status, snap.message = cache.get("status", "ok"), cache.get("message")
+    return snap
+
+
+def _fetch_locked(acc: AccountConfig, cfg: Config, now: int, cache_file) -> Snapshot:
+    cache = read_json(cache_file) or {}
+    snap = _cached_snapshot(cache)
+    if now - (to_epoch(cache.get("attempted_at")) or 0) < cfg.network.min_interval_seconds:
+        return snap
+    # record the attempt before any network activity, so a killed run still counts against the interval
+    cache["attempted_at"] = now
+    write_json(cache_file, cache)
+
+    status, message = "ok", None
+    creds = read_json(f"{acc.home}/.credentials.json") or {}
+    oauth = creds.get("claudeAiOauth") or {}
+    token = oauth.get("accessToken")
+    expires = to_epoch(oauth.get("expiresAt"))
+    if not token:
+        status, message = "error", "not logged in (no OAuth token)"
+    elif not isinstance(token, str) or not TOKEN_RE.fullmatch(token):
+        status, message = "error", "OAuth token has an unexpected format"  # never echo it
+    elif expires and expires <= now:
+        status, message = "stale", "token expired: run `claude` once to refresh it"
+    else:
+        try:
+            usage = netguard.get_json_authenticated(USAGE_HOST, USAGE_PATH, {
+                "Authorization": f"Bearer {token}",
+                "anthropic-beta": "oauth-2025-04-20",
+            }, cfg.network.require_interface, probe_expect=PROBE_EXPECT)
+            snap = _parse_usage(usage, now)
+            snap.plan = oauth.get("subscriptionType")
+            # cache only the parsed limits: no unknown fields, nothing that could break strict JSON
+            cache.update(limits=[asdict(lim) for lim in snap.limits], fetched_at=now, plan=snap.plan)
+        except netguard.VpnCheckFailed as e:
+            status, message = "vpn_off", f"network check failed, request not sent ({e})"
+        except Exception as e:  # anything else after the token was handed over: never let its text through raw
+            status, message = "error", f"usage request failed: {_scrub(e, token)}"
+
+    cache.update(attempted_at=now, status=status, message=message)
+    write_json(cache_file, cache)
+    snap.status, snap.message = status, message
+    return snap
+
+
+def _cached_limits(items) -> list[Limit]:
+    limits = []
+    for item in items if isinstance(items, list) else []:
+        try:
+            lim = Limit(**item)
+        except TypeError:
+            continue
+        if percent(lim.used_percent) is not None:
+            limits.append(lim)
+    return limits
+
+
+def _scrub(error: Exception, token: str) -> str:
+    """Error text safe to store and show: no token, bounded length."""
+    return str(error).replace(token, "<token>")[:200] or type(error).__name__
+
+
+def _parse_usage(usage: dict, fetched_at: int | None) -> Snapshot:
+    limits = []
+    for item in usage.get("limits") or []:
+        if not isinstance(item, dict):
+            continue
+        kind, pct = item.get("kind"), percent(item.get("percent"))
+        if pct is None:
+            continue
+        resets = to_epoch(item.get("resets_at"))
+        if kind == "session":
+            limits.append(Limit("5h", "Session (5h)", pct, resets, 300))
+        elif kind == "weekly_all":
+            limits.append(Limit("7d", "Week", pct, resets, 10080))
+        elif kind == "weekly_scoped":
+            scope = item.get("scope") or {}
+            name = (scope.get("model") or {}).get("display_name") or scope.get("surface") or "scoped"
+            limits.append(Limit(f"7d:{name.lower()}", f"{name} (week)", pct, resets, 10080))
+    if not limits:  # older response shape
+        for key, lid, label, window in (("five_hour", "5h", "Session (5h)", 300), ("seven_day", "7d", "Week", 10080)):
+            w = usage.get(key)
+            used = percent(w.get("utilization")) if isinstance(w, dict) else None
+            if used is not None:
+                limits.append(Limit(lid, label, used, to_epoch(w.get("resets_at")), window))
+    return Snapshot(limits=limits, source="network", updated_at=fetched_at)
+
+
+def tap_from_stdin(home: str, raw: str) -> None:
+    try:
+        data = json.loads(raw)
+    except ValueError:
+        return
+    if isinstance(data, dict):
+        write_tap(home, data, int(time.time()))

ai_limits/providers/codex.py

@@ -0,0 +1,122 @@
+"""OpenAI Codex CLI (ChatGPT subscription).
+
+Offline source ("sessions"): Codex writes the server's rate-limit snapshot into its session logs
+(<home>/sessions/YYYY/MM/DD/rollout-*.jsonl, `event_msg` / `token_count` records). We read the
+tail of the most recently modified logs and take the newest snapshot per limit_id.
+No network source yet.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+from ..config import Config
+from ..model import AccountConfig, Limit, Snapshot, percent, to_epoch
+
+SCAN_FILES = 8  # most recently modified logs to look at
+TAIL_BYTES = 512 * 1024
+
+
+def collect(acc: AccountConfig, cfg: Config, now: int) -> Snapshot:
+    logs = _recent_logs(Path(acc.home))
+    if not logs:
+        return Snapshot(status="no_data", message="no Codex sessions yet")
+
+    latest: dict[str, tuple[float, dict]] = {}  # limit_id -> (epoch with sub-seconds, rate_limits)
+    for path in logs:
+        for ts, rl in _snapshots(path):
+            lid = rl.get("limit_id") or "codex"
+            if lid not in latest or ts > latest[lid][0]:
+                latest[lid] = (ts, rl)
+    if not latest:
+        return Snapshot(status="no_data", message="no rate-limit data in recent Codex sessions")
+
+    # updated_at is the OLDEST snapshot used: nothing is dropped (an old 99 % still constrains the
+    # account), but old numbers then make the whole account stale instead of passing as fresh
+    snap = Snapshot(source="sessions", updated_at=int(min(ts for ts, _ in latest.values())))
+    for lid, (ts, rl) in sorted(latest.items(), key=lambda kv: (kv[0] != "codex", kv[0])):
+        snap.plan = snap.plan or rl.get("plan_type")
+        for key in ("primary", "secondary"):
+            w = rl.get(key)
+            if isinstance(w, dict) and percent(w.get("used_percent")) is not None:
+                snap.limits.append(_limit(lid, rl.get("limit_name"), w))
+    return snap
+
+
+def _limit(limit_id: str, limit_name: str | None, w: dict) -> Limit:
+    minutes = w.get("window_minutes")
+    minutes = minutes if isinstance(minutes, int) and not isinstance(minutes, bool) and minutes > 0 else None
+    base, label = {300: ("5h", "Session (5h)"), 10080: ("7d", "Week")}.get(
+        minutes, (f"{minutes}m" if minutes else "?", _window_label(minutes)))
+    if limit_id != "codex":
+        name = limit_name or limit_id
+        base, label = f"{base}:{limit_id}", f"{name} ({label.lower()})"
+    return Limit(base, label, percent(w["used_percent"]), to_epoch(w.get("resets_at")), minutes)
+
+
+def _window_label(minutes: int | None) -> str:
+    if not minutes:
+        return "Limit"
+    if minutes % 1440 == 0:
+        return f"{minutes // 1440}d"
+    if minutes % 60 == 0:
+        return f"{minutes // 60}h"
+    return f"{minutes}m"
+
+
+def _recent_logs(home: Path) -> list[Path]:
+    found = []
+    for sub in ("sessions", "archived_sessions"):
+        root = home / sub
+        if not root.is_dir():
+            continue
+        for dirpath, _dirs, files in os.walk(root):
+            for name in files:
+                if name.startswith("rollout-") and name.endswith(".jsonl"):
+                    p = Path(dirpath, name)
+                    try:
+                        found.append((p.stat().st_mtime, p))
+                    except OSError:
+                        pass
+    found.sort(reverse=True)
+    return [p for _, p in found[:SCAN_FILES]]
+
+
+def _parse_ts(value) -> float | None:
+    """ISO-8601 with any precision/offset -> epoch float (string comparison gets these wrong)."""
+    try:
+        when = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+        if when.tzinfo is None:
+            when = when.replace(tzinfo=timezone.utc)
+        return when.timestamp()
+    except (ValueError, OverflowError, OSError):
+        return None
+
+
+def _snapshots(path: Path):
+    """(epoch, rate_limits) for each record in the file's tail."""
+    try:
+        with open(path, "rb") as f:
+            size = f.seek(0, os.SEEK_END)
+            f.seek(max(0, size - TAIL_BYTES))
+            chunk = f.read()
+    except OSError:
+        return
+    lines = chunk.split(b"\n")
+    if size > TAIL_BYTES:
+        lines = lines[1:]  # first line is probably cut
+    for line in lines:
+        if b'"rate_limits"' not in line:
+            continue
+        try:
+            rec = json.loads(line)
+        except ValueError:
+            continue
+        payload = rec.get("payload") if isinstance(rec, dict) else None
+        rl = payload.get("rate_limits") if isinstance(payload, dict) else None
+        ts = _parse_ts(rec.get("timestamp")) if isinstance(rl, dict) else None
+        if ts is not None:
+            yield ts, rl

ai_limits-0.1.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: ai-limits
+Version: 0.1.0
+Summary: AI subscription usage limits (Claude, Codex) for your desktop panel. Offline by default.
+Author: jointsome0-lgtm
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jointsome0-lgtm/ai-limits
+Project-URL: Repository, https://github.com/jointsome0-lgtm/ai-limits
+Project-URL: Issues, https://github.com/jointsome0-lgtm/ai-limits/issues
+Project-URL: Documentation, https://github.com/jointsome0-lgtm/ai-limits#readme
+Keywords: claude,codex,usage,limits,gnome,offline,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ai-limits
+
+See how much of your AI subscriptions is left — Claude and Codex, any number of accounts — right
+in the GNOME top bar.
+
+```
+                                   ✳ 42%   ◎ 19%   Oct 27 15:49
+```
+
+```
+ Claude Max
+   Session (5h)   ████░░░░░░  42%   ↻ 18:30 (in 2h10m)
+   Week           ██░░░░░░░░  18%   ↻ Sun 19:00 (in 5d3h)
+ Codex · personal                         ★ most headroom
+   Week           ██░░░░░░░░  19%   ↻ Thu 12:00 (in 2d21h)
+ Codex · work                             updated 8h ago
+   Week           █████████░  91%   ↻ 18:00 (in 2h)
+```
+
+**Offline by default.** ai-limits reads only what Claude Code and Codex already saved on your
+machine. It sends no requests and does not read your tokens unless you turn on network mode, and
+network mode refuses to send anything unless the route goes through the VPN interface you name.
+
+> Unofficial. Not affiliated with Anthropic or OpenAI. The local formats and the usage endpoint it
+> reads are undocumented and may change.
+
+## Install
+
+```sh
+uv tool install ai-limits        # or: pipx install ai-limits
+ai-limits                       # check it sees your accounts
+```
+
+For the optional GNOME Shell 45–49 extension, install from a checkout (it is not in the wheel):
+
+```sh
+git clone https://github.com/jointsome0-lgtm/ai-limits.git
+cd ai-limits
+./gnome-extension/install.sh
+```
+
+### Platforms
+
+Python **3.11–3.14**, with no runtime dependencies. On distributions with an older system Python
+(e.g. Ubuntu 22.04 ships 3.10), use `uv tool install ai-limits`: uv fetches a suitable Python itself.
+**Linux** supports the offline CLI,
+Claude tap, and VPN-guarded network mode (`ip` from iproute2 is required for network mode).
+**macOS and Windows** support the offline CLI and Claude tap; network mode refuses to run
+there, before reading credentials or looking up the host. The GNOME extension is Linux-only.
+
+Config and cache use `~/.config/ai-limits` and `~/.cache/ai-limits` on all platforms, unless
+`XDG_CONFIG_HOME` / `XDG_CACHE_HOME` override them. On Windows, `~` is the user profile directory
+and cache privacy relies on Windows ACLs; on POSIX, directories/files use 0700/0600.
+Files and CLI streams use UTF-8. Reset times display in the local timezone; timestamps without
+an explicit timezone are interpreted as UTC.
+
+## Where the numbers come from
+
+| Provider | Offline source | Network source (opt-in) |
+|---|---|---|
+| Codex | rate-limit snapshots in `~/.codex/sessions/**/rollout-*.jsonl`, updated whenever you use Codex | — |
+| Claude | `rate_limits` Claude Code passes to its status line; saved by `ai-limits tap claude` | `api.anthropic.com/api/oauth/usage` (adds per-model weekly limits) |
+
+When a window's reset time has passed, the limit is shown as `~0%` until fresh data arrives.
+
+### Claude: add the tap to your status line
+
+In `~/.claude/settings.json`:
+
+```jsonc
+"statusLine": { "type": "command", "command": "ai-limits tap claude --print" }
+// already have a status line? pass stdin through to it:
+"statusLine": { "type": "command", "command": "ai-limits tap claude | bash ~/.claude/statusline.sh" }
+```
+
+## Several accounts
+
+Both CLIs keep each login in its own directory (`CLAUDE_CONFIG_DIR=…`, `CODEX_HOME=…`). List them in
+`~/.config/ai-limits/config.toml`:
+
+```toml
+[[account]]
+provider = "claude"
+label    = "Claude Max"
+home     = "~/.claude"
+
+[[account]]
+provider = "codex"
+label    = "Codex · personal"
+home     = "~/.codex"
+
+[[account]]
+provider = "codex"
+label    = "Codex · work"
+home     = "~/.codex-work"
+```
+
+Without a config file, `~/.claude` and `~/.codex` are picked up automatically. With two or more
+accounts of one provider, the one with the most headroom gets a ★ and is the one shown in the panel.
+
+## Network mode (Linux only, behind a VPN)
+
+```toml
+[network]
+enabled = true
+require_interface = "tun0"     # mandatory: no interface, no network
+min_interval_seconds = 300
+```
+
+Before every request ai-limits:
+
+1. checks the interface exists — if not, it stops before even a DNS lookup;
+2. resolves the host and asks the kernel which interface the packet would leave by
+   (`ip route get`, which honours policy routing as used by sing-box / xray / WireGuard);
+3. sends an anonymous probe (no token, no cookies) to the same host and IP, e.g.
+   `api.anthropic.com/v1/models`. Being the same domain, it takes the same routing rule in your VPN
+   client, so a `direct` rule or a dead tunnel shows up here. Only the exact answer an allowed
+   region gets for a missing token (`401 authentication_error`) passes; a region block (403), a
+   timeout or anything unexpected stops here;
+4. only then sends the real request, to exactly that IP, ignoring proxy environment variables.
+
+Every socket is also bound to the interface (`SO_BINDTODEVICE`), so if the VPN drops between the
+checks and the request, the kernel refuses to send it another way. Any failure means no request
+with your token, and the panel shows `⏸` next to the last known numbers. Tokens are only read,
+never refreshed, never put on a command line, and never written anywhere.
+
+**What this cannot see:** what your VPN client does *inside* the tunnel. If its rules send
+`anthropic.com` to a `direct` outbound (or fall back to direct when the proxy is down), traffic
+enters `tun0` and still leaves from your real IP. The probe catches a region block, but the only
+real guarantee is in your VPN config: route these domains to the proxy with no direct fallback,
+or block them when the proxy is down (a kill switch).
+
+## CLI
+
+```
+ai-limits               summary
+ai-limits --version     installed version
+ai-limits json          state for UIs (docs/state-schema.md), also written to ~/.cache/ai-limits/state.json
+ai-limits accounts      configured / detected accounts
+ai-limits tap claude    status line helper (see above)
+```
+
+## Development
+
+```sh
+python3 -m unittest discover tests
+python3 -m ai_limits json
+```
+
+Releases go to PyPI through Trusted Publishing: run the **Build or publish to PyPI** workflow
+(`publish.yml`) on `main` with mode `publish`; `build-only` just builds and checks the packages.
+The PyPI publisher is owner `jointsome0-lgtm`, repository `ai-limits`, workflow `publish.yml`,
+environment `pypi`. No API token is needed.
+
+The GNOME extension only runs `ai-limits json` and draws the result; adding a provider means one
+module in `ai_limits/providers/`.
+
+## License
+
+MIT

ai_limits-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+ai_limits/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+ai_limits/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+ai_limits/cli.py,sha256=k9ajxC7qaa4aJ4t1H5ZFQvEQAEeGcg4Q3cbjczmkzYs,5083
+ai_limits/config.py,sha256=5oWABCyRSyExr92wJk_0vdynMQEvqPiZaoW9TdMR9es,4581
+ai_limits/core.py,sha256=RF5cNlTGvqJX_LAhSnSTYgTlIckl_NlkHwqqohHEzII,2491
+ai_limits/model.py,sha256=naZzLHwWd2T-h0xNpjO8yGOiwwdj036NEuPsLR6Woww,3332
+ai_limits/netguard.py,sha256=52SW9Ovi-AS6WGMoEjeNsP3GrYBRAUcQapdH_qkHdRg,6276
+ai_limits/providers/__init__.py,sha256=ae-whWUowVcPIkvm1DA7n95oGbVmwlogFlAG_L5p0Pg,1246
+ai_limits/providers/claude.py,sha256=Z40ohB3JGdm7jfJhS7w4mFTvkPyrpE47vxIwhuT7yKs,9509
+ai_limits/providers/codex.py,sha256=b_f-xA7m62fB7zXttNJ4Oe2V7rCQ3wDHvk4czkJZFLk,4697
+ai_limits-0.1.0.dist-info/licenses/LICENSE,sha256=rCi3alSyCyp3n9jRc9pKT7mPjPB71Y9puovy89THm9Q,1062
+ai_limits-0.1.0.dist-info/METADATA,sha256=3lXqUHJt0JWgmJysmQHcvaDecya1rYqwLXmpQFti3ew,7740
+ai_limits-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+ai_limits-0.1.0.dist-info/entry_points.txt,sha256=Kzn3clAtOQ69F0h8qJ9U6PC9GgJP9Cqu_6Ofg1xagDc,49
+ai_limits-0.1.0.dist-info/top_level.txt,sha256=0furvkvRk_rb5gJHSywsdWlJ1vYEWC01jNa03TYw5Uw,10
+ai_limits-0.1.0.dist-info/RECORD,,

ai_limits-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ai_limits-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ai-limits = ai_limits.cli:main

ai_limits-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agniv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ai_limits-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ai_limits