autolimit 0.2.0 → 0.3.0

package/README.md

@@ -2,15 +2,30 @@
 
 `autolimit` is a terminal-agnostic PTY wrapper for interactive command-line runners.
 
-It was built for Claude Code style session-limit messages such as:
+It understands Claude Code style session-limit messages:
 
 ```text
 You've hit your session limit · resets 7:40pm (Asia/Seoul)
 ```
 
-When a configured limit message appears, `autolimit` parses the reset time. After that reset time plus a small grace period, it automatically sends the contents of `~/.config/autolimit/message.txt` to the still-running interactive session. If the same limit message is still on screen after the send (the session did not actually unblock), it retries a few times with backoff (60s / 120s / 240s). Time-of-day resets (`resets 7:40pm`, `resets 19:40`) and dated resets (`resets Jul 8 at 10:59am`) are both recognized.
+and OpenAI Codex CLI usage-limit messages:
 
-If the wrapped process exits after printing the limit message — or exits right after an auto-send, before the message could be processed — `autolimit` can run a runner-specific fallback command after the reset time. Built-in fallback profiles are included for `claude` and `cc`.
+```text
+You've hit your usage limit. Try again at 7:30 PM.
+You've hit your usage limit. Upgrade to Pro (https://chatgpt.com/explore/pro), visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again at Jul 8th, 2026 10:59 AM.
+```
+
+When a configured limit message appears, `autolimit` parses the reset time. After that reset time plus a small grace period, it automatically sends the contents of `~/.config/autolimit/message.txt` to the still-running interactive session. If the same limit message is still on screen after the send (the session did not actually unblock), it retries a few times with backoff (60s / 120s / 240s).
+
+Recognized reset formats:
+
+- time-of-day: `resets 7:40pm`, `resets 19:40`, `Try again at 7:30 PM.`
+- dated: `resets Jul 8 at 10:59am`, `try again at Jul 8th, 2026 10:59 AM.`
+- relative (older codex builds): `try again in 4 days 23 hours`
+
+Codex prints reset times with the machine's local clock and no timezone name, so the shipped codex patterns carry `"timezone": "local"`. Codex messages without a reset time (`Try again later.`) are ignored on purpose: there is nothing to schedule.
+
+If the wrapped process exits after printing the limit message — or exits right after an auto-send, before the message could be processed — `autolimit` can run a runner-specific fallback command after the reset time. Built-in fallback profiles are included for `claude`, `cc`, and `codex`.
 
 ## Installation
 
@@ -71,6 +86,12 @@ Wrap Claude Code directly:
 autolimit --claude
 ```
 
+Wrap Codex:
+
+```bash
+autolimit --codex
+```
+
 Wrap any command:
 
 ```bash
@@ -179,6 +200,9 @@ If the process exits after printing the limit message, `autolimit` uses a fallba
     },
     "cc": {
       "fallback": ["{runner}", "{args}", "-c", "-p", "{message}"]
+    },
+    "codex": {
+      "fallback": ["{runner}", "exec", "resume", "--last", "{message}"]
     }
   }
 }
@@ -190,6 +214,14 @@ So `autolimit --cc --model sonnet` falls back to roughly:
 cc --model sonnet -c -p '<message>'
 ```
 
+and `autolimit --codex` falls back to:
+
+```bash
+codex exec resume --last '<message>'
+```
+
+The codex fallback intentionally does not re-insert the original arguments: flags meant for the interactive TUI are not all valid for `codex exec`. Adjust the profile if your codex invocation needs them.
+
 The actual fallback is run through the same mode as the original invocation. In default shell mode, aliases and functions are respected.
 
 The fallback also covers two exit-time edge cases:
@@ -225,7 +257,7 @@ Example:
 
 ```json
 {
-  "version": 1,
+  "version": 3,
   "message_file": "/Users/you/.config/autolimit/message.txt",
   "log_file": "/Users/you/.config/autolimit/limit-watch.log",
   "default_timezone": "Asia/Seoul",
@@ -240,6 +272,21 @@ Example:
     {
       "name": "Claude-style dated limit",
       "regex": "You[\\u2019']?ve\\s+hit\\s+your(?:\\s+[\\w-]+)?\\s+limit.{0,120}?resets\\s+(?P<month>[A-Za-z]{3,9})\\.?\\s+(?P<day>\\d{1,2})(?:st|nd|rd|th)?,?\\s*(?:at\\s+)?(?P<hour>\\d{1,2})(?::(?P<minute>\\d{2}))?\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)?\\s*\\((?P<tzname>[^)]{1,64})\\)"
+    },
+    {
+      "name": "Codex-style usage limit",
+      "regex": "You[\\u2019']?ve\\s+hit\\s+your\\s+usage\\s+limit.{0,200}?try\\s+again\\s+at\\s+(?P<hour>\\d{1,2}):(?P<minute>\\d{2})\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)",
+      "timezone": "local"
+    },
+    {
+      "name": "Codex-style dated usage limit",
+      "regex": "You[\\u2019']?ve\\s+hit\\s+your\\s+usage\\s+limit.{0,200}?try\\s+again\\s+at\\s+(?P<month>[A-Za-z]{3,9})\\.?\\s+(?P<day>\\d{1,2})(?:st|nd|rd|th)?,?\\s*(?:(?P<year>\\d{4})\\s+)?(?P<hour>\\d{1,2}):(?P<minute>\\d{2})\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)",
+      "timezone": "local"
+    },
+    {
+      "name": "Codex-style relative usage limit",
+      "regex": "You[\\u2019']?ve\\s+hit\\s+your\\s+usage\\s+limit.{0,200}?try\\s+again\\s+in\\s+(?=\\d+\\s*(?:d(?:ays?)?|h(?:(?:ou)?rs?)?|m(?:in(?:ute)?s?)?|s(?:ec(?:ond)?s?))\\b)(?:(?P<rel_days>\\d+)\\s*d(?:ays?)?\\b)?[,\\s]*(?:(?P<rel_hours>\\d+)\\s*h(?:(?:ou)?rs?)?\\b)?[,\\s]*(?:(?P<rel_minutes>\\d+)\\s*m(?:in(?:ute)?s?)?\\b)?[,\\s]*(?:(?P<rel_seconds>\\d+)\\s*s(?:ec(?:ond)?s?)?\\b)?",
+      "max_ahead_hours": 192
     }
   ],
   "runners": {
@@ -248,6 +295,9 @@ Example:
     },
     "cc": {
       "fallback": ["{runner}", "{args}", "-c", "-p", "{message}"]
+    },
+    "codex": {
+      "fallback": ["{runner}", "exec", "resume", "--last", "{message}"]
     }
   }
 }
