patch-cc 0.1.3__tar.gz → 0.2.0__tar.gz

{patch_cc-0.1.3 → patch_cc-0.2.0}/.github/workflows/ci.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.12", "3.13"]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
     steps:
       - uses: actions/checkout@v4
 

{patch_cc-0.1.3 → patch_cc-0.2.0}/.gitignore

@@ -20,3 +20,7 @@ build/
 *.patched
 content*.js
 claude-*.bin
+.opencode/
+
+# Build journal, not documentation (see docs/PLAYBOOK.md for the shipped "why")
+CODEX-PLAN.md

patch_cc-0.2.0/AGENTS.md

@@ -0,0 +1,18 @@
+# patch-cc
+
+Interactive patcher for the Claude Code native binary. What it does and how to
+use it: [README.md](README.md).
+
+Before changing anything, read [docs/CONDUCT.md](docs/CONDUCT.md) — how we
+build here: the mindset, the guardrails, and who commits (the user does). Then:
+
+- [docs/PLAYBOOK.md](docs/PLAYBOOK.md) — matcher rules, the patch reference,
+  how to repair a patch after a Claude update, and the map of the bundle's
+  native surfaces (the model registry and its consumers).
+- [docs/INTERNALS.md](docs/INTERNALS.md) — the Bun container format and how
+  the binary is rewritten in place.
+
+Verify with `uv run patch-cc doctor` (every patch against a clean bundle;
+point it at the pristine copies in `~/.local/share/patch-cc/backups/` to sweep
+older builds). There is no test suite by design — doctor against real bundles
+is the check.

patch_cc-0.2.0/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

