codex-statusline 0.2.2__tar.gz → 0.3.1__tar.gz

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-statusline
-Version: 0.2.2
+Version: 0.3.1
 Summary: A tmux statusline for OpenAI Codex CLI: context usage, 5h and weekly quota, and session tokens at a glance. Local-only.
 Author: Zimo Xu
 License-Expression: MIT
@@ -59,7 +59,7 @@ Prefer to do it yourself:
 
 ```sh
 uv tool install codex-statusline    # or: pipx install codex-statusline
-codex-statusline install            # add --dry-run to see the plan first
+cxbar install                       # add --dry-run to see the plan first
 ```
 
 Then **open a new terminal** and run `codex`. The first time, Codex asks you to review a hook: confirm it is `codex-statusline binding`.
@@ -73,17 +73,19 @@ codex                     # same as always, now with a status bar
 codex resume --last
 codex exec 'task'         # non-interactive: passed straight through, no bar
 
-codex-statusline config   # pick segments, theme and colors interactively
-codex-statusline update   # upgrade, whichever way you installed it
-codex-statusline doctor   # check versions and dependencies
-codex-statusline uninstall
+cxbar config              # pick segments, theme and colors interactively
+cxbar update              # upgrade, whichever way you installed it
+cxbar doctor              # check your setup; prints the fix for anything wrong
+cxbar uninstall
 ```
 
+`cxbar` is the short name for `codex-statusline`; both work.
+
 Uninstall removes only what this tool added and still matches exactly. If you edited its block, it stops instead of overwriting. Backups live in `~/.local/share/codex-statusline/`.
 
 ## Configuration
 
-Run `codex-statusline config` to set everything up in an interactive screen with a live preview: toggle and reorder segments, switch theme, set the warning thresholds, then press `s` to save.
+Run `cxbar config` to set everything up in an interactive screen with a live preview: toggle and reorder segments, switch theme, set the warning thresholds, then press `s` to save.
 
 ```text
   [x] ctx     context used

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/README.md

@@ -38,7 +38,7 @@ Prefer to do it yourself:
 
 ```sh
 uv tool install codex-statusline    # or: pipx install codex-statusline
-codex-statusline install            # add --dry-run to see the plan first
+cxbar install                       # add --dry-run to see the plan first
 ```
 
 Then **open a new terminal** and run `codex`. The first time, Codex asks you to review a hook: confirm it is `codex-statusline binding`.
@@ -52,17 +52,19 @@ codex                     # same as always, now with a status bar
 codex resume --last
 codex exec 'task'         # non-interactive: passed straight through, no bar
 
-codex-statusline config   # pick segments, theme and colors interactively
-codex-statusline update   # upgrade, whichever way you installed it
-codex-statusline doctor   # check versions and dependencies
-codex-statusline uninstall
+cxbar config              # pick segments, theme and colors interactively
+cxbar update              # upgrade, whichever way you installed it
+cxbar doctor              # check your setup; prints the fix for anything wrong
+cxbar uninstall
 ```
 
+`cxbar` is the short name for `codex-statusline`; both work.
+
 Uninstall removes only what this tool added and still matches exactly. If you edited its block, it stops instead of overwriting. Backups live in `~/.local/share/codex-statusline/`.
 
 ## Configuration
 
-Run `codex-statusline config` to set everything up in an interactive screen with a live preview: toggle and reorder segments, switch theme, set the warning thresholds, then press `s` to save.
+Run `cxbar config` to set everything up in an interactive screen with a live preview: toggle and reorder segments, switch theme, set the warning thresholds, then press `s` to save.
 
 ```text
   [x] ctx     context used

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/codex_statusline.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-statusline
-Version: 0.2.2
+Version: 0.3.1
 Summary: A tmux statusline for OpenAI Codex CLI: context usage, 5h and weekly quota, and session tokens at a glance. Local-only.
 Author: Zimo Xu
 License-Expression: MIT
@@ -59,7 +59,7 @@ Prefer to do it yourself:
 
 ```sh
 uv tool install codex-statusline    # or: pipx install codex-statusline
-codex-statusline install            # add --dry-run to see the plan first
+cxbar install                       # add --dry-run to see the plan first
 ```
 
 Then **open a new terminal** and run `codex`. The first time, Codex asks you to review a hook: confirm it is `codex-statusline binding`.