@@ -259,7 +309,12 @@ Settings:
 - `max_schedule_ahead_hours`: a parsed reset time further ahead than this is treated as stale scrollback text and ignored (date-carrying patterns are allowed up to 8 days). This prevents an already-handled message from re-scheduling a next-day send.
 - `max_fallback_wait_hours`: upper bound on how long the post-exit fallback will wait for a reset.
 
-A `config.json` that still contains the v0.1 default pattern is upgraded to the current defaults automatically on the next run (custom patterns are left untouched).
+Per-pattern settings:
+
+- `timezone`: timezone assumed when the message itself does not name one. Accepts an IANA name, an abbreviation, an offset, or the special value `local` (this machine's timezone). Used by the codex patterns because codex prints local wall-clock times.
+- `max_ahead_hours`: raises the stale ceiling for this pattern (used by the relative codex pattern so weekly limits up to 8 days out can be scheduled).
+
+A `config.json` from an earlier release is upgraded automatically on the next run: the v0.1 default pattern is replaced, configs that still carry the shipped Claude patterns gain the codex patterns, and the shipped Codex relative pattern is updated when needed. Custom patterns are left untouched.
 
 ### Custom runner fallback
 
@@ -286,13 +341,18 @@ For commands with complex spacing, prefer JSON array templates instead of string
 
 ### Custom limit patterns
 
-Patterns are Python regular expressions. A pattern must provide these captures, either by name or by positional group:
+Patterns are Python regular expressions. For wall-clock reset times, a pattern must provide these captures:
 
 - `hour`, required
 - `minute`, optional
 - `ampm`, optional; omit it to accept 24-hour clocks
-- `tzname`, optional; an IANA name (`Asia/Seoul`), a common abbreviation (`KST`, `PST`, ...), or an offset (`UTC+9`); unknown names fall back to `default_timezone` and are logged
+- `tzname`, optional; an IANA name (`Asia/Seoul`), a common abbreviation (`KST`, `PST`, ...), an offset (`UTC+9`), or `local`; unknown names fall back to `default_timezone` and are logged. When the message has no timezone at all, the pattern's `timezone` setting applies, then `default_timezone`.
 - `month` / `day`, optional named groups for date-carrying messages such as `resets Jul 8 at 10:59am`
+- `year`, optional named group for messages that state the year explicitly, such as codex's `try again at Jul 8th, 2026 10:59 AM.`
+
+For relative reset times (`try again in 4 days 23 hours`), provide one or more of the named groups `rel_days`, `rel_hours`, `rel_minutes`, `rel_seconds` instead; the reset time is computed from the moment the message is seen.
+
+Positional groups (1=hour, 2=minute, 3=ampm, 4=tzname) are still accepted, but only for patterns that use no named groups at all.
 
 Named captures are recommended. Keep the gap between the anchor text and the time bounded (for example `.{0,120}?` instead of `.*?`) so unrelated output cannot bridge a match:
 

package/lib/autolimit.py

@@ -34,7 +34,11 @@ try:
 except Exception:  # pragma: no cover - Python < 3.9 guard
     ZoneInfo = None  # type: ignore
 
-VERSION = "0.2.0"
+VERSION = "0.3.0"
+
+# Bumped when the shipped default patterns change; config files with an older
+# version are upgraded in place by migrate_legacy_patterns().
+CONFIG_VERSION = 3
 
 DEFAULT_CONFIG_DIR = Path.home() / ".config" / "autolimit"
 CONFIG_DIR = Path(os.environ.get("AUTOLIMIT_CONFIG_DIR", str(DEFAULT_CONFIG_DIR))).expanduser()
@@ -117,24 +121,84 @@ DEFAULT_PATTERN_DATED = (
     r"(?P<ampm>[aApP]\.?[mM]\.?)?\s*\((?P<tzname>[^)]{1,64})\)"
 )
 
+# Codex prints reset times in the machine's local time and never names the
+# timezone (codex-rs protocol/src/error.rs). Same-day resets look like
+# "You've hit your usage limit. Try again at 7:30 PM." and other days like
+# "... or try again at Jul 8th, 2026 10:59 AM.". The gap allows the plan or
+# promo copy between the two anchors ("Upgrade to Pro (...), visit ... or").
+DEFAULT_PATTERN_CODEX = (
+    r"You[\u2019']?ve\s+hit\s+your\s+usage\s+limit.{0,200}?"
+    r"try\s+again\s+at\s+(?P<hour>\d{1,2}):(?P<minute>\d{2})\s*(?P<ampm>[aApP]\.?[mM]\.?)"
+)
+
+DEFAULT_PATTERN_CODEX_DATED = (
+    r"You[\u2019']?ve\s+hit\s+your\s+usage\s+limit.{0,200}?"
+    r"try\s+again\s+at\s+(?P<month>[A-Za-z]{3,9})\.?\s+(?P<day>\d{1,2})(?:st|nd|rd|th)?,?\s*"
+    r"(?:(?P<year>\d{4})\s+)?"
+    r"(?P<hour>\d{1,2}):(?P<minute>\d{2})\s*(?P<ampm>[aApP]\.?[mM]\.?)"
+)
+
+# Older codex builds phrased the reset relatively: "try again in 4 days
+# 23 hours". The reset time is computed from the moment the message is seen.
+OLD_DEFAULT_PATTERN_CODEX_RELATIVE = (
+    r"You[\u2019']?ve\s+hit\s+your\s+usage\s+limit.{0,200}?"
+    r"try\s+again\s+in\s+(?=\d)"
+    r"(?:(?P<rel_days>\d+)\s*d(?:ays?)?)?[,\s]*"
+    r"(?:(?P<rel_hours>\d+)\s*h(?:(?:ou)?rs?)?)?[,\s]*"
+    r"(?:(?P<rel_minutes>\d+)\s*m(?:in(?:ute)?s?)?)?[,\s]*"
+    r"(?:(?P<rel_seconds>\d+)\s*s(?:ec(?:ond)?s?)?)?"
+)
+
+DEFAULT_PATTERN_CODEX_RELATIVE = (
+    r"You[\u2019']?ve\s+hit\s+your\s+usage\s+limit.{0,200}?"
+    r"try\s+again\s+in\s+(?=\d+\s*(?:d(?:ays?)?|h(?:(?:ou)?rs?)?|m(?:in(?:ute)?s?)?|s(?:ec(?:ond)?s?))\b)"
+    r"(?:(?P<rel_days>\d+)\s*d(?:ays?)?\b)?[,\s]*"
+    r"(?:(?P<rel_hours>\d+)\s*h(?:(?:ou)?rs?)?\b)?[,\s]*"
+    r"(?:(?P<rel_minutes>\d+)\s*m(?:in(?:ute)?s?)?\b)?[,\s]*"
+    r"(?:(?P<rel_seconds>\d+)\s*s(?:ec(?:ond)?s?)?\b)?"
+)
+
+# Optional per-pattern settings carried alongside the regex in config.json.
+PATTERN_META_KEYS = ("timezone", "max_ahead_hours")
+
+_CLAUDE_DEFAULT_PATTERNS: list[dict[str, Any]] = [
+    {
+        "name": "Claude-style session limit",
+        "regex": DEFAULT_PATTERN,
+    },
+    {
+        "name": "Claude-style dated limit",
+        "regex": DEFAULT_PATTERN_DATED,
+    },
+]
+
+_CODEX_DEFAULT_PATTERNS: list[dict[str, Any]] = [
+    {
+        "name": "Codex-style usage limit",
+        "regex": DEFAULT_PATTERN_CODEX,
+        "timezone": "local",
+    },
+    {
+        "name": "Codex-style dated usage limit",
+        "regex": DEFAULT_PATTERN_CODEX_DATED,
+        "timezone": "local",
+    },
+    {
+        "name": "Codex-style relative usage limit",
+        "regex": DEFAULT_PATTERN_CODEX_RELATIVE,
+        "max_ahead_hours": DATED_MAX_SCHEDULE_AHEAD_HOURS,
+    },
+]
+
 DEFAULT_CONFIG: dict[str, Any] = {
-    "version": 1,
+    "version": CONFIG_VERSION,
     "message_file": str(MESSAGE_FILE),
     "log_file": str(LOG_FILE),
     "default_timezone": DEFAULT_TZ_NAME,
     "send_grace_seconds": DEFAULT_SEND_GRACE_SECONDS,
     "max_schedule_ahead_hours": DEFAULT_MAX_SCHEDULE_AHEAD_HOURS,
     "max_fallback_wait_hours": DEFAULT_MAX_FALLBACK_WAIT_HOURS,
-    "patterns": [
-        {
-            "name": "Claude-style session limit",
-            "regex": DEFAULT_PATTERN,
-        },
-        {
-            "name": "Claude-style dated limit",
-            "regex": DEFAULT_PATTERN_DATED,
-        },
-    ],
+    "patterns": _CLAUDE_DEFAULT_PATTERNS + _CODEX_DEFAULT_PATTERNS,
     "runners": {
         # Fallback is only used when the wrapped process exits after printing a
         # limit message. For Claude Code style runners, `-c -p <message>` resumes
@@ -145,6 +209,12 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "cc": {
             "fallback": ["{runner}", "{args}", "-c", "-p", "{message}"],
         },
+        # `codex exec resume --last <prompt>` resumes the most recent codex
+        # session non-interactively. Original TUI arguments are intentionally
+        # not re-inserted: they are not all valid for `codex exec`.
+        "codex": {
+            "fallback": ["{runner}", "exec", "resume", "--last", "{message}"],
+        },
     },
 }
 
@@ -244,22 +314,69 @@ def _normalized_regex(value: Any) -> str:
     return str(value).replace("’", "\\u2019")
 
 
+def _pattern_regex(item: Any) -> Optional[str]:
+    regex = item.get("regex") if isinstance(item, dict) else item
+    return regex if isinstance(regex, str) and regex.strip() else None
+
+
 def migrate_legacy_patterns(loaded: dict[str, Any]) -> bool:
-    patterns = loaded.get("patterns")
-    if not isinstance(patterns, list):
-        return False
-    old_norm = _normalized_regex(OLD_DEFAULT_PATTERN)
+    """Upgrade shipped default patterns from earlier releases in place.
+
+    The v0.1 default pattern is replaced with the full current default set.
+    Older configs that still carry shipped default patterns gain the codex
+    patterns and the bounded codex relative-duration units. Custom patterns are
+    never modified.
+    Returns True when `loaded` changed and should be rewritten to disk.
+    """
     changed = False
-    migrated: list[Any] = []
-    for item in patterns:
-        regex = item.get("regex") if isinstance(item, dict) else item
-        if isinstance(regex, str) and _normalized_regex(regex) == old_norm:
-            migrated.extend(json.loads(json.dumps(DEFAULT_CONFIG["patterns"])))
-            changed = True
-        else:
-            migrated.append(item)
-    if changed:
-        loaded["patterns"] = migrated
+    patterns = loaded.get("patterns")
+
+    if isinstance(patterns, list):
+        old_norm = _normalized_regex(OLD_DEFAULT_PATTERN)
+        old_codex_relative_norm = _normalized_regex(OLD_DEFAULT_PATTERN_CODEX_RELATIVE)
+        replaced = False
+        migrated: list[Any] = []
+        for item in patterns:
+            regex = _pattern_regex(item)
+            regex_norm = _normalized_regex(regex) if regex is not None else None
+            if regex_norm == old_norm:
+                if not replaced:
+                    migrated.extend(json.loads(json.dumps(DEFAULT_CONFIG["patterns"])))
+                    replaced = True
+                changed = True
+            elif regex_norm == old_codex_relative_norm:
+                if isinstance(item, dict):
+                    updated = dict(item)
+                    updated["regex"] = DEFAULT_PATTERN_CODEX_RELATIVE
+                    migrated.append(updated)
+                else:
+                    migrated.append(DEFAULT_PATTERN_CODEX_RELATIVE)
+                changed = True
+            else:
+                migrated.append(item)
+        if changed:
+            loaded["patterns"] = migrated
+            patterns = migrated
+
+    try:
+        config_version = int(loaded.get("version") or 1)
+    except (TypeError, ValueError):
+        config_version = 1
+
+    if config_version < CONFIG_VERSION:
+        if isinstance(patterns, list):
+            norms = {
+                _normalized_regex(regex)
+                for regex in (_pattern_regex(item) for item in patterns)
+                if regex is not None
+            }
+            has_claude_default = _normalized_regex(DEFAULT_PATTERN) in norms
+            has_codex_default = _normalized_regex(DEFAULT_PATTERN_CODEX) in norms
+            if has_claude_default and not has_codex_default:
+                loaded["patterns"] = list(patterns) + json.loads(json.dumps(_CODEX_DEFAULT_PATTERNS))
+        loaded["version"] = CONFIG_VERSION
+        changed = True
+
     return changed
 
 
@@ -275,23 +392,51 @@ def load_config() -> dict[str, Any]:
                         json.dumps(loaded, ensure_ascii=False, indent=2) + "\n",
                         encoding="utf-8",
                     )
