cwarm 0.1.0__py3-none-any.whl

cwarm/__init__.py

@@ -0,0 +1,3 @@
+"""cwarm: stagger-warm coding-agent accounts (Claude Code today, Codex next)."""
+
+__version__ = "0.1.0"

cwarm/agent.py

@@ -0,0 +1,56 @@
+"""What makes one coding agent different from another — as plain data.
+
+Sending a warmup is uniform across agents: a single non-interactive prompt
+(`<cli> -p "Hi"`). The only agent-specific part is the **account switcher** that
+decides which credentials are active. So agents are rows in a table, not classes:
+
+    name      command            switcher
+    claude    ("claude", "-p")   "cswap"     # claude-swap manages the accounts
+
+Add a coding agent by adding a row. Only a *new* switcher (something other than
+cswap) needs code — a sibling module to cswap.py, registered in `_SWITCHERS`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import ModuleType
+
+from . import cswap
+
+DEFAULT_AGENT = "claude"
+
+
+@dataclass(frozen=True)
+class Agent:
+    name: str
+    command: tuple[str, ...]  # warmup invocation; the message is appended
+    switcher: str | None  # account-switcher backend, or None for no switching
+
+
+_AGENTS: dict[str, Agent] = {
+    "claude": Agent("claude", ("claude", "-p"), switcher="cswap"),
+    # To add Codex once its non-interactive invocation is confirmed:
+    #   "codex": Agent("codex", ("codex", "exec"), switcher=None),
+    # switcher=None warms whichever account that CLI has active (no multi-account
+    # switching). If Codex can swap accounts, add a cswap-style module and name it.
+}
+
+# Switcher backends, keyed by the name used in Agent.switcher.
+_SWITCHERS: dict[str, ModuleType] = {"cswap": cswap}
+
+
+def known_agents() -> list[str]:
+    return list(_AGENTS)
+
+
+def get_agent(name: str) -> Agent:
+    try:
+        return _AGENTS[name]
+    except KeyError:
+        raise ValueError(f"unknown agent {name!r}; known agents: {', '.join(_AGENTS)}") from None
+
+
+def get_switcher(name: str | None) -> ModuleType | None:
+    """The switcher module for an agent, or None when the agent does no switching."""
+    return _SWITCHERS.get(name) if name else None

cwarm/cli.py

@@ -0,0 +1,228 @@
+"""Command-line entrypoint: init | validate | list | run | daemon."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+from . import __version__
+from .agent import get_agent, get_switcher
+from .config import Account, Config, ConfigError, load_config
+from .cron import next_fire
+from .cswap import CswapError
+from .log import log_event, setup_logging
+from .schedule import run_batch, run_daemon
+from .warmup import FAILED
+
+DEFAULT_CONFIG = "config.json"
+
+CONFIG_TEMPLATE = """{
+  "defaults": {
+    "agent": "claude",
+    "message": "Hi",
+    "timezone": "Asia/Kolkata",
+    "settle_seconds": 3,
+    "skip_if_warm": true
+  },
+  "accounts": [
+    { "id": "1", "enabled": true,  "schedules": ["0 5 * * 1-5", "0 13 * * 1-5"] },
+    { "id": "2", "enabled": true,  "schedule": "30 7 * * 1-5" },
+    { "id": "3", "enabled": false, "schedule": "0 10 * * *" }
+  ]
+}
+"""
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if args.command is None:
+        parser.print_help()
+        return 2
+
+    setup_logging(log_file=args.log_file)
+
+    # `init` writes the config, so it must run before we try to load one.
+    if args.command == "init":
+        return _cmd_init(args.config, args.force)
+
+    try:
+        config = load_config(args.config)
+    except ConfigError as exc:
+        print(f"config error: {exc}", file=sys.stderr)
+        return 2
+
+    if args.command == "validate":
+        return _cmd_validate(config)
+    if args.command == "list":
+        return _cmd_list(config)
+    if args.command == "run":
+        return _cmd_run(config, args.account)
+    if args.command == "daemon":
+        return _cmd_daemon(config)
+    return 2
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="cwarm",
+        description="Stagger-warm coding-agent accounts so their usage windows reset at different times.",
+    )
+    parser.add_argument("--version", action="version", version=f"cwarm {__version__}")
+    parser.add_argument(
+        "-c", "--config", default=DEFAULT_CONFIG, type=Path,
+        help=f"path to the JSON config (default: {DEFAULT_CONFIG})",
+    )
+    parser.add_argument(
+        "--log-file", default=None, type=Path,
+        help="also append structured logs to this file",
+    )
+
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    init = sub.add_parser("init", help="write a starter config.json")
+    init.add_argument("--force", action="store_true", help="overwrite an existing config")
+
+    sub.add_parser("validate", help="validate config and environment; send nothing")
+    sub.add_parser("list", help="show configured accounts, window state, and next run")
+
+    run = sub.add_parser("run", help="warm all enabled accounts (or one) immediately")
+    run.add_argument("--account", default=None, help="warm only this account id (slot or email)")
+
+    sub.add_parser("daemon", help="run long-lived, firing each account on its cron schedule")
+    return parser
+
+
+def _cmd_init(config_path: Path, force: bool) -> int:
+    if config_path.exists() and not force:
+        print(f"init: {config_path} already exists — use --force to overwrite", file=sys.stderr)
+        return 1
+    config_path.write_text(CONFIG_TEMPLATE)
+    print(f"init: wrote {config_path} — edit the account ids/schedules, then run `cwarm validate`")
+    return 0
+
+
+def _cmd_validate(config: Config) -> int:
+    """Schema OK; each agent's CLI present and (if it switches) every id known. Sends nothing."""
+    for agent_name, accounts in _by_agent(config).items():
+        agent = get_agent(agent_name)
+        if shutil.which(agent.command[0]) is None:
+            print(f"validate: agent '{agent_name}': '{agent.command[0]}' is not on PATH", file=sys.stderr)
+            return 1
+
+        switcher = get_switcher(agent.switcher)
+        if switcher is None:
+            continue  # no switcher: can't enumerate accounts, nothing more to check
+        if not switcher.is_installed():
+            print(f"validate: agent '{agent_name}': switcher '{agent.switcher}' is not on PATH", file=sys.stderr)
+            return 1
+        try:
+            listed = switcher.list_accounts()
+        except CswapError as exc:
+            print(f"validate: agent '{agent_name}': could not list accounts: {exc}", file=sys.stderr)
+            return 1
+
+        missing = [a.id for a in accounts if not any(la.matches(a.id) for la in listed)]
+        if missing:
+            known = ", ".join(f"{la.slot}:{la.email}" for la in listed) or "(none)"
+            print(
+                f"validate: these ids are not known to agent '{agent_name}': "
+                + ", ".join(missing)
+                + f"\n  known accounts: {known}",
+                file=sys.stderr,
+            )
+            return 1
+
+    enabled = len(config.enabled_accounts())
+    used = ", ".join(sorted(_by_agent(config)))
+    print(f"validate: ok — {len(config.accounts)} account(s) configured, {enabled} enabled, agents: {used}")
+    return 0
+
+
+def _cmd_list(config: Config) -> int:
+    """Read-only overview: each account's agent, window state (live), and next run. Sends nothing."""
+    listings: dict[str, list | None] = {}
+
+    def window_state(account: Account) -> str:
+        switcher = get_switcher(get_agent(account.agent).switcher)
+        if switcher is None:
+            return "n/a"
+        name = get_agent(account.agent).switcher
+        if name not in listings:
+            try:
+                listings[name] = switcher.list_accounts()
+            except CswapError:
+                listings[name] = None
+        listed = listings[name]
+        if listed is None:
+            return "?"
+        match = next((a for a in listed if a.matches(account.id)), None)
+        if match is None:
+            return "unknown"
+        return {True: "warm", False: "cold", None: "?"}[match.window_open]
+
+    rows = [
+        (
+            account.id,
+            account.agent,
+            "yes" if account.enabled else "no",
+            window_state(account),
+            _next_run(account) if account.enabled else "-",
+            ", ".join(account.schedules),
+        )
+        for account in config.accounts
+    ]
+    _print_table(("ID", "AGENT", "ON", "WINDOW", "NEXT RUN", "SCHEDULE(S)"), rows)
+    return 0
+
+
+def _cmd_run(config: Config, account: str | None) -> int:
+    account_ids = [account] if account else None
+    try:
+        results = run_batch(config, account_ids)
+    except ValueError as exc:
+        print(f"run: {exc}", file=sys.stderr)
+        return 2
+    failed = sum(1 for r in results if r.outcome == FAILED)
+    log_event("run", outcome="done", total=len(results), failed=failed)
+    return 1 if failed else 0
+
+
+def _cmd_daemon(config: Config) -> int:
+    run_daemon(config)
+    return 0
+
+
+def _by_agent(config: Config) -> dict[str, list[Account]]:
+    grouped: dict[str, list[Account]] = {}
+    for account in config.accounts:
+        grouped.setdefault(account.agent, []).append(account)
+    return grouped
+
+
+def _next_run(account: Account) -> str:
+    """Soonest upcoming fire across the account's schedules, in its timezone."""
+    now = datetime.now(ZoneInfo(account.timezone))
+    fires = [f for cron in account.schedules if (f := next_fire(cron, account.timezone, now))]
+    if not fires:
+        return "-"
+    return min(fires).strftime("%a %H:%M (%d %b)")
+
+
+def _print_table(headers: tuple[str, ...], rows: list[tuple[str, ...]]) -> None:
+    widths = [len(h) for h in headers]
+    for row in rows:
+        widths = [max(w, len(str(c))) for w, c in zip(widths, row, strict=False)]
+    line = "  ".join(h.ljust(w) for h, w in zip(headers, widths, strict=False))
+    print(line)
+    print("  ".join("-" * w for w in widths))
+    for row in rows:
+        print("  ".join(str(c).ljust(w) for c, w in zip(row, widths, strict=False)))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cwarm/config.py