@@ -73,17 +73,19 @@ codex                     # same as always, now with a status bar
 codex resume --last
 codex exec 'task'         # non-interactive: passed straight through, no bar
 
-codex-statusline config   # pick segments, theme and colors interactively
-codex-statusline update   # upgrade, whichever way you installed it
-codex-statusline doctor   # check versions and dependencies
-codex-statusline uninstall
+cxbar config              # pick segments, theme and colors interactively
+cxbar update              # upgrade, whichever way you installed it
+cxbar doctor              # check your setup; prints the fix for anything wrong
+cxbar uninstall
 ```
 
+`cxbar` is the short name for `codex-statusline`; both work.
+
 Uninstall removes only what this tool added and still matches exactly. If you edited its block, it stops instead of overwriting. Backups live in `~/.local/share/codex-statusline/`.
 
 ## Configuration
 
-Run `codex-statusline config` to set everything up in an interactive screen with a live preview: toggle and reorder segments, switch theme, set the warning thresholds, then press `s` to save.
+Run `cxbar config` to set everything up in an interactive screen with a live preview: toggle and reorder segments, switch theme, set the warning thresholds, then press `s` to save.
 
 ```text
   [x] ctx     context used

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/codex_statusline.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/__main__.py
 src/cli.py
 src/configure.py
 src/data.py
+src/doctor.py
 src/entry.py
 src/hook.py
 src/launcher.py
@@ -20,6 +21,7 @@ src/update.py
 tests/test_auto_shells.py
 tests/test_configure.py
 tests/test_data.py
+tests/test_doctor.py
 tests/test_fish.py
 tests/test_management.py
 tests/test_render.py

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/codex_statusline.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 codex-statusline = src.cli:main
+cxbar = src.cli:main

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codex-statusline"
-version = "0.2.2"
+version = "0.3.1"
 description = "A tmux statusline for OpenAI Codex CLI: context usage, 5h and weekly quota, and session tokens at a glance. Local-only."
 requires-python = ">=3.11"
 license = "MIT"
@@ -23,6 +23,7 @@ Changelog = "https://github.com/Moviw/codex-statusline/blob/main/CHANGELOG.md"
 
 [project.scripts]
 codex-statusline = "src.cli:main"
+cxbar = "src.cli:main"  # short alias
 
 [build-system]
 requires = ["setuptools>=77"]

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/src/__init__.py

@@ -1,3 +1,3 @@
 """A local-only tmux status area for the official Codex CLI."""
 
-__version__ = "0.2.2"
+__version__ = "0.3.1"

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/src/cli.py

@@ -1,7 +1,4 @@
 import argparse
-import json
-import os
-import shutil
 import sys
 from pathlib import Path
 
@@ -10,7 +7,7 @@ from . import __version__
 
 def main():
     args = sys.argv[1:]
-    from .launcher import child, launch, official, raw, version
+    from .launcher import child, launch, raw
 
     if args and args[0] in ("launch", "raw"):
         try:
@@ -25,11 +22,11 @@ def main():
         record()
         return 0
     parser = argparse.ArgumentParser(
-        prog="codex-statusline",
+        prog="cxbar" if Path(sys.argv[0]).name == "cxbar" else "codex-statusline",
         description="A status bar for Codex CLI: context, 5h/weekly quota, and tokens. "
         "Run `codex` as usual once installed.",
     )
