clanker-usage 0.4.2__tar.gz → 0.4.4__tar.gz

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: clanker-usage
-Version: 0.4.2
+Version: 0.4.4
 Summary: Plan and quota of coding-agent accounts, with a statusline, a cache daemon and a check for provider changes
 Project-URL: Homepage, https://github.com/wakamex/clanker-usage
 Project-URL: Source, https://github.com/wakamex/clanker-usage
@@ -16,7 +16,7 @@ Description-Content-Type: text/markdown
 
 Monitor the plan and quota of your coding-agent accounts from the terminal: current usage, a one-line statusline, a daemon that keeps a cache fresh, and a check that fails loudly when a provider changes its API. Every provider has the same commands and the same JSON document.
 
-Providers: Antigravity (`agy-usage`), Claude Code (`ccusage`), Codex (`codex-cli-usage`), Cursor (`cursor-cli-usage`), DeepSeek (`deepseek-harness-usage`), Devin (`devin-cli-usage`), Gemini CLI (`gemini-cli-usage`), OpenCode Go (`opencode-cli-usage`) and Z.ai's Coding Plan (`zcode-cli-usage`). Each package name and command is a former standalone tool, now one interface over one codebase.
+Providers: Antigravity (`agy-usage`), Claude Code (`ccusage`), Codex (`codex-cli-usage`), Cursor (`cursor-cli-usage`), DeepSeek (`deepseek-harness-usage`), Devin (`devin-cli-usage`), Gemini CLI (`gemini-cli-usage`), Muse Code (`muse-code-usage`), OpenCode Go (`opencode-cli-usage`) and Z.ai's Coding Plan (`zcode-cli-usage`). Each package name and command is a former standalone tool, now one interface over one codebase.
 
 clanker-usage reports what the provider says about the account: plan, quota windows and balance. Token use and cost from local session logs are the job of [clanker-analytics](https://github.com/wakamex/clanker-analytics).
 
@@ -158,12 +158,18 @@ Sign in with the Devin CLI. The tool reads its local API key and server from `~/
 
 Usage comes from the server's `SeatManagementService/GetUserStatus`. The `daily` and `weekly` windows come from the remaining quota it reports; `details.credits` keeps the prompt, flow and flex credits and the overage balance. The tool keeps only the plan and quota parts of the response, leaving out the account's name, email and model lists.
 
+Devin's free models also have a rate limit that this API does not report. When a request hits it, Devin writes the error, with the time the limit resets, to its CLI log, so the tool reads the logs from the last seven days in `~/.local/share/devin/cli/logs`. `details.free_model_limits` lists, per model, the last hit, its reset and whether the limit still applied when the document was made, and `details.free_model_limit_hits` keeps the last 50 hits. `status` and `statusline` show a limit that still applies. The model is known only when the log names it, as Devin's interactive mode does; logs from its ACP server do not, so those hits have a null `model`. To read the logs of other Devin homes, such as ones another tool creates for each run, add a glob once: `devin-cli-usage configure --log-glob '~/work/*/devin/cli/logs'`.
+
 ## Gemini CLI
 
 Quota exists only for a Google login, and since 2026-06-18 Google allows that only for [Gemini Code Assist](https://developers.google.com/gemini-code-assist/docs/deprecations/code-assist-individuals) Standard and Enterprise subscriptions. Individual, Google AI Pro and Ultra accounts can no longer sign Gemini CLI in with Google; their quota is Antigravity's, which `agy-usage` reports. A Gemini API key has no quota to read. The tool chooses the login as Gemini CLI does: the `GOOGLE_GENAI_USE_GCA`, `GOOGLE_GENAI_USE_VERTEXAI`, `GEMINI_API_KEY` and Cloud Shell variables, then `.gemini/settings.json` in the current directory, then `~/.gemini/settings.json` (under `$GEMINI_CLI_HOME` when set). With any other login the document is `unavailable` and `check` reports `expected-unavailable`, which does not fail it. With a Google login it reads `~/.gemini/oauth_creds.json` and renews an expired token the same way as for Antigravity, using the OAuth client in the credentials file or in the installed Gemini CLI.
 
 Quota comes from Code Assist `retrieveUserQuota`, with one window per model, scoped to that model. `GOOGLE_CLOUD_PROJECT` selects the Code Assist project for accounts that need one, as in Gemini CLI.
 
+## Muse Code
+
+Sign in with Muse Code (`/login`). The tool reads Muse's Meta login from `~/.config/muse/auth.json` (under `$XDG_CONFIG_HOME` when set) and never changes it. Muse reports its usage only when it signs in and at the end of each model call, so the tool makes the sign-in's key request, `POST https://api.meta.ai/muse-code/key`, which uses no quota and, as checked with Muse 1.4.12, returns the key Muse already stored. The windows are the 5-hour window and the weekly limit, and the plan is the subscription tier, such as Muse Code Power Usage. The account id is a fingerprint of the account's email.
+
 ## OpenCode Go
 
 Connect OpenCode Go in OpenCode with `/connect`. The tool reads the Go key OpenCode stores in `~/.local/share/opencode/auth.json` (under `$XDG_DATA_HOME` when set) and never changes the file. The account id is a fingerprint of the key.

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/README.md

@@ -2,7 +2,7 @@
 
 Monitor the plan and quota of your coding-agent accounts from the terminal: current usage, a one-line statusline, a daemon that keeps a cache fresh, and a check that fails loudly when a provider changes its API. Every provider has the same commands and the same JSON document.
 
-Providers: Antigravity (`agy-usage`), Claude Code (`ccusage`), Codex (`codex-cli-usage`), Cursor (`cursor-cli-usage`), DeepSeek (`deepseek-harness-usage`), Devin (`devin-cli-usage`), Gemini CLI (`gemini-cli-usage`), OpenCode Go (`opencode-cli-usage`) and Z.ai's Coding Plan (`zcode-cli-usage`). Each package name and command is a former standalone tool, now one interface over one codebase.
+Providers: Antigravity (`agy-usage`), Claude Code (`ccusage`), Codex (`codex-cli-usage`), Cursor (`cursor-cli-usage`), DeepSeek (`deepseek-harness-usage`), Devin (`devin-cli-usage`), Gemini CLI (`gemini-cli-usage`), Muse Code (`muse-code-usage`), OpenCode Go (`opencode-cli-usage`) and Z.ai's Coding Plan (`zcode-cli-usage`). Each package name and command is a former standalone tool, now one interface over one codebase.
 
 clanker-usage reports what the provider says about the account: plan, quota windows and balance. Token use and cost from local session logs are the job of [clanker-analytics](https://github.com/wakamex/clanker-analytics).
 
@@ -144,12 +144,18 @@ Sign in with the Devin CLI. The tool reads its local API key and server from `~/
 
 Usage comes from the server's `SeatManagementService/GetUserStatus`. The `daily` and `weekly` windows come from the remaining quota it reports; `details.credits` keeps the prompt, flow and flex credits and the overage balance. The tool keeps only the plan and quota parts of the response, leaving out the account's name, email and model lists.
 
+Devin's free models also have a rate limit that this API does not report. When a request hits it, Devin writes the error, with the time the limit resets, to its CLI log, so the tool reads the logs from the last seven days in `~/.local/share/devin/cli/logs`. `details.free_model_limits` lists, per model, the last hit, its reset and whether the limit still applied when the document was made, and `details.free_model_limit_hits` keeps the last 50 hits. `status` and `statusline` show a limit that still applies. The model is known only when the log names it, as Devin's interactive mode does; logs from its ACP server do not, so those hits have a null `model`. To read the logs of other Devin homes, such as ones another tool creates for each run, add a glob once: `devin-cli-usage configure --log-glob '~/work/*/devin/cli/logs'`.
+
 ## Gemini CLI
 
 Quota exists only for a Google login, and since 2026-06-18 Google allows that only for [Gemini Code Assist](https://developers.google.com/gemini-code-assist/docs/deprecations/code-assist-individuals) Standard and Enterprise subscriptions. Individual, Google AI Pro and Ultra accounts can no longer sign Gemini CLI in with Google; their quota is Antigravity's, which `agy-usage` reports. A Gemini API key has no quota to read. The tool chooses the login as Gemini CLI does: the `GOOGLE_GENAI_USE_GCA`, `GOOGLE_GENAI_USE_VERTEXAI`, `GEMINI_API_KEY` and Cloud Shell variables, then `.gemini/settings.json` in the current directory, then `~/.gemini/settings.json` (under `$GEMINI_CLI_HOME` when set). With any other login the document is `unavailable` and `check` reports `expected-unavailable`, which does not fail it. With a Google login it reads `~/.gemini/oauth_creds.json` and renews an expired token the same way as for Antigravity, using the OAuth client in the credentials file or in the installed Gemini CLI.
 
 Quota comes from Code Assist `retrieveUserQuota`, with one window per model, scoped to that model. `GOOGLE_CLOUD_PROJECT` selects the Code Assist project for accounts that need one, as in Gemini CLI.
 
+## Muse Code
+
+Sign in with Muse Code (`/login`). The tool reads Muse's Meta login from `~/.config/muse/auth.json` (under `$XDG_CONFIG_HOME` when set) and never changes it. Muse reports its usage only when it signs in and at the end of each model call, so the tool makes the sign-in's key request, `POST https://api.meta.ai/muse-code/key`, which uses no quota and, as checked with Muse 1.4.12, returns the key Muse already stored. The windows are the 5-hour window and the weekly limit, and the plan is the subscription tier, such as Muse Code Power Usage. The account id is a fingerprint of the account's email.
+
 ## OpenCode Go
 
 Connect OpenCode Go in OpenCode with `/connect`. The tool reads the Go key OpenCode stores in `~/.local/share/opencode/auth.json` (under `$XDG_DATA_HOME` when set) and never changes the file. The account id is a fingerprint of the key.

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/build_wrappers.py

@@ -52,6 +52,11 @@ WRAPPERS = {
         "description": "Gemini CLI model quota monitor",
         "keywords": ["gemini", "gemini-cli", "google", "usage", "quota", "statusline", "cli"],
     },
+    "muse-code-usage": {
+        "provider": "muse-code", "label": "Muse Code",
+        "description": "Muse Code subscription limit monitor",
+        "keywords": ["muse", "muse-code", "meta", "usage", "quota", "statusline", "cli"],
+    },
     "opencode-cli-usage": {
         "provider": "opencode", "label": "OpenCode Go",
         "description": "OpenCode Go subscription limit monitor",

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "clanker-usage"
-version = "0.4.2"
+version = "0.4.4"
 description = "Plan and quota of coding-agent accounts, with a statusline, a cache daemon and a check for provider changes"
 readme = "README.md"
 keywords = ["usage", "quota", "statusline", "z.ai", "ai-agents", "cli"]

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/src/clanker_usage/cli.py

@@ -146,10 +146,19 @@ def render(provider, record):
             reset = datetime.fromisoformat(window["resets_at"]).astimezone()
             line += f", resets {reset:%Y-%m-%d %H:%M %Z}"
         lines.append(line)
+    lines += [f"  {note}" for note in provider_notes(provider, record)]
     note = status_note(record)
     return "\n".join(lines + ([f"  ({note})"] if note else []))
 
 
+def provider_notes(provider, record):
+    """What a provider adds about the document beyond its windows, such as Devin's free-model rate limits."""
+    try:
+        return provider.notes(record) if hasattr(provider, "notes") else []
+    except (KeyError, TypeError, ValueError):
+        return []
+
+
 def harness_prefix(status):
     """The directory, model and cost from the status JSON a harness pipes to its statusline, as Claude Code does."""
     if not isinstance(status, dict):
@@ -191,6 +200,7 @@ def statusline(provider, record):
         if until:
             part += f" ({until})"
         parts.append(part)
+    parts += provider_notes(provider, record)
     return " · ".join(parts) + (" (stale)" if record["status"] == "stale" else "")
 
 

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/src/clanker_usage/paths.py

@@ -1,6 +1,7 @@
 """Where clanker-usage keeps its cache, check state and configuration."""
 
 import os
+import shutil
 from pathlib import Path
 
 from . import cache
@@ -36,3 +37,18 @@ def set_config(provider, section):
     data = cache.read_json(config_file()) or {}
     data[provider] = section
     cache.write_json(config_file(), data)
+
+
+def executable(name):
+    """A harness's command: on PATH, else where user installers put it.
+
+    A systemd user service runs with a PATH that leaves out ~/.local/bin, where Claude Code, Devin,
+    agy and Gemini CLI install themselves, so PATH alone misses them under a daemon.
+    """
+    if found := shutil.which(name):
+        return Path(found)
+    for folder in (Path.home() / ".local/bin", Path.home() / "bin", Path("/usr/local/bin"), Path("/usr/bin")):
+        candidate = folder / name
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return candidate
+    return None

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/src/clanker_usage/providers/__init__.py

@@ -8,6 +8,6 @@ add_commands(sub) and run_command(args) for its own setup command, and selectors
 when one person can have several accounts on one machine, such as Claude's config directories.
 """
 
-from . import agy, claude, codex, cursor, deepseek, devin, gemini, opencode, zcode
+from . import agy, claude, codex, cursor, deepseek, devin, gemini, muse, opencode, zcode
 
-PROVIDERS = {module.NAME: module for module in (agy, claude, codex, cursor, deepseek, devin, gemini, opencode, zcode)}
+PROVIDERS = {module.NAME: module for module in (agy, claude, codex, cursor, deepseek, devin, gemini, muse, opencode, zcode)}

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/src/clanker_usage/providers/agy.py

@@ -2,13 +2,12 @@
 
 import os
 import re
-import shutil
 import subprocess
 from datetime import datetime, timedelta, timezone
 from functools import cache
 from pathlib import Path
 
-from .. import cache as files, http, oauth
+from .. import cache as files, http, oauth, paths
 from . import google
 
 NAME = "agy"
@@ -29,13 +28,7 @@ def token_file():
 
 
 def agy_binary():
-    found = shutil.which("agy")
-    if found:
-        return Path(found)
-    for candidate in (Path.home() / ".local/bin/agy", Path.home() / "bin/agy", Path("/usr/local/bin/agy"), Path("/usr/bin/agy")):
-        if candidate.is_file() and os.access(candidate, os.X_OK):
-            return candidate
-    return None
+    return paths.executable("agy")
 
 
 @cache

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/src/clanker_usage/providers/codex.py

@@ -6,7 +6,6 @@ import json
 import math
 import os
 import queue
-import shutil
 import subprocess
 import threading
 import time
@@ -14,7 +13,7 @@ from datetime import datetime, timezone
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 
-from .. import cache as files, http
+from .. import cache as files, http, paths
 
 NAME = "codex"
 LABEL = "Codex"
@@ -93,7 +92,7 @@ def _response(messages, request_id, deadline):
 
 def via_app_server():
     """account/rateLimits/read from `codex app-server`, or None when Codex is missing or does not answer."""
-    codex = shutil.which("codex")
+    codex = paths.executable("codex")
     if not codex:
         return None
     deadline = time.monotonic() + APP_SERVER_TIMEOUT

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/src/clanker_usage/providers/devin.py

@@ -1,17 +1,18 @@
 """Devin quota and credits, read with the local API key the Devin CLI already holds."""
 
+import glob
 import hashlib
 import math
 import os
 import re
-import shutil
+import time
 import subprocess
 import tomllib
 import urllib.parse
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
-from .. import http
+from .. import http, paths
 
 NAME = "devin"
 LABEL = "Devin"
@@ -26,6 +27,73 @@ CREDIT_KEYS = ("availablePromptCredits", "usedPromptCredits", "availableFlowCred
                "availableFlexCredits", "usedFlexCredits", "overageBalanceMicros", "acuConsumed", "acuLimit")
 
 
+# Devin's free models have a rate limit that its status API does not report; the only record is the
+# error Devin writes to its CLI log, such as "Reached free model rate limit. ... Your limit will reset
+# in 1 minute (at 09:51 UTC)." It names no model, so a hit's model comes from the log's model line.
+RATE_LIMIT = re.compile(r"^(\S+)\s.*Reached free model rate limit\..*?reset in [^(]*\(at (\d{1,2}):(\d{2}) UTC\)")
+MODEL_LINE = re.compile(r"resolved_model_uid=([A-Za-z0-9_.-]+)|model_uid=([A-Za-z0-9_.-]+)")
+# Logs older than this are not read, so status stays fast on hosts with many Devin homes.
+LOG_MAX_AGE = 7 * 86400
+HISTORY = 50
+
+
+def data_dir():
+    return Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share") / "devin"
+
+
+def log_dirs():
+    """Devin's own log directory and every directory matching a glob added with configure --log-glob."""
+    found = [data_dir() / "cli" / "logs"]
+    for pattern in paths.config(NAME).get("log_globs", []):
+        found += [Path(match) for match in sorted(glob.glob(os.path.expanduser(pattern)))]
+    return list(dict.fromkeys(folder for folder in found if folder.is_dir()))
+
+
+def rate_limit_hits(now=None):
+    """Each free-model rate-limit hit in recent Devin logs: when, the reset it named, and the model when the log gives it.
+
+    Devin retries a failed request and logs the same error several times, so lines in one log that name
+    the same reset count as one hit.
+    """
+    cutoff = (now or time.time()) - LOG_MAX_AGE
+    hits = {}
+    for folder in log_dirs():
+        for log in folder.glob("*.log"):
+            try:
+                if log.stat().st_mtime < cutoff:
+                    continue
+                lines = log.read_text(errors="replace").splitlines()
+            except OSError:
+                continue
+            model = None
+            for line in lines:
+                if (found := MODEL_LINE.search(line)) and "Reached free model rate limit" not in line:
+                    model = found.group(1) or found.group(2)
+                if "Reached free model rate limit" not in line or not (match := RATE_LIMIT.match(line)):
+                    continue
+                try:
+                    at = datetime.fromisoformat(match.group(1).replace("Z", "+00:00")).astimezone(timezone.utc)
+                except ValueError:
+                    continue
+                reset = at.replace(hour=int(match.group(2)), minute=int(match.group(3)), second=0, microsecond=0)
+                if reset < at - timedelta(minutes=1):
+                    reset += timedelta(days=1)  # The reset is after midnight UTC.
+                key = (str(log), reset)
+                if key not in hits:
+                    hits[key] = {"at": at.isoformat(timespec="seconds"), "resets_at": reset.isoformat(), "model": model}
+    return sorted(hits.values(), key=lambda hit: hit["at"])
+
+
+def free_model_limits(hits, now):
+    """Per model, the last hit, its reset and whether the limit still applies at now; a model of None is unnamed."""
+    latest = {}
+    for hit in hits:
+        latest[hit["model"]] = hit
+    return [{"model": model, "last_hit_at": hit["at"], "resets_at": hit["resets_at"],
+             "limited": datetime.fromisoformat(hit["resets_at"]) > now}
+            for model, hit in sorted(latest.items(), key=lambda item: item[1]["at"], reverse=True)]
+
+
 def credentials_file():
     return Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share") / "devin" / "credentials.toml"
 
@@ -53,16 +121,21 @@ def account():
     return hashlib.sha256(credentials()[0].encode()).hexdigest()[:16]
 
 
+# Devin's server answers HTTP 500 when the client version is not a version, so a host without the
+# devin command sends this recent one.
+FALLBACK_VERSION = "3000.11.205"
+
+
 def devin_version():
-    executable = shutil.which("devin")
+    executable = paths.executable("devin")
     if not executable:
-        return "unknown"
+        return FALLBACK_VERSION
     try:
         result = subprocess.run([executable, "version"], capture_output=True, text=True, timeout=5, check=False)
     except (OSError, subprocess.SubprocessError):
-        return "unknown"
+        return FALLBACK_VERSION
     match = re.search(r"\b(\d+(?:\.\d+)+)\b", result.stdout)
-    return match.group(1) if match else "unknown"
+    return match.group(1) if match else FALLBACK_VERSION
 
 
 def fetch():
@@ -79,6 +152,7 @@ def fetch():
     return {
         "planInfo": {key: info[key] for key in PLAN_KEYS if key in info} if isinstance(info, dict) else {},
         "planStatus": {key: value for key, value in plan_status.items() if key != "planInfo"},
+        "rateLimitHits": rate_limit_hits()[-HISTORY:],
     }
 
 
@@ -116,4 +190,36 @@ def normalize(payload):
     plan = info.get("planName")
     details = {"credits": credits, "plan_period": {"start": status.get("planStart"), "end": status.get("planEnd")}}
     details.update({key: info[key] for key in PLAN_KEYS[1:] if key in info})
+    hits = payload.get("rateLimitHits") or []
+    if not isinstance(hits, list) or not all(isinstance(hit, dict) and isinstance(hit.get("resets_at"), str) for hit in hits):
+        raise ValueError("Devin rate-limit hits are malformed")
+    details["free_model_limits"] = free_model_limits(hits, datetime.now(timezone.utc))
+    details["free_model_limit_hits"] = hits
     return {"plan": plan if isinstance(plan, str) and plan else None, "windows": windows, "details": details}
+
+
+def notes(record):
+    """Free models whose rate limit applies now, for status and statusline."""
+    now = datetime.now(timezone.utc)
+    out = []
+    for limit in (record.get("details") or {}).get("free_model_limits") or []:
+        reset = datetime.fromisoformat(limit["resets_at"])
+        if reset > now:
+            out.append(f"{limit['model'] or 'free model'} rate-limited until {reset.astimezone():%H:%M}")
+    return out
+
+
+def add_commands(sub):
+    configure = sub.add_parser("configure", help="Also read Devin logs from directories matching a glob")
+    configure.add_argument("--log-glob", required=True,
+                           help="such as the logs of Devin homes another tool creates, ~/work/*/devin/cli/logs")
+
+
+def run_command(args):
+    if args.command != "configure":
+        return False
+    section = paths.config(NAME)
+    section["log_globs"] = list(dict.fromkeys([*section.get("log_globs", []), args.log_glob]))
+    paths.set_config(NAME, section)
+    print(f"Configured {paths.config_file()}; {len(log_dirs())} Devin log directories match")
+    return True

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/src/clanker_usage/providers/gemini.py

@@ -8,12 +8,11 @@ key has no quota to read.
 import json
 import os
 import re
-import shutil
 import sys
 import time
 from pathlib import Path
 
-from .. import cache as files, http, oauth
+from .. import cache as files, http, oauth, paths
 from ..errors import ExpectedUnavailable
 from . import google
 
@@ -84,7 +83,7 @@ def _oauth2_sources():
     relative = [Path("node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js"),
                 Path("node_modules/@google/gemini-cli/node_modules/@google/gemini-cli-core/dist/src/code_assist/oauth2.js")]
     roots = []
-    if binary := shutil.which("gemini"):
+    if binary := paths.executable("gemini"):
         resolved = Path(binary).resolve()
         if resolved.parent.name == "bundle":
             yield from sorted(resolved.parent.glob("*.js"))

clanker_usage-0.4.4/src/clanker_usage/providers/muse.py

@@ -0,0 +1,93 @@
+"""Muse Code subscription limits, read with the login Muse Code already holds.
+
+Muse reports its usage in only two places: the key call it makes at /login, and an event at the end
+of every model call. This provider makes the key call, which uses no quota. Checked on 2026-10-25
+with Muse 1.4.12: the call returns the API key already stored, and leaves Muse's login working.
+"""
+
+import hashlib
+import math
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .. import cache as files, http
+
+NAME = "muse-code"
+LABEL = "Muse Code"
+PACKAGE = "muse-code-usage"
+DESCRIPTION = "Read Muse Code subscription limits with the login Muse Code already holds."
+KEY_URL = "https://api.meta.ai/muse-code/key"
+INTERVAL = 300
+KEEP = frozenset({"is_subs_active", "is_subs_upgrade_available", "subs_tier_name", "window_duration_mins"})
+
+
+def auth_file():
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "muse" / "auth.json"
+
+
+def login():
+    """Muse's Meta login, read without changing Muse's file."""
+    meta = ((files.read_json(auth_file()) or {}).get("providers") or {}).get("meta")
+    if not isinstance(meta, dict) or not meta.get("access_token") or not meta.get("api_key"):
+        raise RuntimeError(f"Muse Code is not signed in: no Meta login in {auth_file()}; run muse and /login")
+    return meta
+
+
+def account():
+    """A one-way fingerprint of the account's email, else of its API key."""
+    meta = login()
+    email = meta.get("user_email")
+    source = "email:" + email.strip().lower() if isinstance(email, str) and email.strip() else meta["api_key"]
+    return hashlib.sha256(source.encode()).hexdigest()[:16]
+
+
+def fetch():
+    """The subscription part of the key response; the key itself, names and payment details are left out."""
+    response = http.request_json(KEY_URL, {"Authorization": "Bearer " + login()["access_token"], "x-api-version": "1.0.0"},
+                                 {"onboard": False})
+    if not isinstance(response, dict):
+        raise ValueError("Muse Code key response is not an object")
+    return {key: response[key] for key in ("is_subs_active", "subs_tier_name", "is_subs_upgrade_available", "subs_usage")
+            if key in response}
+
+
+def percent(value):
+    if isinstance(value, bool) or not isinstance(value, int | float) or not math.isfinite(value) or not 0 <= value <= 100:
+        raise ValueError("Invalid Muse Code usage: used_percent must be between 0 and 100")
+    return value
+
+
+def reset(value):
+    if value is None:
+        return None
+    if isinstance(value, bool) or not isinstance(value, int | float) or not math.isfinite(value) or value < 0:
+        raise ValueError("Invalid Muse Code usage: resets_at must be a Unix time")
+    return datetime.fromtimestamp(value, timezone.utc).isoformat()
+
+
+def normalize(payload):
+    """The short window and the weekly limit; an account without a subscription has no plan."""
+    if not payload.get("is_subs_active"):
+        return {"plan": None, "windows": [], "details": {}}
+    usage = payload.get("subs_usage")
+    if not isinstance(usage, dict):
+        raise ValueError("Muse Code key response has no subscription usage")
+    windows = []
+    window = usage.get("window")
+    if isinstance(window, dict):
+        minutes = window.get("window_duration_mins")
+        if isinstance(minutes, bool) or not isinstance(minutes, int) or minutes <= 0:
+            raise ValueError("Invalid Muse Code usage: window_duration_mins must be a positive whole number")
+        name = f"{minutes // 60}-hour" if minutes % 60 == 0 else f"{minutes}-minute"
+        windows.append({"name": name, "seconds": minutes * 60, "scope": None,
+                        "used_pct": percent(window.get("used_percent")), "resets_at": reset(window.get("resets_at"))})
+    weekly = usage.get("weekly")
+    if isinstance(weekly, dict):
+        windows.append({"name": "weekly", "seconds": 7 * 86400, "scope": None,
+                        "used_pct": percent(weekly.get("used_percent")), "resets_at": reset(weekly.get("resets_at"))})
+    if not windows:
+        raise ValueError("Muse Code key response has no usage windows")
+    plan = payload.get("subs_tier_name")
+    return {"plan": plan if isinstance(plan, str) and plan else None, "windows": windows,
+            "details": {"upgrade_available": bool(payload.get("is_subs_upgrade_available"))}}

clanker_usage-0.4.4/src/clanker_usage/shapes/devin/devin-2026-10-24-rate-limits.json

@@ -0,0 +1,29 @@
+{
+  "planInfo": {
+    "planName": "synthetic",
+    "billingStrategy": "BILLING_STRATEGY_QUOTA",
+    "monthlyPromptCredits": 1
+  },
+  "planStatus": {
+    "planStart": "2001-01-01T00:00:00Z",
+    "planEnd": "2001-01-01T00:00:00Z",
+    "availablePromptCredits": 1,
+    "dailyQuotaRemainingPercent": 1,
+    "weeklyQuotaRemainingPercent": 1,
+    "overageBalanceMicros": "-100000",
+    "dailyQuotaResetAtUnix": "1000000000",
+    "weeklyQuotaResetAtUnix": "1000000000"
+  },
+  "rateLimitHits": [
+    {
+      "at": "2001-01-01T00:00:00+00:00",
+      "resets_at": "2001-01-01T00:00:00+00:00",
+      "model": null
+    },
+    {
+      "at": "2001-01-01T00:00:00+00:00",
+      "resets_at": "2001-01-01T00:00:00+00:00",
+      "model": "synthetic"
+    }
+  ]
+}

clanker_usage-0.4.4/src/clanker_usage/shapes/muse-code/muse-2026-10-25.json

@@ -0,0 +1,17 @@
+{
+  "is_subs_active": true,
+  "subs_tier_name": "Muse Code Power Usage",
+  "is_subs_upgrade_available": true,
+  "subs_usage": {
+    "window": {
+      "used_percent": 1,
+      "window_duration_mins": 300,
+      "resets_at": 1
+    },
+    "weekly": {
+      "used_percent": 1,
+      "resets_at": 1
+    },
+    "tier": "10000000000000000"
+  }
+}

clanker_usage-0.4.4/src/clanker_usage/shapes/opencode/opencode-2026-10-24-idle-5h.json

@@ -0,0 +1,30 @@
+{
+  "product": "go",
+  "renewalProduct": "go",
+  "resumability": "renewing",
+  "cancelAtPeriodEnd": false,
+  "access": {
+    "startsAt": "2001-01-01T00:00:00Z",
+    "endsAt": "2001-01-01T00:00:00Z",
+    "cancelAtPeriodEnd": false,
+    "meters": {
+      "fiveHour": {
+        "startsAt": null,
+        "resetsAt": null,
+        "limitMicroCents": "1000000000",
+        "usedMicroCents": "1"
+      },
+      "week": {
+        "startsAt": "2001-01-01T00:00:00Z",
+        "resetsAt": "2001-01-01T00:00:00Z",
+        "limitMicroCents": "1000000000",
+        "usedMicroCents": "100000000"
+      },
+      "month": {
+        "resetsAt": "2001-01-01T00:00:00Z",
+        "limitMicroCents": "1000000000",
+        "usedMicroCents": "100000000"
+      }
+    }
+  }
+}

{clanker_usage-0.4.2 → clanker_usage-0.4.4}/tests/test_zcode.py

@@ -170,7 +170,7 @@ class StandardCommandTests(Home):
             self.assertEqual(cli.main(["--json"]), 0)
         statuses = {record["provider"]: record["status"] for record in json.loads(out.getvalue())}
         self.assertEqual(statuses, {"agy": "unavailable", "claude": "unavailable", "codex": "unavailable", "cursor": "unavailable", "deepseek": "unavailable",
-                                    "devin": "unavailable", "gemini": "unavailable", "opencode": "unavailable",
+                                    "devin": "unavailable", "gemini": "unavailable", "muse-code": "unavailable", "opencode": "unavailable",
                                     "zcode": "cached"})
 
     def test_refresh_fails_without_a_key(self):