@@ -0,0 +1,226 @@
+"""Load and validate the cwarm JSON config (§7).
+
+No tokens live here — accounts are referenced by the handle their agent uses
+(e.g. a claude-swap slot number or email). Per-account fields fall back to
+`defaults`.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from .agent import DEFAULT_AGENT, known_agents
+from .cron import to_trigger
+
+# 5-field cron, the subset APScheduler's CronTrigger.from_crontab accepts.
+_CRON_FIELDS = 5
+
+
+class ConfigError(ValueError):
+    """Raised when the config file is missing, malformed, or invalid."""
+
+
+@dataclass(frozen=True)
+class Defaults:
+    agent: str = DEFAULT_AGENT
+    message: str = "Hi"
+    timezone: str = "Asia/Kolkata"
+    settle_seconds: int = 3
+    skip_if_warm: bool = False
+
+
+@dataclass(frozen=True)
+class Account:
+    id: str
+    agent: str
+    schedules: tuple[str, ...]
+    enabled: bool
+    message: str
+    timezone: str
+    settle_seconds: int
+    skip_if_warm: bool
+
+
+@dataclass(frozen=True)
+class Config:
+    defaults: Defaults
+    accounts: list[Account]
+
+    def enabled_accounts(self) -> list[Account]:
+        return [a for a in self.accounts if a.enabled]
+
+    def find(self, account_id: str) -> Account | None:
+        return next((a for a in self.accounts if a.id == account_id), None)
+
+
+def load_config(path: str | Path) -> Config:
+    """Read, parse, and validate the config at `path`. Raises ConfigError."""
+    path = Path(path)
+    if not path.is_file():
+        raise ConfigError(f"config file not found: {path}")
+    try:
+        raw = json.loads(path.read_text())
+    except json.JSONDecodeError as exc:
+        raise ConfigError(f"{path}: invalid JSON: {exc}") from exc
+    return _build(raw, path)
+
+
+def _build(raw: object, path: Path) -> Config:
+    if not isinstance(raw, dict):
+        raise ConfigError(f"{path}: top level must be a JSON object")
+
+    defaults = _build_defaults(raw.get("defaults", {}))
+
+    raw_accounts = raw.get("accounts")
+    if not isinstance(raw_accounts, list) or not raw_accounts:
+        raise ConfigError(f"{path}: 'accounts' must be a non-empty array")
+
+    accounts: list[Account] = []
+    seen: set[str] = set()
+    for i, entry in enumerate(raw_accounts):
+        account = _build_account(entry, defaults, i)
+        if account.id in seen:
+            raise ConfigError(f"{path}: duplicate account id {account.id!r}")
+        seen.add(account.id)
+        accounts.append(account)
+
+    return Config(defaults=defaults, accounts=accounts)
+
+
+def _build_defaults(raw: object) -> Defaults:
+    if not isinstance(raw, dict):
+        raise ConfigError("'defaults' must be a JSON object")
+    base = Defaults()
+    agent = raw.get("agent", base.agent)
+    message = raw.get("message", base.message)
+    timezone = raw.get("timezone", base.timezone)
+    settle = raw.get("settle_seconds", base.settle_seconds)
+    skip = raw.get("skip_if_warm", base.skip_if_warm)
+    _check_agent("defaults", agent)
+    _check_message("defaults", message)
+    _check_timezone("defaults", timezone)
+    _check_settle("defaults", settle)
+    _check_bool("defaults.skip_if_warm", skip)
+    return Defaults(
+        agent=agent,
+        message=message,
+        timezone=timezone,
+        settle_seconds=settle,
+        skip_if_warm=skip,
+    )
+
+
+def _build_account(raw: object, defaults: Defaults, index: int) -> Account:
+    where = f"accounts[{index}]"
+    if not isinstance(raw, dict):
+        raise ConfigError(f"{where}: must be a JSON object")
+
+    account_id = raw.get("id")
+    if not isinstance(account_id, str) or not account_id.strip():
+        raise ConfigError(f"{where}: 'id' is required and must be a non-empty string")
+    account_id = account_id.strip()
+
+    schedules = _collect_schedules(raw, f"{where} ({account_id})")
+
+    enabled = raw.get("enabled", True)
+    _check_bool(f"{where} ({account_id}).enabled", enabled)
+
+    agent = raw.get("agent", defaults.agent)
+    message = raw.get("message", defaults.message)
+    timezone = raw.get("timezone", defaults.timezone)
+    settle = raw.get("settle_seconds", defaults.settle_seconds)
+    skip = raw.get("skip_if_warm", defaults.skip_if_warm)
+    _check_agent(f"{where} ({account_id})", agent)
+    _check_message(f"{where} ({account_id})", message)
+    _check_timezone(f"{where} ({account_id})", timezone)
+    _check_settle(f"{where} ({account_id})", settle)
+    _check_bool(f"{where} ({account_id}).skip_if_warm", skip)
+
+    return Account(
+        id=account_id,
+        agent=agent,
+        schedules=schedules,
+        enabled=enabled,
+        message=message,
+        timezone=timezone,
+        settle_seconds=settle,
+        skip_if_warm=skip,
+    )
+
+
+def _collect_schedules(raw: dict, where: str) -> tuple[str, ...]:
+    """Gather warmup times from `schedule` (string) and/or `schedules` (array).
+
+    Either or both keys may be present; the result is the de-duplicated union,
+    so one account can fire at several times of day (e.g. 05:00, 11:00, 21:00).
+    """
+    collected: list[str] = []
+
+    single = raw.get("schedule")
+    if single is not None:
+        if not isinstance(single, str) or not single.strip():
+            raise ConfigError(f"{where}: 'schedule' must be a non-empty cron string")
+        collected.append(single.strip())
+
+    multi = raw.get("schedules")
+    if multi is not None:
+        if not isinstance(multi, list) or not multi:
+            raise ConfigError(f"{where}: 'schedules' must be a non-empty array of cron strings")
+        for entry in multi:
+            if not isinstance(entry, str) or not entry.strip():
+                raise ConfigError(f"{where}: every 'schedules' entry must be a non-empty cron string")
+            collected.append(entry.strip())
+
+    if not collected:
+        raise ConfigError(f"{where}: provide 'schedule' (string) or 'schedules' (array of 5-field cron)")
+
+    for cron in collected:
+        _check_cron(where, cron)
+
+    return tuple(dict.fromkeys(collected))  # de-dup, preserve order
+
+
+def _check_agent(where: str, value: object) -> None:
+    if not isinstance(value, str) or value not in known_agents():
+        raise ConfigError(
+            f"{where}.agent: must be one of {known_agents()}, got {value!r}"
+        )
+
+
+def _check_bool(where: str, value: object) -> None:
+    if not isinstance(value, bool):
+        raise ConfigError(f"{where}: must be a boolean")
+
+
+def _check_message(where: str, value: object) -> None:
+    if not isinstance(value, str) or not value:
+        raise ConfigError(f"{where}.message: must be a non-empty string")
+
+
+def _check_settle(where: str, value: object) -> None:
+    if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+        raise ConfigError(f"{where}.settle_seconds: must be a non-negative integer")
+
+
+def _check_timezone(where: str, value: object) -> None:
+    if not isinstance(value, str):
+        raise ConfigError(f"{where}.timezone: must be a string")
+    try:
+        ZoneInfo(value)
+    except (ZoneInfoNotFoundError, ValueError) as exc:
+        raise ConfigError(f"{where}.timezone: unknown timezone {value!r}") from exc
+
+
+def _check_cron(where: str, value: str) -> None:
+    fields = value.split()
+    if len(fields) != _CRON_FIELDS:
+        raise ConfigError(
+            f"{where}.schedule: expected a 5-field cron expression, got {len(fields)} fields: {value!r}"
+        )
+    try:
+        to_trigger(value, "UTC")  # tz irrelevant here; this also validates each field
+    except (ValueError, TypeError) as exc:
+        raise ConfigError(f"{where}.schedule: invalid cron {value!r}: {exc}") from exc

cwarm/cron.py

@@ -0,0 +1,64 @@
+"""Translate 5-field crontab expressions into APScheduler CronTriggers.
+
+APScheduler's own `CronTrigger.from_crontab()` does **not** convert the
+day-of-week numbering: crontab uses 0/7=Sunday..6=Saturday, while APScheduler
+uses 0=Monday..6=Sunday. Passing crontab numbers straight through shifts every
+weekday by one (so `1-5`, meant as Mon-Fri, schedules as Tue-Sat). We translate
+the day-of-week field to weekday names so a crontab expression means what a user
+typing it into `crontab` would expect.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from apscheduler.triggers.cron import CronTrigger
+
+# crontab day-of-week: index 0..6 = Sun..Sat (and 7 also = Sun).
+_DOW_NAMES = ("sun", "mon", "tue", "wed", "thu", "fri", "sat")
+
+
+def to_trigger(expression: str, timezone: str) -> CronTrigger:
+    minute, hour, day, month, dow = expression.split()
+    return CronTrigger(
+        minute=minute,
+        hour=hour,
+        day=day,
+        month=month,
+        day_of_week=_translate_dow(dow),
+        timezone=timezone,
+    )
+
+
+def next_fire(expression: str, timezone: str, now: datetime) -> datetime | None:
+    return to_trigger(expression, timezone).get_next_fire_time(None, now)
+
+
+def _translate_dow(field: str) -> str:
+    if field == "*":
+        return "*"
+    return ",".join(_translate_part(part) for part in field.split(","))
+
+
+def _translate_part(part: str) -> str:
+    step = ""
+    if "/" in part:
+        part, _, step = part.partition("/")
+        step = "/" + step
+    if part == "*":
+        return "*" + step
+    if "-" in part:
+        lo, hi = part.split("-", 1)
+        return f"{_name(lo)}-{_name(hi)}{step}"
+    return _name(part) + step
+
+
+def _name(token: str) -> str:
+    """crontab day-of-week token -> APScheduler weekday name (numbers only)."""
+    try:
+        n = int(token)
+    except ValueError:
+        return token.lower()  # already a name like "mon"
+    if not 0 <= n <= 7:
+        raise ValueError(f"day-of-week out of range (0-7): {token!r}")
+    return _DOW_NAMES[0 if n == 7 else n]