-    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument("-V", "-v", "--version", action="version", version=__version__)
     sub = parser.add_subparsers(dest="action", required=True, metavar="<command>", title="commands")
     commands = {
         "install": "hook the status bar into `codex` for your shells",
@@ -68,18 +65,9 @@ def main():
 
             return update()
         if ns.action == "doctor":
-            path = official()
-            data = {
-                "python": sys.version.split()[0],
-                "codex": path,
-                "codex_version": ".".join(map(str, version(path))),
-                "tmux": shutil.which("tmux"),
-                "shell": os.environ.get("SHELL"),
-                "tested_codex": "0.159.0",
-                "credentials_read": False,
-            }
-            print(json.dumps(data, indent=2))
-            return 0 if data["tmux"] and version(path) >= (0, 159, 0) else 1
+            from .doctor import doctor
+
+            return doctor()
     except (OSError, ValueError, RuntimeError, KeyError) as error:
         print(f"codex-statusline: {error}", file=sys.stderr)
         return 1

codex_statusline-0.3.1/src/doctor.py

@@ -0,0 +1,111 @@
+"""`cxbar doctor`: one line per check, and the command that fixes each problem."""
+
+import json
+import shutil
+import subprocess
+import tomllib
+from pathlib import Path
+
+from . import __version__
+from .launcher import official, version
+from .manage import STATUS_MESSAGE, hook_group, paths, text, tilde
+from .update import is_newer, latest_version
+
+
+def command_name() -> str:
+    return "cxbar" if shutil.which("cxbar") else "codex-statusline"
+
+
+def checks(home: Path, latest=latest_version) -> list[tuple[bool | None, str, str | None]]:
+    """(ok, message, fix): ok is True, False, or None for information only."""
+    cmd = command_name()
+    out = []
+    try:
+        found = version(official())
+        shown = ".".join(map(str, found))
+        out.append((found >= (0, 159, 0), f"Codex CLI {shown}", "upgrade Codex CLI to 0.159.0+"))
+    except (RuntimeError, OSError, subprocess.TimeoutExpired):
+        out.append((False, "Codex CLI not found on PATH", "install Codex CLI"))
+    tmux = shutil.which("tmux")
+    if tmux:
+        tmux_version = subprocess.run([tmux, "-V"], capture_output=True, text=True).stdout.strip()
+        out.append((True, tmux_version or "tmux", None))
+    else:
+        out.append((False, "tmux not found", "brew install tmux  /  sudo apt install tmux"))
+
+    codex_home, _, manifest_path = paths(home, "all")
+    try:
+        manifest = json.loads(text(manifest_path) or "{}")
+    except ValueError:
+        manifest = {}
+    if not manifest:
+        out.append((False, "not hooked into your shell yet", f"{cmd} install"))
+        return out + [_update_check(cmd, latest)]
+
+    if manifest.get("hook_group") != hook_group():
+        other = manifest["hook_group"]["hooks"][0]["command"].removesuffix(" hook")
+        out.append((False, f"codex runs another copy: {other}", f"{cmd} install"))
+    else:
+        shells = [Path(item["path"]) for item in manifest.get("shells", [])]
+        missing = [p for p in shells if item_block(manifest, p) not in text(p)]
+        names = ", ".join(tilde(p, home) for p in shells)
+        out.append((not missing, f"codex is hooked into {names}", f"{cmd} install"))
+
+    hooks_path = Path(manifest["hooks_path"])
+    try:
+        groups = json.loads(text(hooks_path) or "{}").get("hooks", {}).get("SessionStart", [])
+    except ValueError:
+        groups = []
+    index = next((i for i, g in enumerate(groups) if g == manifest["hook_group"]), None)
+    if index is None:
+        out.append((False, f"hook missing from {tilde(hooks_path, home)}", f"{cmd} install"))
+    else:
+        try:
+            state = (
+                tomllib.loads(text(codex_home / "config.toml")).get("hooks", {}).get("state", {})
+            )
+        except tomllib.TOMLDecodeError:
+            state = {}
+        # Codex keys trust by the hooks.json path as it sees it; compare resolved paths so a
+        # symlinked ~/.codex (or macOS /var -> /private/var) still matches.
+        suffix = f":session_start:{index}:0"
+        trusted = any(
+            key.endswith(suffix)
+            and Path(key.removesuffix(suffix)).resolve() == hooks_path.resolve()
+            and "trusted_hash" in value
+            for key, value in state.items()
+            if isinstance(value, dict)
+        )
+        out.append(
+            (True, "hook approved in Codex", None)
+            if trusted
+            else (
+                False,
+                "hook not approved in Codex yet",
+                f"start codex, approve '{STATUS_MESSAGE}'",
+            )
+        )
+    return out + [_update_check(cmd, latest)]
+
+
+def item_block(manifest: dict, path: Path) -> str:
+    return next(i["block"] for i in manifest["shells"] if Path(i["path"]) == path)
+
+
+def _update_check(cmd: str, latest) -> tuple[bool | None, str, str | None]:
+    found = latest()
+    if found is None:
+        return (None, "could not check for updates (offline?)", None)
+    if is_newer(found):
+        return (False, f"{found} available", f"{cmd} update")
+    return (True, "latest version", None)
+
+
+def doctor(home: Path | None = None) -> int:
+    results = checks(home or Path.home())
+    print(f"codex-statusline {__version__}")
+    for ok, message, fix in results:
+        print(f"  {'✓' if ok else '✗' if ok is False else '·'} {message}")
+        if ok is False and fix:
+            print(f"      → {fix}")
+    return 1 if any(ok is False for ok, _, _ in results) else 0

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/src/launcher.py

@@ -143,19 +143,6 @@ def binding_for(bindings, hint, launch_id):
     return candidates[0] if len(candidates) == 1 else None
 
 
-def branch(cwd):
-    try:
-        p = subprocess.run(
-            ["git", "-C", cwd, "symbolic-ref", "--quiet", "--short", "HEAD"],
-            capture_output=True,
-            text=True,
-            timeout=0.7,
-        )
-        return p.stdout.strip() if p.returncode == 0 else None
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-
-
 def placeholder(width=80):
     """Use the normal layout before telemetry arrives or while it is unavailable."""
     from .data import newest_quotas, sessions_dir
@@ -216,6 +203,10 @@ def launch(args):
         "set -g allow-rename off\n"
         "set -g set-titles off\n"
         "set -g mouse on\n"
+        # Every key belongs to Codex: no prefix (Ctrl-B), no wait after Esc.
+        "set -g prefix None\n"
+        "unbind C-b\n"
+        "set -s escape-time 10\n"
         "set -g history-limit 10000\n"
         "set -g remain-on-exit on\n"
         "set -g exit-empty on\n"
@@ -247,6 +238,7 @@ def launch(args):
         cfg = load_config()
         reader = LogReader()
         latest = {}
+        updater = "cxbar" if shutil.which("cxbar") else "codex-statusline"
         if cfg["update_check"]:
             from .update import newer_version
 
@@ -254,7 +246,6 @@ def launch(args):
                 target=lambda: latest.update(version=newer_version()), daemon=True
             ).start()
         sessions, readers, others, scan_at = sessions_dir(), {}, {}, 0.0
