pennyrouter 0.3.19 → 0.3.21

package/standalone/codex-proxy.sh

@@ -0,0 +1,208 @@
+#!/usr/bin/env bash
+# Point Codex at an OpenAI Responses-compatible proxy, and put it back.
+#
+# This writes a marker-fenced custom provider into ~/.codex/config.toml. The
+# proxy token is read from the local .env and written only inside the managed
+# provider block. Every setting outside the managed block is
+# preserved, including the model provider that `off` restores.
+#
+#   codex-proxy.sh on [url]   point Codex at the proxy
+#   codex-proxy.sh off        remove it, back to the previous provider
+#   codex-proxy.sh status     show what is set right now
+#
+# The URL and token fall back to whatever claude-proxy.sh already saved in
+# .env (PENNY_COMPARE_NATIVE_BASE_URL / PENNY_COMPARE_NATIVE_AUTH_TOKEN), so a
+# bare `on` reuses the same proxy without retyping either. CODEX_PROXY_URL and
+# CODEX_PROXY_TOKEN (or CODEX_PROXY_TOKEN_ENV, to name a different token
+# variable) override that when set. Include the API prefix expected by the
+# proxy, commonly `/v1`, in the URL.
+#
+# export CODEX_PROXY_URL=https://litellm.example.com/v1
+# export CODEX_PROXY_TOKEN=sk-example
+# ./codex-proxy.sh on
+#
+# The first `on` backs the config file up once per invocation, so an edit that
+# goes wrong is recoverable from ~/.codex/config.toml.bak.<timestamp>.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+ENV_FILE="${PROXY_ENV_FILE:-$SCRIPT_DIR/.env}"
+if [ -f "$ENV_FILE" ]; then
+  set -a
+  . "$ENV_FILE"
+  set +a
+fi
+
+CONFIG="${CODEX_CONFIG:-${CODEX_HOME:-$HOME/.codex}/config.toml}"
+# Falls back to the same proxy URL claude-proxy.sh already saved in .env, so a
+# bare `./codex-proxy.sh on` reuses it without retyping.
+DEFAULT_URL="${CODEX_PROXY_URL:-${PENNY_COMPARE_NATIVE_BASE_URL:-}}"
+TOKEN_ENV="${CODEX_PROXY_TOKEN_ENV:-CODEX_PROXY_TOKEN}"
+
+die() { echo "error: $*" >&2; exit 1; }
+
+command -v python3 >/dev/null || die "python3 is required"
+
+# Codex creates this on first run. Refuse to invent a new file because doing so
+# would guess at the rest of the user's configuration.
+[ -f "$CONFIG" ] || die "no config file at $CONFIG (run codex once first)"
+
+backup() {
+  local dest="$CONFIG.bak.$(date +%Y%m%dT%H%M%SZ)"
+  cp "$CONFIG" "$dest"
+  echo "backed up to $dest"
+}
+
+# Add or remove the managed provider block. Root-level TOML keys must precede
+# the first table, so this edits text deliberately instead of appending a block.
+# Writes use a same-directory temporary file and atomic rename.
+edit_config() {
+  ACTION="$1" URL="${2:-}" TOKEN="${3:-}" CONFIG="$CONFIG" python3 <<'PY'
+import base64
+import json
+import os
+import re
+import tempfile
+
+path = os.environ["CONFIG"]
+action = os.environ["ACTION"]
+start = "# --- Codex proxy managed provider ---"
+end = "# --- end Codex proxy managed provider ---"
+provider_id = "codex_proxy"
+
+with open(path) as fh:
+    original = fh.read()
+
+block_pattern = re.compile(
+    rf"(?ms)^{re.escape(start)}\n.*?^{re.escape(end)}\n?"
+)
+old_match = block_pattern.search(original)
+previous = None
+if old_match:
+    saved = re.search(
+        r"(?m)^# previous_model_provider_b64: ([A-Za-z0-9+/=]+|none)$",
+        old_match.group(0),
+    )
+    if saved and saved.group(1) != "none":
+        previous = base64.b64decode(saved.group(1)).decode("utf-8")
+
+clean = block_pattern.sub("", original)
+lines = clean.splitlines()
+first_table = next((i for i, line in enumerate(lines) if re.match(r"^\s*\[", line)), len(lines))
+
+root_provider_indexes = [
+    i for i, line in enumerate(lines[:first_table])
+    if re.match(r"^\s*model_provider\s*=", line)
+]
+if action == "on":
+    if previous is None and root_provider_indexes:
+        previous = lines[root_provider_indexes[0]]
+    lines = [line for i, line in enumerate(lines) if i not in root_provider_indexes]
+
+    clean_without_root_provider = "\n".join(lines)
+    if re.search(rf"(?m)^\s*\[model_providers\.{provider_id}\]\s*$", clean_without_root_provider):
+        raise SystemExit(
+            f"error: config already defines [model_providers.{provider_id}] outside the managed block"
+        )
+
+    first_table = next((i for i, line in enumerate(lines) if re.match(r"^\s*\[", line)), len(lines))
+    saved_previous = (
+        base64.b64encode(previous.encode("utf-8")).decode("ascii")
+        if previous is not None else "none"
+    )
+    block = [
+        start,
+        f"# previous_model_provider_b64: {saved_previous}",
+        f'model_provider = "{provider_id}"',
+        "",
+        f"[model_providers.{provider_id}]",
+        'name = "Codex proxy"',
+        f'base_url = {json.dumps(os.environ["URL"])}',
+        'wire_api = "responses"',
+        "supports_websockets = false",
+        f'experimental_bearer_token = {json.dumps(os.environ["TOKEN"])}',
+        end,
+    ]
+    if first_table > 0 and lines[first_table - 1].strip():
+        block.insert(0, "")
+    if first_table < len(lines) and lines[first_table].strip():
+        block.append("")
+    lines[first_table:first_table] = block
+elif action == "off":
+    # If the user added a new root provider while the proxy was active, keep it
+    # instead of replacing it with the older saved value.
+    if previous is not None and not root_provider_indexes:
+        lines = clean.splitlines()
+        first_table = next((i for i, line in enumerate(lines) if re.match(r"^\s*\[", line)), len(lines))
+        insertion = [previous]
+        if first_table > 0 and lines[first_table - 1].strip():
+            insertion.insert(0, "")
+        lines[first_table:first_table] = insertion
+else:
+    raise SystemExit(f"error: unknown action: {action}")
+
+text = "\n".join(lines)
+text = re.sub(r"\n{3,}", "\n\n", text).strip() + "\n"
+directory = os.path.dirname(path) or "."
+with tempfile.NamedTemporaryFile("w", dir=directory, delete=False) as tmp:
+    tmp.write(text)
+    temp_path = tmp.name
+os.chmod(temp_path, 0o600)
+os.replace(temp_path, path)
+PY
+}
+
+show_status() {
+  CONFIG="$CONFIG" python3 <<'PY'
+import json
+import os
+import re
+
+with open(os.environ["CONFIG"]) as fh:
+    text = fh.read()
+
+match = re.search(
+    r'(?ms)^# --- Codex proxy managed provider ---\n(.*?)^# --- end Codex proxy managed provider ---$',
+    text,
+)
+if not match:
+    print("proxy OFF (Codex uses its previous/default provider)")
+    raise SystemExit
+
+url_match = re.search(r"(?m)^base_url\s*=\s*(\"(?:[^\"\\]|\\.)*\")\s*$", match.group(1))
+url = json.loads(url_match.group(1)) if url_match else "UNKNOWN"
+token_match = re.search(r"(?m)^experimental_bearer_token\s*=\s*", match.group(1))
+token_status = "set" if token_match else "MISSING"
+print(f"proxy ON\n  base_url: {url}\n  token: {token_status}")
+PY
+}
+
+case "${1:-status}" in
+  on)
+    url="${2:-$DEFAULT_URL}"
+    [ -n "$url" ] || die "usage: $(basename "$0") on <proxy-url>   (or set CODEX_PROXY_URL)"
+    [[ "$TOKEN_ENV" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || die "invalid token environment variable name: $TOKEN_ENV"
+    # Falls back to the same proxy token claude-proxy.sh already saved in
+    # .env, so a bare `./codex-proxy.sh on` reuses it without retyping.
+    token="${!TOKEN_ENV:-${PENNY_COMPARE_NATIVE_AUTH_TOKEN:-}}"
+    [ -n "$token" ] || die "$TOKEN_ENV is not set (or set PENNY_COMPARE_NATIVE_AUTH_TOKEN in .env)"
+
+    backup
+    edit_config on "${url%/}" "$token"
+    echo "Codex -> ${url%/}"
+    echo "Restart any running Codex session to pick this up."
+    ;;
+  off)
+    backup
+    edit_config off
+    echo "Codex -> previous/default provider"
+    echo "Restart any running Codex session to pick this up."
+    ;;
+  status)
+    show_status
+    ;;
+  *)
+    die "usage: $(basename "$0") {on [url]|off|status}"
+    ;;
+esac