cwarm/cswap.py

@@ -0,0 +1,123 @@
+"""The one account-switcher backend: claude-swap (`cswap`).
+
+It switches Claude Code credentials and reports per-account usage-window state —
+the only genuinely agent-specific machinery in cwarm. A different coding agent
+that can swap accounts would get a sibling module exposing the same surface
+(`status` / `list_accounts` / `switch_to`), referenced from `agent.py`.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from dataclasses import dataclass
+
+CSWAP = "cswap"
+
+# `Status: Account-3 (email@x [Org])`
+_STATUS_RE = re.compile(r"^Status:\s+Account-(\d+)\s+\(([^\s\[\]()]+)")
+# A listed account header: `  3: email@x [Org] (active)`
+_LIST_HEAD_RE = re.compile(r"^\s*(\d+):\s+(\S+)\s+\[.*?\](?P<active>\s+\(active\))?\s*$")
+# A 5h usage line with a reset time: `├ 5h:   3%   resets 14:09   in 4h 19m`
+_FIVE_H_RE = re.compile(r"5h:\s*\d+%\s*resets\s+(\d{1,2}:\d{2})")
+
+
+class CswapError(RuntimeError):
+    """A cswap invocation failed."""
+
+
+@dataclass(frozen=True)
+class ActiveAccount:
+    slot: str
+    email: str
+    window_reset: str | None  # HH:MM if a window is open, else None
+
+    @property
+    def ref(self) -> str:
+        """The id to pass back to switch_to (slot is the most stable handle)."""
+        return self.slot
+
+
+@dataclass(frozen=True)
+class ListedAccount:
+    slot: str
+    email: str
+    active: bool
+    window_open: bool | None  # True=warm, False=closed, None=usage unavailable
+
+    def matches(self, account_id: str) -> bool:
+        return account_id == self.slot or account_id.lower() == self.email.lower()
+
+
+def is_installed() -> bool:
+    return shutil.which(CSWAP) is not None
+
+
+def status() -> ActiveAccount | None:
+    """Currently-active account, or None if none could be determined."""
+    out = _run(["--status"])
+    slot = email = reset = None
+    for line in out.splitlines():
+        m = _STATUS_RE.match(line)
+        if m:
+            slot, email = m.group(1), m.group(2)
+            continue
+        if reset is None:
+            fm = _FIVE_H_RE.search(line)
+            if fm:
+                reset = fm.group(1)
+    if slot is None or email is None:
+        return None
+    return ActiveAccount(slot=slot, email=email, window_reset=reset)
+
+
+def list_accounts() -> list[ListedAccount]:
+    """All managed accounts with their usage-window state."""
+    out = _run(["--list"])
+    accounts: list[ListedAccount] = []
+    current: dict | None = None
+
+    def flush() -> None:
+        if current is not None:
+            accounts.append(ListedAccount(**current))
+
+    for line in out.splitlines():
+        head = _LIST_HEAD_RE.match(line)
+        if head:
+            flush()
+            current = {
+                "slot": head.group(1),
+                "email": head.group(2),
+                "active": head.group("active") is not None,
+                "window_open": None,
+            }
+            continue
+        if current is None:
+            continue
+        if "Running instances" in line:
+            break
+        if _FIVE_H_RE.search(line):
+            current["window_open"] = True
+        elif "usage unavailable" in line.lower():
+            current["window_open"] = None
+    flush()
+    return accounts
+
+
+def switch_to(account_id: str) -> None:
+    """Make `account_id` (slot number or email) the active account."""
+    _run(["--switch-to", account_id])
+
+
+def _run(args: list[str]) -> str:
+    try:
+        proc = subprocess.run([CSWAP, *args], capture_output=True, text=True, timeout=60)
+    except FileNotFoundError as exc:
+        raise CswapError(f"{CSWAP} is not installed or not on PATH") from exc
+    except subprocess.TimeoutExpired as exc:
+        raise CswapError(f"cswap {' '.join(args)} timed out") from exc
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip()
+        raise CswapError(f"cswap {' '.join(args)} exited {proc.returncode}: {detail}")
+    return proc.stdout

cwarm/log.py

@@ -0,0 +1,58 @@
+"""Structured, single-line logging (FR11, G6).
+
+Each warmup attempt and each save/restore emits exactly one line so a silent
+failure is impossible to miss. Output goes to stderr and, optionally, a file.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+_LOGGER_NAME = "cwarm"
+_FORMAT = "%(asctime)s %(levelname)s %(message)s"
+_DATEFMT = "%Y-%m-%dT%H:%M:%S%z"
+
+
+def setup_logging(log_file: str | Path | None = None, level: int = logging.INFO) -> logging.Logger:
+    logger = logging.getLogger(_LOGGER_NAME)
+    logger.setLevel(level)
+    logger.handlers.clear()
+    formatter = logging.Formatter(_FORMAT, datefmt=_DATEFMT)
+
+    stream = logging.StreamHandler(sys.stderr)
+    stream.setFormatter(formatter)
+    logger.addHandler(stream)
+
+    if log_file is not None:
+        path = Path(log_file)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(path)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def get_logger() -> logging.Logger:
+    return logging.getLogger(_LOGGER_NAME)
+
+
+def _fields(**fields: object) -> str:
+    return " ".join(f"{k}={v}" for k, v in fields.items() if v is not None)
+
+
+def log_attempt(account_id: str, outcome: str, reset: str | None = None, error: str | None = None) -> None:
+    """One structured line per warmup attempt (FR11)."""
+    logger = get_logger()
+    msg = "warmup " + _fields(account=account_id, outcome=outcome, reset=reset, error=error)
+    if outcome == "failed":
+        logger.error(msg)
+    else:
+        logger.info(msg)
+
+
+def log_event(event: str, **fields: object) -> None:
+    """One structured line for batch lifecycle events (save/restore, etc.)."""
+    get_logger().info(f"{event} " + _fields(**fields))