-        last_branch, branch_at = None, 0
         last_line = None
         while not stop.is_set():
             try:
@@ -290,9 +281,7 @@ def launch(args):
                     )
                 state["quotas"] = merge_quotas(state["quotas"], others)
                 state["update"] = latest.get("version")
-                if time.monotonic() - branch_at > 3:
-                    last_branch, branch_at = branch(state["cwd"]), time.monotonic()
-                state["branch"] = last_branch
+                state["updater"] = updater
                 line = render(
                     state,
                     int(width or 80),

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/src/render.py

@@ -278,7 +278,8 @@ def render(
     hint = None
     if isinstance(update, str) and re.fullmatch(r"\d+(\.\d+)*", update):
         arrow = "^" if ascii_only else "↑"
-        hint = (f"{arrow} update available: codex-statusline update", f"{arrow} update", "warning")
+        tool = "cxbar" if state.get("updater") == "cxbar" else "codex-statusline"
+        hint = (f"{arrow} update available: {tool} update", f"{arrow} update", "warning")
     head, rest = parts[0], parts[1:]
     compact_head = (head[1], head[2])
     # Widest first: all detail, compact head, all compact, then drop segments.

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/src/update.py

@@ -24,8 +24,8 @@ def is_newer(latest: str, current: str = __version__) -> bool:
     return bool(_parse(latest)) and _parse(latest) > _parse(current)
 
 
-def newer_version(timeout: float = 2) -> str | None:
-    """Latest release if newer than this one; None on any failure. Sends only a plain GET."""
+def latest_version(timeout: float = 2) -> str | None:
+    """Latest release on PyPI; None on any failure. Sends only a plain GET."""
     try:
         request = urllib.request.Request(
             PYPI, headers={"User-Agent": f"codex-statusline/{__version__}"}
@@ -34,7 +34,13 @@ def newer_version(timeout: float = 2) -> str | None:
             latest = json.load(response)["info"]["version"]
     except Exception:
         return None
-    return latest if isinstance(latest, str) and is_newer(latest) else None
+    return latest if isinstance(latest, str) else None
+
+
+def newer_version(timeout: float = 2) -> str | None:
+    """Latest release if newer than this one; None otherwise or on any failure."""
+    latest = latest_version(timeout)
+    return latest if latest and is_newer(latest) else None
 
 
 def upgrade_command(prefix: str = sys.prefix, package: Path = PACKAGE) -> list[str]:

codex_statusline-0.3.1/tests/test_doctor.py

@@ -0,0 +1,74 @@
+import argparse
+import contextlib
+import io
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from src import doctor, manage
+
+
+class DoctorTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        # A symlinked home, like macOS /var -> /private/var or a linked ~/.codex.
+        real = Path(self.temp.name) / "real"
+        real.mkdir()
+        self.home = Path(self.temp.name) / "link"
+        self.home.symlink_to(real)
+        env = {"CODEX_HOME": str(self.home / ".codex"), "ZDOTDIR": str(self.home)}
+        for p in (
+            patch.dict(os.environ, env),
+            patch.object(doctor, "official", return_value="/bin/codex"),
+            patch.object(doctor, "version", return_value=(0, 159, 0)),
+        ):
+            p.start()
+            self.addCleanup(p.stop)
+        self.addCleanup(self.temp.cleanup)
+
+    def run_checks(self, latest="0.0.1"):
+        return {msg: (ok, fix) for ok, msg, fix in doctor.checks(self.home, lambda: latest)}
+
+    def install(self):
+        args = argparse.Namespace(home=str(self.home), shell="zsh", yes=True, dry_run=False)
+        with contextlib.redirect_stdout(io.StringIO()):
+            manage.installation(args)
+
+    def test_not_installed_points_to_install(self):
+        results = self.run_checks()
+        ok, fix = results["not hooked into your shell yet"]
+        self.assertFalse(ok)
+        self.assertTrue(fix.endswith(" install"))
+
+    def test_installed_hook_waits_for_approval_then_passes(self):
+        self.install()
+        self.assertFalse(self.run_checks()["hook not approved in Codex yet"][0])
+        hooks = self.home / ".codex" / "hooks.json"
+        key = f"{hooks}:session_start:0:0"
+        (self.home / ".codex" / "config.toml").write_text(
+            f'[hooks.state."{key}"]\ntrusted_hash = "sha256:x"\n'
+        )
+        results = self.run_checks()
+        self.assertTrue(results["hook approved in Codex"][0])
+        self.assertTrue(results["codex is hooked into ~/.zshrc"][0])
+        self.assertTrue(results["latest version"][0])
+
+    def test_stale_copy_and_update_are_flagged(self):
+        self.install()
+        with patch.object(doctor, "hook_group", return_value={"hooks": [{"command": "new"}]}):
+            results = self.run_checks(latest="99.0.0")
+        stale = [m for m in results if m.startswith("codex runs another copy")]
+        self.assertEqual(len(stale), 1)
+        self.assertEqual(results["99.0.0 available"][1].split()[-1], "update")
+        self.assertIsNone(doctor._update_check("cxbar", lambda: None)[0])
+
+    def test_doctor_exit_code(self):
+        with contextlib.redirect_stdout(io.StringIO()) as out:
+            with patch.object(doctor, "latest_version", return_value=None):
+                code = doctor.doctor(self.home)
+        self.assertEqual(code, 1)
+        self.assertIn("✗ not hooked into your shell yet", out.getvalue())
+        json.dumps(out.getvalue())  # plain text, printable

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/tests/test_startup.py

@@ -118,6 +118,8 @@ class StartupTests(unittest.TestCase):
                 self.assertIn("CTX USED", conf)
                 # Codex asks tmux for #{mouse}; off makes the wheel recall old prompts.
                 self.assertIn("set -g mouse on", conf)
+                self.assertIn("set -g prefix None", conf)
+                self.assertIn("set -s escape-time 10", conf)
                 self.assertNotIn("binding pending", conf)
                 # error.json is written before the fallback status is applied.
                 # Faster Linux startup can observe that intermediate state.

{codex_statusline-0.2.2 → codex_statusline-0.3.1}/tests/test_update.py

@@ -43,6 +43,8 @@ class UpdateTests(unittest.TestCase):
         state = {"context_used": 10, "now": 1000, "update": "0.2.0", "quotas": {}}
         wide = render(state, 240, tmux=False)
         self.assertIn("↑ update available: codex-statusline update", wide)
+        short = render(dict(state, updater="cxbar"), 240, tmux=False)
+        self.assertIn("↑ update available: cxbar update", short)
         self.assertIn("^ update available", render(state, 240, tmux=False, ascii_only=True))
         self.assertNotIn("update", render(state, 40, tmux=False))
         self.assertNotIn("update", render(dict(state, update="#(evil)"), 240, tmux=False))