package/standalone/delta.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Derives the cross-pane comparison.
+
+The percentages describe the pair, not either pane, so they are computed once here and written
+where the penny pane can display them above its readout.
+"""
+
+import os
+import sys
+import time
+
+
+def read(path):
+    try:
+        with open(path) as handle:
+            cost, total, write = handle.read().split()[:3]
+        return float(cost), int(total), int(write)
+    except (OSError, ValueError):
+        return None
+
+
+def main():
+    state, out = sys.argv[1], sys.argv[2]
+    while True:
+        native = read(os.path.join(state, "native.txt"))
+        penny = read(os.path.join(state, "penny.txt"))
+        text = ""
+        if native and penny and native[0] > 0 and native[1] > 0:
+            cost_delta = (penny[0] - native[0]) / native[0] * 100
+            token_delta = (penny[1] - native[1]) / native[1] * 100
+            text = f"{cost_delta:+.0f}% cost  {token_delta:+.0f}% tok"
+        try:
+            with open(out, "w") as handle:
+                handle.write(text)
+        except OSError:
+            pass
+        time.sleep(1)
+
+
+if __name__ == "__main__":
+    main()

package/standalone/demo_example.md

@@ -0,0 +1,7 @@
+are you familiar with the omop common data model
+
+can you write me a sql query to find patients with gerd using omop
+
+great what is a good resource for finding concept sets with omop queries
+
+perfect can you make me a simple HTML showing the components of the OMOP CDM and how they connect

package/standalone/hud.py

@@ -0,0 +1,122 @@
+"""Draws the token readout above a harness session.
+
+The HUD owns a fixed block of rows at the top of the terminal and repaints them in place, so the
+session below scrolls untouched. Values roll toward their targets rather than snapping, which is
+what makes a turn's tokens legible as they land.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+
+GREEN = "\033[38;5;46m"
+DIM_GREEN = "\033[38;5;28m"
+AMBER = "\033[38;5;214m"
+RED = "\033[38;5;203m"
+GREY = "\033[38;5;242m"
+WHITE = "\033[38;5;253m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+WIDTH = 26
+ROWS = 7
+
+
+def abbreviate(value: int) -> str:
+    if value >= 1_000_000:
+        return f"{value / 1_000_000:.2f}M"
+    if value >= 1_000:
+        return f"{value / 1_000:.1f}k"
+    return str(value)
+
+
+class CountUp:
+    """Eases displayed values toward their targets.
+
+    Counts arrive in jumps and at any magnitude, so each value chases its target continuously:
+    a target that moves mid-roll retargets rather than restarting. Closing the tail as a share of
+    the whole jump keeps a roll the same duration whether it counts dozens or hundreds of
+    thousands.
+    """
+
+    RATE = 0.88
+    MIN_STEP_SHARE = 0.55
+
+    def __init__(self):
+        self._shown: dict[str, float] = {}
+        self._origin: dict[str, float] = {}
+
+    def advance(self, targets: dict[str, int], elapsed: float) -> dict[str, int]:
+        remaining = (1 - self.RATE) ** max(0.0, elapsed)
+        out: dict[str, int] = {}
+        for key, target in targets.items():
+            goal = float(target)
+            if key not in self._shown:
+                # A session's existing total is not motion worth watching.
+                self._shown[key] = self._origin[key] = goal
+                out[key] = target
+                continue
+            current = self._shown[key]
+            if goal < current:
+                # A drop is a new session; land rather than counting backwards.
+                current = goal
+                self._origin[key] = goal
+            else:
+                if goal > self._origin[key] and current >= goal:
+                    self._origin[key] = current
+                span = max(1.0, goal - min(self._origin[key], current))
+                floor_step = span * self.MIN_STEP_SHARE * max(0.0, elapsed)
+                current += max((goal - current) * (1 - remaining), min(goal - current, floor_step))
+            self._shown[key] = current
+            out[key] = min(target, int(current))
+        return out
+
+    def reset(self) -> None:
+        self._shown.clear()
+        self._origin.clear()
+
+
+def _row(label: str, value: str, colour: str) -> str:
+    pad = WIDTH - len(label) - len(value)
+    return f"{GREY}{label}{' ' * max(1, pad)}{colour}{BOLD}{value}{RESET}"
+
+
+def render(title: str, model: str, usage, cost: float, delta: str | None = None,
+           waiting: bool = False) -> list[str]:
+    """The readout as a list of lines, top-aligned and padded to a fixed height."""
+    lines: list[str] = []
+
+    if waiting:
+        # Zeros would read as a measurement; the pane has simply not seen a turn yet.
+        return ["",
+                f"{GREEN}{BOLD}{title}{RESET}",
+                f"{GREY}{'waiting for first turn':<{WIDTH}}{RESET}",
+                "", "", "", ""]
+
+    if delta:
+        # Right-aligned within the block; the pad is interior so it covers nothing beside it.
+        pad = max(0, WIDTH - len(delta))
+        lines.append(f"{' ' * pad}{GREEN}{BOLD}{delta}{RESET}")
+    else:
+        lines.append("")
+
+    short = (model or "").split("/")[-1] or "—"
+    # A dated model id would run past the block and break the right alignment.
+    room = WIDTH - len(title) - 1
+    if len(short) > room:
+        short = short[:room]
+    head_pad = WIDTH - len(title) - len(short)
+    lines.append(f"{GREEN}{BOLD}{title}{RESET}{' ' * max(1, head_pad)}{DIM_GREEN}{short}{RESET}")
+
+    lines.append(_row("read", abbreviate(usage["cache_read"]), GREEN))
+    lines.append(_row("write", abbreviate(usage["cache_write"]), AMBER))
+    lines.append(_row("in", abbreviate(usage["fresh_input"]), GREEN))
+    lines.append(_row("out", abbreviate(usage["output"]), GREEN))
+
+    total = (usage["cache_read"] + usage["cache_write"]
+             + usage["fresh_input"] + usage["output"])
+    lines.append(_row("total", abbreviate(total), WHITE))
+
+    lines.append(_row("cost", f"${cost:,.2f}", WHITE))
+    return lines