cwarm/schedule.py

@@ -0,0 +1,128 @@
+"""Batch execution and the long-lived daemon (FR3, FR5, FR8).
+
+Warmups are strictly serial — a switcher has only one active account at a time.
+For each switcher the batch touches, the active account is captured before and
+restored after, even on failure (FR3). The daemon maps each enabled account's
+cron+timezone to a job and serialises all firings through a single lock.
+"""
+
+from __future__ import annotations
+
+import threading
+
+from apscheduler.schedulers.blocking import BlockingScheduler
+
+from .agent import get_agent, get_switcher
+from .config import Account, Config
+from .cron import to_trigger
+from .cswap import ActiveAccount, CswapError
+from .log import log_event
+from .warmup import FAILED, WarmResult, warm_account
+
+# Serialises warmups so two coincident cron firings never run concurrently (FR5).
+_warmup_lock = threading.Lock()
+
+
+def run_batch(config: Config, account_ids: list[str] | None = None) -> list[WarmResult]:
+    """Warm the selected accounts serially, saving and restoring each switcher's active one.
+
+    `account_ids=None` warms every enabled account. Restore (FR3) runs in a
+    `finally` so it survives any individual warmup failure.
+    """
+    accounts = _select(config, account_ids)
+    with _warmup_lock:
+        return _run_serial(accounts)
+
+
+def _run_serial(accounts: list[Account]) -> list[WarmResult]:
+    # Distinct switcher backends this batch will touch (agents may share one).
+    switchers = {get_agent(a.agent).switcher for a in accounts}
+    switchers.discard(None)
+    saved = {name: _save_active(name) for name in switchers}
+    results: list[WarmResult] = []
+    try:
+        for account in accounts:
+            results.append(warm_account(account))
+    finally:
+        for name, active in saved.items():
+            _restore_active(name, active)
+    return results
+
+
+def _save_active(switcher_name: str) -> ActiveAccount | None:
+    try:
+        active = get_switcher(switcher_name).status()
+    except CswapError as exc:
+        log_event("save-active", switcher=switcher_name, outcome=FAILED, error=str(exc))
+        return None
+    if active:
+        log_event("save-active", switcher=switcher_name, account=active.email, ref=active.ref)
+    else:
+        log_event("save-active", switcher=switcher_name, outcome="none", error="no-active-account")
+    return active
+
+
+def _restore_active(switcher_name: str, saved: ActiveAccount | None) -> None:
+    if saved is None:
+        log_event("restore-active", switcher=switcher_name, outcome="skipped", error="nothing-to-restore")
+        return
+    try:
+        get_switcher(switcher_name).switch_to(saved.ref)
+        log_event("restore-active", switcher=switcher_name, account=saved.email, ref=saved.ref, outcome="ok")
+    except CswapError as exc:
+        log_event("restore-active", switcher=switcher_name, account=saved.email, outcome=FAILED, error=str(exc))
+
+
+def _select(config: Config, account_ids: list[str] | None) -> list[Account]:
+    if account_ids is None:
+        return config.enabled_accounts()
+    selected: list[Account] = []
+    for account_id in account_ids:
+        account = config.find(account_id)
+        if account is None:
+            raise ValueError(f"account id {account_id!r} not found in config")
+        if not account.enabled:
+            log_event("select", account=account_id, outcome="skipped", error="disabled")
+            continue
+        selected.append(account)
+    return selected
+
+
+def run_daemon(config: Config) -> None:
+    """Long-lived scheduler: one cron job per enabled account (FR8)."""
+    # Explicit scheduler tz avoids tzlocal probing /etc/timezone; each job still
+    # carries its own per-account timezone.
+    scheduler = BlockingScheduler(timezone=config.defaults.timezone)
+    enabled = config.enabled_accounts()
+    if not enabled:
+        log_event("daemon", outcome="no-enabled-accounts")
+        return
+
+    jobs = 0
+    for account in enabled:
+        for idx, cron in enumerate(account.schedules):
+            trigger = to_trigger(cron, account.timezone)
+            scheduler.add_job(
+                _fire,
+                trigger=trigger,
+                args=[account],
+                id=f"cwarm:{account.agent}:{account.id}:{idx}",
+                name=f"warmup {account.agent}:{account.id} [{cron}]",
+                max_instances=1,
+                coalesce=True,
+                misfire_grace_time=3600,
+            )
+            log_event("schedule", account=account.id, cron=repr(cron), tz=account.timezone)
+            jobs += 1
+
+    log_event("daemon", outcome="started", jobs=jobs)
+    try:
+        scheduler.start()
+    except (KeyboardInterrupt, SystemExit):
+        log_event("daemon", outcome="stopped")
+
+
+def _fire(account: Account) -> None:
+    """A single account's scheduled firing: its own save/restore batch."""
+    with _warmup_lock:
+        _run_serial([account])