-                    log(f"Upgraded legacy default limit pattern in {CONFIG_FILE}.")
+                    log(f"Upgraded default limit patterns in {CONFIG_FILE}.")
                 except Exception:
-                    log(f"Upgraded legacy default limit pattern in memory only; could not rewrite {CONFIG_FILE}.")
+                    log(f"Upgraded default limit patterns in memory only; could not rewrite {CONFIG_FILE}.")
             cfg = deep_merge(cfg, loaded)
     except Exception as exc:
         log(f"Failed to read config file {CONFIG_FILE}: {exc}; using defaults.")
     return cfg
 
 
+def _system_local_tz():
+    """Timezone of this machine, as a real zone when discoverable.
+
+    Used for limit messages that state a wall-clock time without naming a
+    timezone (codex formats reset times with the machine's local clock).
+    """
+    if ZoneInfo is not None:
+        env_tz = (os.environ.get("TZ") or "").strip()
+        if env_tz:
+            try:
+                return ZoneInfo(env_tz)
+            except Exception:
+                # A POSIX-style TZ string; the astimezone() fallback honors it.
+                return datetime.now().astimezone().tzinfo or timezone.utc
+        try:
+            localtime = os.path.realpath("/etc/localtime")
+            marker = "zoneinfo/"
+            idx = localtime.rfind(marker)
+            if idx != -1:
+                return ZoneInfo(localtime[idx + len(marker):])
+        except Exception:
+            pass
+    return datetime.now().astimezone().tzinfo or timezone.utc
+
+
 def _tz_from_name(name: str):
     """Best-effort tzinfo for an IANA name, common abbreviation, or UTC offset.
 
+    The special names "local" and "system" resolve to this machine's timezone.
     Returns None when the name is unrecognized.
     """
     name = (name or "").strip()
     if not name:
         return None