package/standalone/install.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# Put penny-compare and penny-session on PATH.
+#
+#   ./install.sh              symlink into ~/.local/bin
+#   ./install.sh ~/bin        symlink into a directory you choose
+#
+# Symlinks, not copies: the scripts resolve their own directory, so they keep
+# finding pane.py and friends here. Move this folder and re-run to repoint.
+
+set -euo pipefail
+
+here="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+bindir="${1:-$HOME/.local/bin}"
+
+missing=()
+command -v tmux    >/dev/null 2>&1 || missing+=(tmux)
+command -v python3 >/dev/null 2>&1 || missing+=(python3)
+if [ ${#missing[@]} -gt 0 ]; then
+  echo "Missing: ${missing[*]}" >&2
+  echo "  macOS:  brew install ${missing[*]}" >&2
+  echo "  Debian: sudo apt install ${missing[*]}" >&2
+  exit 1
+fi
+
+python3 - <<'PY' || { echo "python3 must be 3.10 or newer (the code uses \`X | None\` annotations)." >&2; exit 1; }
+import sys; sys.exit(0 if sys.version_info >= (3, 10) else 1)
+PY
+
+mkdir -p "$bindir"
+for script in penny-compare penny-session penny-compare-viewer; do
+  chmod +x "$here/$script"
+  ln -sfn "$here/$script" "$bindir/$script"
+  echo "  $bindir/$script -> $here/$script"
+done
+chmod +x "$here"/*.py
+
+echo
+if ! printf '%s' ":$PATH:" | grep -q ":$bindir:"; then
+  echo "NOTE: $bindir is not on your PATH. Add it:"
+  echo "  echo 'export PATH=\"$bindir:\$PATH\"' >> ~/.zshrc && exec zsh"
+  echo
+fi
+
+harnesses=()
+for h in claude codex opencode penny; do
+  command -v "$h" >/dev/null 2>&1 && harnesses+=("$h")
+done
+if [ ${#harnesses[@]} -gt 0 ]; then
+  echo "Harnesses found: ${harnesses[*]}"
+else
+  echo "No harnesses found on PATH yet (claude / codex / opencode / penny)."
+fi
+if ! command -v penny >/dev/null 2>&1; then
+  echo "For the penny-routed panes, install PennyRouter:  npx pennyrouter install"
+fi
+
+echo
+echo "Done. Try:  penny-compare"