cwarm/warmup.py

@@ -0,0 +1,95 @@
+"""Warm a single account: (optionally switch) -> settle -> send message (FR4).
+
+The send is just the agent's configured command with the message appended
+(`claude -p "Hi"`). If the agent has a switcher, we switch to the target account
+first; a fresh process then reads the swapped credentials at startup, so no
+interactive restart is needed — the `settle_seconds` delay covers the write race.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from types import ModuleType
+
+from .agent import get_agent, get_switcher
+from .config import Account
+from .cswap import CswapError
+from .log import log_attempt
+
+# Outcomes (FR11)
+OK = "ok"
+FAILED = "failed"
+SKIPPED = "skipped"
+
+_SEND_TIMEOUT = 180  # seconds for a single warmup message
+_SEND_ERRORS = (CswapError, OSError, subprocess.SubprocessError, RuntimeError)
+
+
+@dataclass(frozen=True)
+class WarmResult:
+    account_id: str
+    outcome: str
+    reset: str | None = None
+    error: str | None = None
+
+
+def warm_account(account: Account) -> WarmResult:
+    """Switch to `account` (if its agent switches), settle, and anchor its window."""
+    agent = get_agent(account.agent)
+    switcher = get_switcher(agent.switcher)
+
+    if account.skip_if_warm and switcher:
+        try:
+            if _is_warm(switcher, account):
+                log_attempt(account.id, SKIPPED, error="already-warm")
+                return WarmResult(account.id, SKIPPED, error="already-warm")
+        except CswapError as exc:
+            # Can't tell if warm — fall through and warm it rather than skip blindly.
+            log_attempt(account.id, "warn", error=f"skip-check-failed: {exc}")
+
+    try:
+        if switcher:
+            switcher.switch_to(account.id)
+            if account.settle_seconds > 0:
+                time.sleep(account.settle_seconds)
+        _send(agent.command, account.message)
+    except _SEND_ERRORS as exc:
+        result = WarmResult(account.id, FAILED, error=_summary(exc))
+        log_attempt(account.id, FAILED, error=result.error)
+        return result
+
+    reset = _reset(switcher)
+    log_attempt(account.id, OK, reset=reset)
+    return WarmResult(account.id, OK, reset=reset)
+
+
+def _send(command: tuple[str, ...], message: str) -> None:
+    """Send one non-interactive warmup message via the agent's CLI."""
+    proc = subprocess.run([*command, message], capture_output=True, text=True, timeout=_SEND_TIMEOUT)
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip().splitlines()
+        raise RuntimeError(detail[-1] if detail else f"{command[0]} exited {proc.returncode}")
+
+
+def _is_warm(switcher: ModuleType, account: Account) -> bool:
+    """True if the account's usage window is already open (skip-if-warm, FR6)."""
+    listed = next((a for a in switcher.list_accounts() if a.matches(account.id)), None)
+    return bool(listed and listed.window_open)
+
+
+def _reset(switcher: ModuleType | None) -> str | None:
+    """Best-effort window reset time for the log line."""
+    if switcher is None:
+        return None
+    try:
+        active = switcher.status()
+    except CswapError:
+        return None
+    return active.window_reset if active else None
+
+
+def _summary(exc: Exception) -> str:
+    text = str(exc).strip().replace("\n", " ")
+    return text[:200] if text else exc.__class__.__name__