+    if name.lower() in {"local", "system"}:
+        return _system_local_tz()
     if ZoneInfo is None:
         raise RuntimeError("Python 3.9+ is required because autolimit uses zoneinfo.")
     try:
@@ -415,31 +560,79 @@ def _month_number(token: str) -> int:
     raise ValueError(f"unrecognized month name {token!r}")
 
 
-def parse_reset_at(match: re.Match[str], cfg: dict[str, Any], now: Optional[datetime] = None) -> datetime:
+def parse_reset_at(
+    match: re.Match[str],
+    cfg: dict[str, Any],
+    now: Optional[datetime] = None,
+    pattern_meta: Optional[dict[str, Any]] = None,
+) -> datetime:
     gd = match.groupdict()
+    meta = pattern_meta if isinstance(pattern_meta, dict) else {}
+    # The positional-group fallback exists for patterns written entirely
+    # without named groups; a partially named pattern must not have its
+    # remaining fields misread from unrelated positional groups.
+    use_positional = not gd
 
     def get_group(name: str, index: int, default: Optional[str] = None) -> Optional[str]:
         value = gd.get(name)
         if value not in {None, ""}:
             return value
-        try:
-            value = match.group(index)
-            if value not in {None, ""}:
-                return value
-        except Exception:
-            pass
+        if use_positional:
+            try:
+                value = match.group(index)
+                if value not in {None, ""}:
+                    return value
+            except Exception:
+                pass
         return default
 