{patch_cc-0.1.3 → patch_cc-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patch-cc
-Version: 0.1.3
+Version: 0.2.0
 Summary: Interactive patcher for the Claude Code native binary
 Project-URL: Homepage, https://github.com/anfreire/patch-cc
 Project-URL: Repository, https://github.com/anfreire/patch-cc
@@ -8,7 +8,7 @@ Project-URL: Issues, https://github.com/anfreire/patch-cc/issues
 Author-email: André Freire Ferreira <anfreire.dev@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
-Keywords: bun,claude,claude-code,cli,patch,tui
+Keywords: bun,claude,claude-code,cli,codex,gpt,openai,patch,tui
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
 Requires-Python: >=3.11
@@ -52,12 +53,12 @@ uvx patch-cc                   # fullscreen menu, no install needed
 ```
 
 The menu is a single centered panel: move with `↑ ↓`, toggle with `space`,
-press `s` to save. Patches that carry a setting — subagent models, the startup
-name, the `--version` marker — open a centered modal on `enter`, and the row
-then shows what you chose. Everything choosable is a picker: the agent names
-and model aliases are **discovered from your binary itself**, so the menu can
-never offer something your build would reject. Typing exists only for the two
-genuinely free-text values.
+press `s` to save. Patches that carry a setting — subagent models, Codex models,
+the startup name, the `--version` marker — open a centered modal on `enter`, and
+the row then shows what you chose. Everything choosable is a picker: the agent
+names and model aliases are **discovered from your binary itself** (and the
+Codex ones from your plan), so the menu can never offer something your build
+would reject. Typing exists only for the genuinely free-text values.
 
 A patched binary records what was applied inside itself, so the menu always
 comes up showing the real current state, and `patch-cc status` answers
@@ -76,14 +77,15 @@ patch-cc                       # then just run it
 |---|---|---|
 | Output & diffs | Detailed tool calls | Show full read/search calls, not collapsed summaries |
 | | Colour new files as diffs | Created files render with `+` lines and green |
-| Thinking | Opt out of server-side experiments | Some accounts land in one that empties every thinking block |
+| Thinking | Fix blank thinking blocks | Opt out of the server-side experiment that can empty every thinking block |
 | | Always show thinking | Thinking blocks stay inline — no `ctrl+o` |
-| Live thinking | Stream thinking live | See reasoning as it is generated, inline and in order |
+| | Stream thinking live | See reasoning as it is generated, inline and in order |
 | Subagents | Show subagent prompts | Prompt blocks visible during normal use |
 | | Override subagent models | Pick the model per built-in agent (discovered from your binary) |
 | Chrome | Disable spinner tips | No rotating tips on the spinner |
 | | Custom startup name | Defaults to `<your username>'s Code` |
 | | Mark `--version` | Appends `(patched)` — or any marker you choose |
+| Codex | Codex models | Use OpenAI/Codex-plan models in Claude Code — see [Codex models](#codex-models) |
 
 ## Usage
 
@@ -97,21 +99,83 @@ uvx patch-cc apply --brand                    # + branding as <username>'s Code
 uvx patch-cc apply --brand "Ada's Code"       # + branding, explicit name
 uvx patch-cc apply --model Explore=haiku --model general-purpose=opus
 uvx patch-cc apply --suffix "(mine)"          # custom --version marker
+uvx patch-cc apply --codex gpt-5.6-sol        # + a Codex model (see below)
+uvx patch-cc apply --from-cache               # replay your last remembered selection
 uvx patch-cc status                           # exactly what is applied
 uvx patch-cc doctor                           # do all patches match this build?
 uvx patch-cc doctor path/to/claude            # ...or match some other binary
-uvx patch-cc list                             # patches + your binary's agents/models
+uvx patch-cc list                             # every patch, described
 uvx patch-cc restore                          # put the original back
 ```
 
-`--model` and `--brand` imply their patches; agents and models are validated
-against what your installed binary actually ships.
+`--brand`, `--model` and `--codex` imply their patches; agents and models are
+validated against what your installed binary actually ships, and Codex model ids
+against what your plan offers. `apply --help` lists all three.
+
+## Codex models
+
+Bring your **ChatGPT/Codex-plan** models (GPT-5.x) into Claude Code and use them
+alongside your Claude ones — in the `/model` picker, as a subagent override,
+with `/effort` driving how hard they think. It is two halves: a patch that
+teaches your binary to accept and route the models you pick, and a small
+localhost **gateway** that translates between Claude Code and OpenAI. Only the
+models you pick are diverted — every Anthropic request stays byte-identical,
+so your Claude plan is untouched. Nothing extra to install: the gateway is pure
+Python and ships with patch-cc; you just sign in to a ChatGPT or Codex plan.
+
+```bash
+uvx patch-cc codex login                 # sign in to your ChatGPT/Codex plan
+uvx patch-cc                             # Codex models → pick models → save with `s`
+uvx patch-cc codex serve                 # start the gateway; keep it running
+```
+
+Which models you want is a patch setting like the startup name, so the menu's
+**Codex models** row is where you pick them — it lists what your plan offers,
+live. Everything the menu does the command line does too:
+
+```bash
+uvx patch-cc apply --codex gpt-5.6-sol --codex gpt-5.5
+uvx patch-cc apply --help                # lists the model ids your plan offers
+uvx patch-cc apply --from-cache           # replay your last selection
+```
+
+Then pick a model like any other:
+
+```bash
+claude --model sol                       # shortcut → newest gpt-5.6-sol
+claude --model gpt-5.6-sol               # the full id also works, as does /model
+```
+
+- **Shortcuts** (`sol`, `terra`, `luna`, …) are the last word of the model id;
+  the newest in a family wins, the way `opus` means the latest Claude Opus. They
+  are derived from the ids you picked — there is nothing to configure.
+- **Your binary is the record.** The models and the port live in the patched
+  binary, so `patch-cc status` names exactly what is registered, and
+  `codex serve` finds the right port with nothing to tell it.
+- **They read as native everywhere.** A registered model is added to the
+  binary's own model table, so its real name shows in the status line and the
+  welcome banner, its plan-reported effort levels are declared, and
+  `/advisor sol` works like any other model. Ask for an effort the model
+  doesn't run and the gateway quietly runs the closest lower one — the same
+  clamping Claude Code documents for its own models.
+- **The gateway has to be running.** Every surface that names it says whether it
+  is — the apply report as soon as you bake, `patch-cc status`, and `codex
+  status` — so you never learn it from a request that hangs instead.
+- The gateway holds *your* OpenAI token and listens only on localhost. No
+  Anthropic-model request is ever diverted to it. The Codex ones that *are*
+  still carry Claude Code's own auth header — the gateway ignores it and never
+  forwards it, but treat the port as trusted: whatever binds it first sees it.
+- After a Claude update, **re-bake** — the patch reverts with the binary — but
+  the gateway is separate and keeps running. Until you do, a Codex model you had
+  saved as your default reads as unavailable; the models live in the patch.
+  Change the port and the gateway needs a restart to follow it.
 
 ## After a Claude update
 
 Claude auto-updates roughly daily and replaces the binary, which reverts the
-patch. Re-run `patch-cc` — the menu remembers your last selection — or re-apply
-your set explicitly:
+patch. Re-run `patch-cc` — the menu remembers your last selection — replay it
+without the menu via `patch-cc apply --from-cache`, or re-apply your set
+explicitly:
 
 ```bash
 uvx patch-cc apply --brand --model Explore=haiku
@@ -130,6 +194,8 @@ binary is *smaller* than the original (≈113 MB vs 267 MB), not larger.
 
 See [docs/INTERNALS.md](docs/INTERNALS.md) for the container format and
 [docs/PLAYBOOK.md](docs/PLAYBOOK.md) for repairing a patch after an update.
+Changing anything here starts at [docs/CONDUCT.md](docs/CONDUCT.md) — how this
+is built, and what a patch has to prove before it ships.
 
 ## Credits
 
@@ -137,6 +203,9 @@ The patch set is a Python port of
 [a-connoisseur/patch-claude-code](https://github.com/a-connoisseur/patch-claude-code),
 with the subagent-model override idea from
 [aleks-apostle/claude-code-patches](https://github.com/aleks-apostle/claude-code-patches).
+Registering Codex models inside the bundle follows
+[clodex](https://github.com/gxjansen/clodex); the routing here is done in the
+bundle rather than with clodex's TLS interception.
 
 ## License
 

patch_cc-0.2.0/README.md

@@ -0,0 +1,183 @@
+# patch-cc
+
+[![CI](https://github.com/anfreire/patch-cc/actions/workflows/ci.yml/badge.svg)](https://github.com/anfreire/patch-cc/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/patch-cc)](https://pypi.org/project/patch-cc/)
+
+An interactive patcher for the **Claude Code native binary**. Pick the tweaks
+you want — inline and live thinking, detailed tool calls, subagent model
+overrides, your own startup name — and apply them to your installed `claude`
+in one keystroke. Pure Python; no Node, no Bun.
+
+## Requirements
+
+- **Linux or macOS**
+- **Python 3.11+**
+- **[uv](https://docs.astral.sh/uv/)** — how patch-cc is run and installed
+  below. Install it with `curl -LsSf https://astral.sh/uv/install.sh | sh`.
+  Not using uv? `pipx install patch-cc` (or `pip install patch-cc`) works too;
+  it is an ordinary PyPI package.
+- **macOS only:** the Xcode command line tools, for `codesign` — a patched
+  binary has to be re-signed or macOS refuses to run it.
+
+```bash
+uvx patch-cc                   # fullscreen menu, no install needed
+```
+
+The menu is a single centered panel: move with `↑ ↓`, toggle with `space`,
+press `s` to save. Patches that carry a setting — subagent models, Codex models,
+the startup name, the `--version` marker — open a centered modal on `enter`, and
+the row then shows what you chose. Everything choosable is a picker: the agent
+names and model aliases are **discovered from your binary itself** (and the
+Codex ones from your plan), so the menu can never offer something your build
+would reject. Typing exists only for the genuinely free-text values.
+
+A patched binary records what was applied inside itself, so the menu always
+comes up showing the real current state, and `patch-cc status` answers
+exactly.
+
+Prefer it always available on your PATH? Install it:
+
+```bash
+uv tool install patch-cc
+patch-cc                       # then just run it
+```
+
+## What it can do
+
+| Group | Patch | |
+|---|---|---|
+| Output & diffs | Detailed tool calls | Show full read/search calls, not collapsed summaries |
+| | Colour new files as diffs | Created files render with `+` lines and green |
+| Thinking | Fix blank thinking blocks | Opt out of the server-side experiment that can empty every thinking block |
+| | Always show thinking | Thinking blocks stay inline — no `ctrl+o` |
+| | Stream thinking live | See reasoning as it is generated, inline and in order |
+| Subagents | Show subagent prompts | Prompt blocks visible during normal use |
+| | Override subagent models | Pick the model per built-in agent (discovered from your binary) |
+| Chrome | Disable spinner tips | No rotating tips on the spinner |
+| | Custom startup name | Defaults to `<your username>'s Code` |
+| | Mark `--version` | Appends `(patched)` — or any marker you choose |
+| Codex | Codex models | Use OpenAI/Codex-plan models in Claude Code — see [Codex models](#codex-models) |
+
+## Usage
+
+Everything the menu does is also a non-interactive subcommand (shown with
+`uvx`; drop it if you installed the tool):
+
+```bash
+uvx patch-cc apply                            # the default patch set
+uvx patch-cc apply tool-calls live-thinking   # just these
+uvx patch-cc apply --brand                    # + branding as <username>'s Code
+uvx patch-cc apply --brand "Ada's Code"       # + branding, explicit name
+uvx patch-cc apply --model Explore=haiku --model general-purpose=opus
+uvx patch-cc apply --suffix "(mine)"          # custom --version marker
+uvx patch-cc apply --codex gpt-5.6-sol        # + a Codex model (see below)
+uvx patch-cc apply --from-cache               # replay your last remembered selection
+uvx patch-cc status                           # exactly what is applied
+uvx patch-cc doctor                           # do all patches match this build?
+uvx patch-cc doctor path/to/claude            # ...or match some other binary
+uvx patch-cc list                             # every patch, described
+uvx patch-cc restore                          # put the original back
+```
+
+`--brand`, `--model` and `--codex` imply their patches; agents and models are
+validated against what your installed binary actually ships, and Codex model ids
+against what your plan offers. `apply --help` lists all three.
+
+## Codex models
+
+Bring your **ChatGPT/Codex-plan** models (GPT-5.x) into Claude Code and use them
+alongside your Claude ones — in the `/model` picker, as a subagent override,
+with `/effort` driving how hard they think. It is two halves: a patch that
+teaches your binary to accept and route the models you pick, and a small
+localhost **gateway** that translates between Claude Code and OpenAI. Only the
+models you pick are diverted — every Anthropic request stays byte-identical,
+so your Claude plan is untouched. Nothing extra to install: the gateway is pure
+Python and ships with patch-cc; you just sign in to a ChatGPT or Codex plan.
+
+```bash
+uvx patch-cc codex login                 # sign in to your ChatGPT/Codex plan
+uvx patch-cc                             # Codex models → pick models → save with `s`
+uvx patch-cc codex serve                 # start the gateway; keep it running
+```
+
+Which models you want is a patch setting like the startup name, so the menu's
+**Codex models** row is where you pick them — it lists what your plan offers,
+live. Everything the menu does the command line does too:
+
+```bash
+uvx patch-cc apply --codex gpt-5.6-sol --codex gpt-5.5
+uvx patch-cc apply --help                # lists the model ids your plan offers
+uvx patch-cc apply --from-cache           # replay your last selection
+```
+
+Then pick a model like any other:
+
+```bash
+claude --model sol                       # shortcut → newest gpt-5.6-sol
+claude --model gpt-5.6-sol               # the full id also works, as does /model
+```
+
+- **Shortcuts** (`sol`, `terra`, `luna`, …) are the last word of the model id;
+  the newest in a family wins, the way `opus` means the latest Claude Opus. They
+  are derived from the ids you picked — there is nothing to configure.
+- **Your binary is the record.** The models and the port live in the patched
+  binary, so `patch-cc status` names exactly what is registered, and
+  `codex serve` finds the right port with nothing to tell it.
+- **They read as native everywhere.** A registered model is added to the
+  binary's own model table, so its real name shows in the status line and the
+  welcome banner, its plan-reported effort levels are declared, and
+  `/advisor sol` works like any other model. Ask for an effort the model
+  doesn't run and the gateway quietly runs the closest lower one — the same
+  clamping Claude Code documents for its own models.
+- **The gateway has to be running.** Every surface that names it says whether it
+  is — the apply report as soon as you bake, `patch-cc status`, and `codex
+  status` — so you never learn it from a request that hangs instead.
+- The gateway holds *your* OpenAI token and listens only on localhost. No
+  Anthropic-model request is ever diverted to it. The Codex ones that *are*
+  still carry Claude Code's own auth header — the gateway ignores it and never
+  forwards it, but treat the port as trusted: whatever binds it first sees it.
+- After a Claude update, **re-bake** — the patch reverts with the binary — but
+  the gateway is separate and keeps running. Until you do, a Codex model you had
+  saved as your default reads as unavailable; the models live in the patch.
+  Change the port and the gateway needs a restart to follow it.
+
+## After a Claude update
+
+Claude auto-updates roughly daily and replaces the binary, which reverts the
+patch. Re-run `patch-cc` — the menu remembers your last selection — replay it
+without the menu via `patch-cc apply --from-cache`, or re-apply your set
+explicitly:
+
+```bash
+uvx patch-cc apply --brand --model Explore=haiku
+```
+
+`uvx patch-cc status` tells you whether the current binary is patched, and the
+startup name / `--version` marker are visible tells too.
+
+## Why native-only, and why it stays small
+
+Claude Code now ships only as a Bun single-file executable; the npm package is a
+wrapper that downloads it. patch-cc edits the JavaScript bundle embedded in the
+binary's `.bun` section in place. It also drops the module's 154 MB of stale
+precompiled bytecode — editing the source invalidates it anyway — so a patched
+binary is *smaller* than the original (≈113 MB vs 267 MB), not larger.
+
+See [docs/INTERNALS.md](docs/INTERNALS.md) for the container format and
+[docs/PLAYBOOK.md](docs/PLAYBOOK.md) for repairing a patch after an update.
+Changing anything here starts at [docs/CONDUCT.md](docs/CONDUCT.md) — how this
+is built, and what a patch has to prove before it ships.
+
+## Credits
+
+The patch set is a Python port of
+[a-connoisseur/patch-claude-code](https://github.com/a-connoisseur/patch-claude-code),
+with the subagent-model override idea from
+[aleks-apostle/claude-code-patches](https://github.com/aleks-apostle/claude-code-patches).
+Registering Codex models inside the bundle follows
+[clodex](https://github.com/gxjansen/clodex); the routing here is done in the
+bundle rather than with clodex's TLS interception.
+
+## License
+
+MIT

{patch_cc-0.1.3 → patch_cc-0.2.0}/docs/CONDUCT.md

@@ -29,9 +29,11 @@ shape that already absorbs every case, found rather than bolted on.
   brick.
 
 - **Explicit invocations are hermetic.** A non-interactive command's arguments
-  are its whole input; no saved state may silently change what it does, so the
-  same command always yields the same result. Persisted choices belong to the
-  interactive UI alone — they pre-fill a prompt, never trigger an action.
+  are its whole input; no saved state may *silently* change what it does.
+  Persisted choices pre-fill the interactive UI and never act on their own — the
+  lone exception is `apply --from-cache`, which takes the cache as its *named*
+  input, so the state it reads is declared in the arguments, not hidden behind a
+  default. Absent that flag, the same command still always yields the same result.
 
 - **Anchor matchers on meaning.** String literals, `case` labels, prop names,
   control-flow shape — never a minified local that changes every build. A new

{patch_cc-0.1.3 → patch_cc-0.2.0}/docs/INTERNALS.md

@@ -88,10 +88,12 @@ edit is followed by an ad-hoc `codesign` (mandatory on Apple Silicon).
 
 ## The manifest
 
-Every patched bundle ends with a single comment line:
+Every patched bundle ends with a single comment line — the one description of
+its shape; [PLAYBOOK.md](PLAYBOOK.md) covers what it means for matcher health:
 
 ```
-//patch-cc {"v":1,"tool":"0.1.0","patches":[...],"brand":...,"models":{...}}
+//patch-cc {"v":1,"tool":"<version>","patches":[...],"brand":...,"models":{...},
+            "codex":{"port":8817,"models":["gpt-5.6-sol", ...]}}
 ```
 
 That line is why `patch-cc status` can name exactly what is applied: several
@@ -100,6 +102,18 @@ can't collide with code and travels with the bundle through extract/repack.
 The menu also reads it to pre-select the current patch set — the binary is the
 state.
 
+Every key after `patches` belongs to a patch and is written only when *that*
+patch landed, so `status` can never assert a name, marker, or model the bundle
+does not contain.
+
+Each key records what was *asked for*, never what was derived from it. `codex`
+carries model ids and a port and nothing else: a Codex model's display name and
+context window are already baked into the bundle, and repeating them here would
+be a second copy — one that a relabelling upstream could make disagree with the
+binary it claims to describe. That is also what makes the manifest the single
+home for the gateway port: `codex serve` and `codex status` read it from here
+rather than from a store of their own.
+
 ## Safety
 
 - Before the first patch of a version, the pristine binary is copied to
@@ -112,4 +126,6 @@ state.
 - Every write is verified: patch-cc re-extracts the JS from the binary it just
   wrote and asserts it equals what it meant to write.
 - Patching a binary that is already marked, when no pristine backup exists, is
-  refused unless `--force` — there is nothing clean to start from.
+  refused outright — there is nothing clean to start from, and our edits change
+  lengths, so a second pass would corrupt rather than update. `restore` or a
+  reinstall are the only honest fixes; there is deliberately no override.