cwarm-0.1.0.dist-info/METADATA

@@ -0,0 +1,277 @@
+Metadata-Version: 2.4
+Name: cwarm
+Version: 0.1.0
+Summary: Stagger-warm coding-agent accounts (Claude Code, Codex, ...) so their usage windows open early and reset at different times.
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: apscheduler<4,>=3.10
+Requires-Dist: tzdata; platform_system == 'Windows'
+Provides-Extra: dev
+Requires-Dist: commitizen>=3; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cwarm
+
+[![CI](https://github.com/wonderbyte/cwarm/actions/workflows/ci.yml/badge.svg)](https://github.com/wonderbyte/cwarm/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/cwarm.svg)](https://pypi.org/project/cwarm/)
+[![Python](https://img.shields.io/pypi/pyversions/cwarm.svg)](https://pypi.org/project/cwarm/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Stagger-warm multiple **coding-agent accounts** so their rolling usage windows
+open early in the day and reset at different times. Today it warms **Claude Code**
+accounts (paired with [`claude-swap`](https://pypi.org/project/claude-swap/),
+`cswap`); the agent layer is generic, so other CLIs (e.g. Codex) can be added.
+When the active account exhausts its window, another is already warm to switch
+into.
+
+This tool **stores no credentials** — the account-switcher (`claude-swap`) is the
+source of truth for accounts and tokens. cwarm only orchestrates it.
+
+## How it works
+
+Claude Code's 5-hour window starts on an account's first message and resets
+exactly 5 hours later. It's a fixed budget, not free capacity — warming only
+*relocates* the dead/regeneration time so it lands outside your working hours.
+Staggering the warmups (e.g. 05:00, 07:30, 10:00) keeps at least one fresh
+account available through the day.
+
+For each due account, cwarm:
+
+1. switches to it (for Claude: `cswap --switch-to <id>`),
+2. waits `settle_seconds` for the credential swap to land,
+3. sends one minimal message via the agent's command (for Claude: `claude -p "Hi"`)
+   — anchoring that account's window,
+
+then restores whichever account you had active before the batch (always, even
+if a warmup fails).
+
+> A **weekly cap** is shared across web, app, and Claude Code. Warming several
+> accounts daily consumes some of it. Tracking that cap is out of scope.
+
+## Agents
+
+An "agent" is just two things: a **command** that sends a non-interactive prompt
+(`<cli> -p "Hi"`) and an optional **account-switcher**. They live as a small data
+table in `cwarm/agent.py` — not a class per agent:
+
+| agent | command | switcher |
+| --- | --- | --- |
+| `claude` | `claude -p` | `cswap` (claude-swap) |
+
+Each account picks its agent via the `agent` field (default `claude`). To add a
+coding agent, add one row. Only a *new* switcher (something other than `cswap`)
+needs code — a sibling module to `cwarm/cswap.py`. An agent with no switcher
+warms whatever account that CLI currently has active (no multi-account swapping).
+
+## Requirements
+
+- For the `claude` agent: `claude-swap` installed and configured with every
+  target account added (`cswap --add-account` / `cswap --add-token sk-ant-oat01-…`),
+  and Claude Code (`claude`) runnable non-interactively.
+- Python 3.12+.
+
+## Platform support
+
+cwarm is pure Python and runs anywhere the agent's CLIs (`claude`, `cswap`) do:
+
+- **Linux** — fully supported, with the bundled `systemd` user service.
+- **macOS** — the tool and `cwarm daemon` work the same; for boot persistence
+  use `launchd` or `cron` instead of systemd.
+- **Windows** — works too; `tzdata` is pulled in automatically (Windows has no
+  system IANA tz database). Use Task Scheduler or run `cwarm daemon` as a
+  service instead of systemd.
+
+`cwarm run`/`daemon` are cross-platform; only the deployment recipe differs.
+
+## Install
+
+```bash
+cd ~/workspace/apps/cwarm
+uv venv
+uv pip install -e .
+cp config.example.json config.json   # then edit ids/schedules
+```
+
+`config.json` is gitignored — it holds your real account ids.
+
+## Configuration (`config.json`)
+
+No tokens. Accounts are referenced by the handle their agent uses — for Claude, a
+`cswap` **slot number** or **email**.
+
+```json
+{
+  "defaults": {
+    "agent": "claude",
+    "message": "Hi",
+    "timezone": "Asia/Kolkata",
+    "settle_seconds": 3,
+    "skip_if_warm": true
+  },
+  "accounts": [
+    { "id": "work@example.com", "enabled": true,  "schedules": ["0 5 * * 1-5", "0 11 * * 1-5", "0 21 * * 1-5"] },
+    { "id": "2",                "enabled": true,  "schedule": "30 7 * * 1-5" },
+    { "id": "personal@x.com",   "enabled": true,  "schedules": ["0 10 * * *", "0 18 * * *"] },
+    { "id": "4",                "enabled": false, "schedule": "30 12 * * *" }
+  ]
+}
+```
+
+An account can warm at **several times a day** — give it a `schedules` array
+(e.g. 05:00, 11:00, 21:00). Use the singular `schedule` string for a single
+time. Both keys may be present; their union (de-duplicated) is used. Each cron
+time becomes its own daemon job, fired in the account's `timezone`.
+
+| Field | Required | Default | Notes |
+| --- | --- | --- | --- |
+| `id` | yes | — | unique; the agent's account handle (cswap slot or email) |
+| `schedule` / `schedules` | yes | — | one (string) or many (array) 5-field cron times, read in the account's `timezone` |
+| `agent` | no | `defaults` / `claude` | which coding agent warms this account |
+| `enabled` | no | `true` | `false` skips the account entirely |
+| `message` | no | `defaults` / `"Hi"` | the warmup message |
+| `timezone` | no | `defaults` / `Asia/Kolkata` | IANA tz name |
+| `settle_seconds` | no | `defaults` / `3` | delay after switching before sending |
+| `skip_if_warm` | no | `defaults` / `false` | skip if the window is already open |
+
+## Usage
+
+```bash
+cwarm init                           # write a starter config.json
+cwarm validate                       # check config + agents; sends nothing
+cwarm list                           # show accounts, live window state, next run
+cwarm run                            # warm all enabled accounts now
+cwarm run --account work@example.com # warm just one
+cwarm daemon                         # long-lived; fires each account on its cron
+
+# global flags
+cwarm --config /path/to/config.json --log-file /path/to/cwarm.log <command>
+```
+
+- **`init`** — writes a starter `config.json` (won't clobber an existing one
+  without `--force`).
+- **`validate`** — confirms the JSON matches the schema, each account's agent CLI
+  (and its switcher) is installed, and every configured `id` exists. Exits
+  non-zero and sends nothing on any problem.
+- **`list`** — read-only table of every account: agent, enabled, live window
+  state (warm/cold), next scheduled run, and its cron times. Sends nothing.
+- **`run`** — warms enabled accounts immediately (one batch, one save/restore per
+  switcher). Good for testing or a system `crontab`. Non-zero if any warmup failed.
+- **`daemon`** — schedules one job per account per cron time, in the account's
+  timezone. Warmups are always serial.
+
+### Logging
+
+Every attempt emits one structured line to stderr (and the log file if set):
+
+```
+2026-06-21T05:00:03+0530 INFO save-active switcher=cswap account=work@example.com ref=1
+2026-06-21T05:00:09+0530 INFO warmup account=work@example.com outcome=ok reset=10:00
+2026-06-21T05:00:10+0530 INFO restore-active switcher=cswap account=work@example.com ref=1 outcome=ok
+```
+
+Outcomes: `ok` (with the window `reset` time), `failed` (with an `error`
+summary), `skipped` (`skip_if_warm` and already warm).
+
+## Deployment
+
+### systemd (recommended)
+
+```bash
+mkdir -p ~/.config/systemd/user ~/.local/state/cwarm
+cp systemd/cwarm.service ~/.config/systemd/user/
+systemctl --user daemon-reload
+systemctl --user enable --now cwarm
+loginctl enable-linger "$USER"        # run without an active login session
+journalctl --user -u cwarm -f
+```
+
+### Alternative: system crontab
+
+One line per warmup time invoking the one-shot mode (repeat a line per account
+to warm it several times a day):
+
+```cron
+0 5  * * 1-5 cd ~/workspace/apps/cwarm && .venv/bin/cwarm run --account work@example.com
+0 11 * * 1-5 cd ~/workspace/apps/cwarm && .venv/bin/cwarm run --account work@example.com
+0 21 * * 1-5 cd ~/workspace/apps/cwarm && .venv/bin/cwarm run --account work@example.com
+30 7 * * 1-5 cd ~/workspace/apps/cwarm && .venv/bin/cwarm run --account 2
+```
+
+## Energy
+
+The daemon does **not** poll — it sleeps on an event until the next scheduled
+warmup, so idle cost is ~25 MB RAM and effectively 0% CPU (measured: 1 voluntary
+context switch over 3 s idle). There is no busy-loop to optimise.
+
+The real per-warmup energy is the `claude -p "Hi"` call: it boots the Node
+Claude Code CLI **and** sends a real LLM inference request to anchor the window.
+That's irreducible — anchoring *requires* a server-side message. So the only
+meaningful lever is **not sending redundant ones**:
+
+- **`skip_if_warm: true`** (the example default) — before switching, parse
+  `cswap --list`; if the account's window is already open, log `skipped` and send
+  nothing. This skips the entire heavy `claude -p` call, the single biggest
+  energy saving available.
+- **Stagger, don't stack** — overlapping schedules waste warmups (and the shared
+  weekly cap). One warmup per window per account is enough to anchor it.
+
+For literally zero idle footprint, use systemd timers or cron instead of the
+daemon — no process is resident between warmups — but the saving over the
+sleeping daemon is marginal.
+
+## System restart
+
+Yes. Via the systemd **user** service plus linger:
+
+- `systemctl --user enable` + `loginctl enable-linger "$USER"` → the daemon
+  **starts on boot**, with no login session required.
+- `Restart=always` (RestartSec=10) → if the process ever exits — crash or
+  otherwise — systemd brings it straight back.
+- On every (re)start the schedule is **rebuilt fresh from `config.json`**
+  (in-memory jobstore; the config is the single source of truth — no stale
+  persisted state to reconcile).
+- **Short downtime is tolerated:** `misfire_grace_time=3600` + `coalesce=True`
+  mean a warmup missed by under an hour still fires once on recovery.
+- **Long power-off is *not* caught up by design:** a 05:00 warmup missed because
+  the machine was off until noon is skipped, not fired late — firing it hours
+  late would defeat the staggering. Edit `config.json` and
+  `systemctl --user restart cwarm` to re-plan.
+
+## Safety
+
+- No credentials stored or logged — the switcher (`claude-swap`) owns them.
+- Switching changes your local active account; run warmups at off-hours. The
+  save/restore guarantees your default is unchanged after a batch.
+- Only configure accounts you legitimately own or are authorised to use.
+
+## Contributing / releasing
+
+Commits follow [Conventional Commits](https://www.conventionalcommits.org/)
+(`feat:`, `fix:`, `docs:`, `ci:`, …). Lint and tests run in CI:
+
+```bash
+ruff check .
+pytest
+```
+
+Versioning and the changelog are managed by
+[Commitizen](https://commitizen-tools.github.io/commitizen/).
+
+**To release:** run the **Release & Publish** workflow from the Actions tab
+("Run workflow", optionally choosing the bump size). In one run it bumps the
+version (`pyproject.toml` + `cwarm/__init__.py`), updates `CHANGELOG.md`, tags
+and creates the GitHub Release, then builds and publishes to PyPI via Trusted
+Publishing — no token stored. The next version is inferred from the Conventional
+Commits since the last release.
+
+Or do it locally:
+
+```bash
+cz bump                 # bump version + changelog + create the vX.Y.Z tag
+git push --follow-tags
+```
+
+The project is in `0.x` (`major_version_zero`), so breaking changes bump the
+minor until `1.0.0`.

cwarm-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+cwarm/__init__.py,sha256=FDso22uyVsq49FrEiFaqSYU7q75DIlS4WAM7BzeB3qE,104
+cwarm/agent.py,sha256=1niSHpLvj8-q6Xk8aVpDzjYVFo_IJ7xcOqq-Rx2wzFE,1923
+cwarm/cli.py,sha256=hPqvsJNncKahDsm4K7BpLNmV3GR_QTk2f4lj6-I5UsA,8009
+cwarm/config.py,sha256=K_-xoqf3asvG_7Mqz7AHlknBEd-V0eVaZ0L7mb2nlG0,7627
+cwarm/cron.py,sha256=MMn6j8EM4xTF-2Stq1fStVj9a-YjOTBRve4x5mI-jgU,2048
+cwarm/cswap.py,sha256=AAXHH3D2AxJjKPVce867cy2KlmxYoKyNCMzmyXwyUtk,3916
+cwarm/log.py,sha256=n05ORA0VXL--H522Cf3wcR7Hl1B2Q1keqBQWyw7WOcU,1807
+cwarm/schedule.py,sha256=yY75pVZNYNvfY8flXzvo2TD9jKCpcr4LuW1D81fabvA,4856
+cwarm/warmup.py,sha256=24ZxFGQr4ApYN6LNiBZqjhEp6tMi_ZbFIqwQVS4uZvg,3350
+cwarm-0.1.0.dist-info/METADATA,sha256=16UPPqOJC8phIOHPhcDjyaBlBKPqP1eBf7x8_q3k634,11726
+cwarm-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cwarm-0.1.0.dist-info/entry_points.txt,sha256=4eosRqN9NniPmsb-9AtdKGgVMiPZetacDNplZSv7Bjw,41
+cwarm-0.1.0.dist-info/licenses/LICENSE,sha256=SJ8m54t7cDXiLyEdsMUys5G61_P1mMpHkXQVh87pheM,1067
+cwarm-0.1.0.dist-info/RECORD,,

cwarm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

cwarm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cwarm = cwarm.cli:main

cwarm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wonderbyte
+
+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.