+    max_ahead_hours = config_float(
+        cfg, "max_schedule_ahead_hours", "AUTOLIMIT_MAX_SCHEDULE_AHEAD_HOURS", DEFAULT_MAX_SCHEDULE_AHEAD_HOURS
+    )
+    pattern_max_ahead = meta.get("max_ahead_hours")
+    try:
+        if isinstance(pattern_max_ahead, (int, float, str)):
+            max_ahead_hours = max(max_ahead_hours, float(pattern_max_ahead))
+    except (TypeError, ValueError):
+        pass
+
+    def check_ahead(reset_at: datetime, reference: datetime, limit_hours: float) -> datetime:
+        ahead = reset_at - reference
+        if ahead > timedelta(hours=limit_hours):
+            raise ValueError(
+                f"parsed reset time {reset_at.isoformat(timespec='seconds')} is "
+                f"{ahead.total_seconds() / 3600:.1f}h ahead (max {limit_hours:g}h); ignoring as stale"
+            )
+        return reset_at
+
+    # Relative messages ("try again in 4 days 23 hours") count from the moment
+    # the message is seen, so no timezone or wall-clock work is needed.
+    rel_parts: dict[str, int] = {}
+    for unit in ("days", "hours", "minutes", "seconds"):
+        raw = gd.get(f"rel_{unit}")
+        if isinstance(raw, str) and raw:
+            rel_parts[unit] = int(raw)
+    if rel_parts:
+        if now is None:
+            now = datetime.now(_system_local_tz())
+        reset_at = (now + timedelta(**rel_parts)).replace(microsecond=0)
+        return check_ahead(reset_at, now, max_ahead_hours)
+
     hour_s = get_group("hour", 1)
     if hour_s is None:
-        raise ValueError("limit pattern matched but did not provide an hour group")
+        raise ValueError("limit pattern matched but provided neither an hour group nor a relative duration")
 
     hour = int(hour_s)
     minute = int(get_group("minute", 2, "0") or "0")
     ampm = (get_group("ampm", 3, "") or "").lower().replace(".", "")
-    tzname = (get_group("tzname", 4, default_tz_name(cfg)) or default_tz_name(cfg)).strip()
+    tzname = (get_group("tzname", 4) or "").strip()
+    if not tzname:
+        # Messages without a timezone (codex prints local wall-clock times) use
+        # the pattern's configured timezone, then the global default.
+        tzname = str(meta.get("timezone") or "").strip() or default_tz_name(cfg)
     month_s = gd.get("month")
     day_s = gd.get("day")
+    year_s = gd.get("year")
 
     if ampm:
         if ampm == "pm" and hour != 12:
@@ -450,15 +643,17 @@ def parse_reset_at(match: re.Match[str], cfg: dict[str, Any], now: Optional[date
     tz = resolve_timezone(tzname, cfg)
     now = datetime.now(tz) if now is None else now.astimezone(tz)
 
-    max_ahead_hours = config_float(
-        cfg, "max_schedule_ahead_hours", "AUTOLIMIT_MAX_SCHEDULE_AHEAD_HOURS", DEFAULT_MAX_SCHEDULE_AHEAD_HOURS
-    )
-
     if month_s and day_s:
         reset_at = now.replace(
             month=_month_number(month_s), day=int(day_s), hour=hour, minute=minute, second=0, microsecond=0
         )
-        if reset_at < now - RECENT_PAST_TOLERANCE:
+        if year_s:
+            reset_at = reset_at.replace(year=int(year_s))
+            if reset_at < now - RECENT_PAST_TOLERANCE:
+                raise ValueError(
+                    f"parsed reset time {reset_at.isoformat(timespec='seconds')} is in the past; ignoring as stale"
+                )
+        elif reset_at < now - RECENT_PAST_TOLERANCE:
             reset_at = reset_at.replace(year=reset_at.year + 1)
         max_ahead_hours = max(max_ahead_hours, DATED_MAX_SCHEDULE_AHEAD_HOURS)
     else:
@@ -471,14 +666,7 @@ def parse_reset_at(match: re.Match[str], cfg: dict[str, Any], now: Optional[date
     # A same-day limit never resets further ahead than a few hours; anything
     # beyond the window is stale text (for example an old message re-fed from
     # scrollback whose time already passed and rolled over to tomorrow).
-    ahead = reset_at - now
-    if ahead > timedelta(hours=max_ahead_hours):
-        raise ValueError(
-            f"parsed reset time {reset_at.isoformat(timespec='seconds')} is "
-            f"{ahead.total_seconds() / 3600:.1f}h ahead (max {max_ahead_hours:g}h); ignoring as stale"
-        )
-
-    return reset_at
+    return check_ahead(reset_at, now, max_ahead_hours)
 
 
 class LimitScanner:
@@ -489,7 +677,7 @@ class LimitScanner:
         self.entries: dict[str, dict[str, Any]] = {}
         self.scheduled_ts: set[int] = set()
         self.jobs: list[ScheduledJob] = []
-        self.patterns: list[tuple[str, re.Pattern[str]]] = []
+        self.patterns: list[tuple[str, re.Pattern[str], dict[str, Any]]] = []
         self._compile_patterns()
 
     def _compile_patterns(self) -> None:
@@ -497,33 +685,40 @@ class LimitScanner:
         if not isinstance(raw_patterns, list) or not raw_patterns:
             raw_patterns = DEFAULT_CONFIG["patterns"]
 
-        for idx, item in enumerate(raw_patterns):
-            if isinstance(item, str):
-                name = f"pattern #{idx + 1}"
-                regex = item
-            elif isinstance(item, dict):
-                name = str(item.get("name") or f"pattern #{idx + 1}")
-                regex = item.get("regex")
-            else:
-                continue
+        def add_from(items: list[Any]) -> None:
+            for idx, item in enumerate(items):
+                meta: dict[str, Any] = {}
+                if isinstance(item, str):
+                    name = f"pattern #{idx + 1}"
+                    regex = item
+                elif isinstance(item, dict):
+                    name = str(item.get("name") or f"pattern #{idx + 1}")
+                    regex = item.get("regex")
+                    meta = {k: item[k] for k in PATTERN_META_KEYS if item.get(k) not in {None, ""}}
+                else:
+                    continue
 
-            if not isinstance(regex, str) or not regex.strip():
-                continue
-            try:
-                self.patterns.append((name, re.compile(regex, re.IGNORECASE | re.DOTALL)))
-            except re.error as exc:
-                log(f"Ignoring invalid regex pattern {name!r}: {exc}", self.cfg)
+                if not isinstance(regex, str) or not regex.strip():
+                    continue
+                try:
+                    self.patterns.append((name, re.compile(regex, re.IGNORECASE | re.DOTALL), meta))
+                except re.error as exc:
+                    log(f"Ignoring invalid regex pattern {name!r}: {exc}", self.cfg)
 
-        if not self.patterns:
-            self.patterns.append(("default Claude-style session limit", re.compile(DEFAULT_PATTERN, re.IGNORECASE | re.DOTALL)))
-            self.patterns.append(("default Claude-style dated limit", re.compile(DEFAULT_PATTERN_DATED, re.IGNORECASE | re.DOTALL)))
+        add_from(raw_patterns)
+        if not self.patterns and raw_patterns is not DEFAULT_CONFIG["patterns"]:
+            add_from(DEFAULT_CONFIG["patterns"])
 
     @staticmethod
     def _match_key(pattern_name: str, gd: dict[str, Any]) -> str:
         # Built from the captured components (not the raw matched text, which
         # varies across TUI repaints, and not the computed timestamp, which
         # changes once the reset time passes).
-        parts = [pattern_name] + [str(gd.get(k) or "") for k in ("month", "day", "hour", "minute", "ampm", "tzname")]
+        keys = (
+            "month", "day", "year", "hour", "minute", "ampm", "tzname",
+            "rel_days", "rel_hours", "rel_minutes", "rel_seconds",
+        )
+        parts = [pattern_name] + [str(gd.get(k) or "") for k in keys]
         return "|".join(parts)
 
     def feed(self, data: bytes) -> list[ScheduledJob]:
@@ -534,12 +729,12 @@ class LimitScanner:
 
         now = time.time()
         new_jobs: list[ScheduledJob] = []
-        for pattern_name, pattern in self.patterns:
+        for pattern_name, pattern, meta in self.patterns:
             for match in pattern.finditer(self.buffer):
                 key = self._match_key(pattern_name, match.groupdict())
                 entry = self.entries.get(key)
                 if entry is None:
-                    self._schedule_new(key, pattern_name, match, new_jobs)
+                    self._schedule_new(key, pattern_name, match, new_jobs, meta)
                 elif entry["state"] == "fired":
                     self._maybe_retry(key, entry, pattern_name, now, new_jobs)
                 # pending/failed/dropped entries need no further action.
@@ -548,9 +743,16 @@ class LimitScanner:
             self.jobs.sort(key=lambda job: job.timestamp)
         return new_jobs
 
-    def _schedule_new(self, key: str, pattern_name: str, match: re.Match[str], out: list[ScheduledJob]) -> None:
+    def _schedule_new(
+        self,
+        key: str,
+        pattern_name: str,
+        match: re.Match[str],
+        out: list[ScheduledJob],
+        meta: Optional[dict[str, Any]] = None,
+    ) -> None:
         try:
-            reset_at = parse_reset_at(match, self.cfg)
+            reset_at = parse_reset_at(match, self.cfg, pattern_meta=meta)
         except Exception as exc:
             self.entries[key] = {"state": "dropped"}
             log(f"Ignoring limit match via {pattern_name!r}: {exc}", self.cfg)
@@ -1056,6 +1258,7 @@ def print_help() -> None:
 Usage:
   autolimit --cc [args...]              Wrap command `cc [args...]`
   autolimit --claude [args...]          Wrap command `claude [args...]`
+  autolimit --codex [args...]           Wrap command `codex [args...]`
   autolimit <command> [args...]         Wrap an explicit command
   autolimit -- <command> [args...]      Wrap a command when you want exact parsing
 
@@ -1076,6 +1279,7 @@ Examples:
   autolimit --cc
   autolimit --cc --model sonnet
   autolimit --claude --dangerously-skip-permissions
+  autolimit --codex
   autolimit --direct --python3 my_repl.py
   autolimit -- npx some-runner --flag
 
@@ -1131,6 +1335,21 @@ def test_parser(cfg: dict[str, Any]) -> int:
     month = _MONTHS[dated.month - 1].capitalize()
     tzn = default_tz_name(cfg)
 
+    # Codex prints reset times using the machine's local clock.
+    local_now = datetime.now(_system_local_tz())
+    codex_soon = local_now + timedelta(hours=2)
+    codex_dated = local_now + timedelta(days=3)
+    codex_month = _MONTHS[codex_dated.month - 1].capitalize()
+
+    def codex_clock(dt: datetime) -> str:
+        hour = dt.hour % 12 or 12
+        return f"{hour}:{dt.minute:02d} {'AM' if dt.hour < 12 else 'PM'}"
+
+    def day_suffix(day: int) -> str:
+        if 11 <= day <= 13:
+            return "th"
+        return {1: "st", 2: "nd", 3: "rd"}.get(day % 10, "th")
+
     # (example line, should it schedule a job?)
     examples = [
         (f"You've hit your session limit · resets {clock(soon)} ({tzn})", True),
@@ -1138,6 +1357,18 @@ def test_parser(cfg: dict[str, Any]) -> int:
         (f"You've hit your session limit · resets {clock(soon, ampm=False)} ({tzn})", True),
         (f"You've hit your weekly limit · resets {month} {dated.day} at {clock(dated)} ({tzn})", True),
         (f"You've hit your session limit · resets {clock(now - timedelta(hours=3))} ({tzn})", False),
+        (f"You've hit your usage limit. Try again at {codex_clock(codex_soon)}.", True),
+        (
+            "You've hit your usage limit. Upgrade to Pro (https://chatgpt.com/explore/pro), "
+            "visit https://chatgpt.com/codex/settings/usage to purchase more credits or try again at "
+            f"{codex_month} {codex_dated.day}{day_suffix(codex_dated.day)}, {codex_dated.year} {codex_clock(codex_dated)}.",
+            True,
+        ),
+        ("You've hit your usage limit. Try again in 3 hours 26 minutes.", True),
+        ("You've hit your usage limit. Try again in 2 months.", False),
+        ("You've hit your usage limit. Try again in 500ms.", False),
+        ("You've hit your usage limit. Try again later.", False),
+        (f"You've hit your usage limit. Try again at {codex_clock(local_now - timedelta(hours=3))}.", False),
     ]
 
     ok = True

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "autolimit",
-  "version": "0.2.0",
-  "description": "Terminal-agnostic PTY wrapper that resumes CLI runners after reset-time usage limits.",
+  "version": "0.3.0",
+  "description": "Terminal-agnostic PTY wrapper that resumes CLI runners (Claude Code, Codex, ...) after reset-time usage limits.",
   "repository": {
     "type": "git",
     "url": "https://github.com/betive37/autolimit"
@@ -12,13 +12,14 @@
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
     "prepublishOnly": "npm test",
-    "test": "python3 tests/test_autolimit.py && node tests/test_postinstall_star.js && node bin/autolimit.js --test-parser && node bin/autolimit.js --dry-run --cc --example"
+    "test": "python3 tests/test_autolimit.py && node tests/test_postinstall_star.js && node bin/autolimit.js --test-parser && node bin/autolimit.js --dry-run --cc --example && node bin/autolimit.js --dry-run --codex"
   },
   "keywords": [
     "terminal",
     "pty",
     "automation",
     "claude-code",
+    "codex",
     "wrapper"
   ],
   "author": "Jae Hyun <betive37@gmail.com>",

package/scripts/postinstall.js

@@ -19,9 +19,13 @@ const localBin = path.join(home, '.local', 'bin');
 const symlink = path.join(localBin, 'autolimit');
 
 const defaultMessage = '이어서 계속 진행해줘.\n';
-// Keep in sync with DEFAULT_PATTERN / DEFAULT_PATTERN_DATED in lib/autolimit.py.
+// Keep in sync with the DEFAULT_PATTERN* constants and CONFIG_VERSION in lib/autolimit.py.
+const configVersion = 3;
 const defaultPatternTime = "You[\\u2019']?ve\\s+hit\\s+your(?:\\s+[\\w-]+)?\\s+limit.{0,120}?resets\\s+(?P<hour>\\d{1,2})(?::(?P<minute>\\d{2}))?\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)?\\s*\\((?P<tzname>[^)]{1,64})\\)";
 const defaultPatternDated = "You[\\u2019']?ve\\s+hit\\s+your(?:\\s+[\\w-]+)?\\s+limit.{0,120}?resets\\s+(?P<month>[A-Za-z]{3,9})\\.?\\s+(?P<day>\\d{1,2})(?:st|nd|rd|th)?,?\\s*(?:at\\s+)?(?P<hour>\\d{1,2})(?::(?P<minute>\\d{2}))?\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)?\\s*\\((?P<tzname>[^)]{1,64})\\)";
+const defaultPatternCodex = "You[\\u2019']?ve\\s+hit\\s+your\\s+usage\\s+limit.{0,200}?try\\s+again\\s+at\\s+(?P<hour>\\d{1,2}):(?P<minute>\\d{2})\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)";
+const defaultPatternCodexDated = "You[\\u2019']?ve\\s+hit\\s+your\\s+usage\\s+limit.{0,200}?try\\s+again\\s+at\\s+(?P<month>[A-Za-z]{3,9})\\.?\\s+(?P<day>\\d{1,2})(?:st|nd|rd|th)?,?\\s*(?:(?P<year>\\d{4})\\s+)?(?P<hour>\\d{1,2}):(?P<minute>\\d{2})\\s*(?P<ampm>[aApP]\\.?[mM]\\.?)";
+const defaultPatternCodexRelative = "You[\\u2019']?ve\\s+hit\\s+your\\s+usage\\s+limit.{0,200}?try\\s+again\\s+in\\s+(?=\\d+\\s*(?:d(?:ays?)?|h(?:(?:ou)?rs?)?|m(?:in(?:ute)?s?)?|s(?:ec(?:ond)?s?))\\b)(?:(?P<rel_days>\\d+)\\s*d(?:ays?)?\\b)?[,\\s]*(?:(?P<rel_hours>\\d+)\\s*h(?:(?:ou)?rs?)?\\b)?[,\\s]*(?:(?P<rel_minutes>\\d+)\\s*m(?:in(?:ute)?s?)?\\b)?[,\\s]*(?:(?P<rel_seconds>\\d+)\\s*s(?:ec(?:ond)?s?)?\\b)?";
 
 function chmodX(file) {
   try {
@@ -53,7 +57,7 @@ function ensureConfigFile() {
   ensureDir(configDir);
   if (fs.existsSync(configFile)) return;
   const config = {
-    version: 1,
+    version: configVersion,
     message_file: messageFile,
     log_file: path.join(configDir, 'limit-watch.log'),
     default_timezone: 'Asia/Seoul',
@@ -68,6 +72,21 @@ function ensureConfigFile() {
       {
         name: 'Claude-style dated limit',
         regex: defaultPatternDated
+      },
+      {
+        name: 'Codex-style usage limit',
+        regex: defaultPatternCodex,
+        timezone: 'local'
+      },
+      {
+        name: 'Codex-style dated usage limit',
+        regex: defaultPatternCodexDated,
+        timezone: 'local'
+      },
+      {
+        name: 'Codex-style relative usage limit',
+        regex: defaultPatternCodexRelative,
+        max_ahead_hours: 192
       }
     ],
     runners: {
@@ -76,6 +95,9 @@ function ensureConfigFile() {
       },
       cc: {
         fallback: ['{runner}', '{args}', '-c', '-p', '{message}']
+      },
+      codex: {
+        fallback: ['{runner}', 'exec', 'resume', '--last', '{message}']
       }
     }
   };
@@ -115,7 +137,7 @@ async function main() {
   ensureConfigFile();
   ensureSymlink();
 
-  console.log('[autolimit] Installed. Try: autolimit --cc');
+  console.log('[autolimit] Installed. Try: autolimit --cc  or  autolimit --codex');
   console.log(`[autolimit] Message file: ${messageFile}`);
   console.log(`[autolimit] Config file:  ${configFile}`);
   console.log(`[autolimit] PATH helper:  ${symlink}`);