cswap-pin 0.1.0__tar.gz

cswap_pin-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+dist/
+build/
+*.egg-info/
+.venv/

cswap_pin-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: cswap-pin
+Version: 0.1.0
+Summary: Keep Claude Code's Remote Control and Artifacts on one account while inference follows cswap's account swap
+Project-URL: Homepage, https://github.com/codeslake/cswap-pin
+Project-URL: Repository, https://github.com/codeslake/cswap-pin
+Project-URL: Issues, https://github.com/codeslake/cswap-pin/issues
+Project-URL: Upstream discussion, https://github.com/realiti4/claude-swap/issues/198
+Author: Junyong Lee
+License: MIT
+Keywords: claude,claude-code,claude-swap,cswap,proxy,remote-control
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=41.0
+Description-Content-Type: text/markdown
+
+# cswap-pin
+
+Keep Claude Code's **Remote Control** and **Artifacts** on one account while
+inference keeps following [`cswap`](https://github.com/realiti4/claude-swap)'s
+account swap.
+
+## The problem
+
+cswap swaps the on-disk credential, so *everything* follows the swap —
+including two things that are not inference and that you usually want to stay
+put:
+
+- **Remote Control** — a session's owner is fixed at creation by whichever
+  bearer created it. Swap accounts and the phone/web loses the session; stale
+  "ghost" sessions pile up on the old account.
+- **Artifacts** — owned by the publishing bearer. After a swap a republish
+  403s and the artifact "disappears" from the account you are logged into.
+
+Claude Code resolves all of these through one credential accessor and has no
+per-operation token selector, so splitting auth *per operation inside one
+session* means intercepting the requests.
+
+## How it works
+
+A local MITM forward proxy that swaps the `Authorization` bearer on exactly
+the routes whose server-side ownership is decided by it, and passes everything
+else — `/v1/messages` above all — through untouched.
+
+```
+claude session
+  HTTPS_PROXY ─► cswap pin proxy ──► (whatever HTTPS_PROXY was already set) ──► api.anthropic.com
+                   swaps bearer on: /v1/code/sessions*, /v1/sessions/*,
+                                    /api/frame/*, /v1/ultrareview/*
+                   passes through:  /v1/messages, /api/oauth/usage, everything else
+```
+
+Inference keeps billing whichever account cswap has swapped onto. Only the
+claude.ai-side assets are pinned.
+
+## Install
+
+```bash
+uv tool install 'claude-swap[pin]'      # or: pipx install 'claude-swap[pin]'
+```
+
+The pin is an optional extra of claude-swap, not a standalone tool: it reads
+cswap's account store and rewrites the config cswap already manages. Installing
+`cswap-pin` on its own does nothing useful.
+
+## Use
+
+```bash
+cswap pin 2          # RC / artifacts / ultrareview → account 2
+cswap pin            # show the current pin
+cswap pin --clear    # remove it
+```
+
+The pinned account is re-read per request, so `cswap pin <other>` takes effect
+under a live daemon — no session restart. The one thing a re-pin cannot move is
+a Remote Control session that is **already open**: the server fixed its owner
+when it was created, so reconnecting inside it is what mints a new one under
+the new pin.
+
+## Requirements
+
+- Python 3.10+
+- [`claude-swap`](https://github.com/realiti4/claude-swap) — a peer, not a
+  dependency: this package is loaded *by* it (see `src/cswap_pin/_host.py` for
+  the exact surface it borrows)
+- `cryptography` (installed automatically) for the MITM CA
+
+## Why a separate package
+
+Upstream did not want a MITM proxy shipped inside claude-swap itself and asked
+for a companion distribution exposed through an optional extra. See
+[realiti4/claude-swap#198](https://github.com/realiti4/claude-swap/issues/198).
+
+## Trust
+
+The proxy generates its own CA to re-sign `api.anthropic.com` and names it in
+`NODE_EXTRA_CA_CERTS`. Node accepts exactly one file there, so an existing CA
+(a corporate MITM, another local proxy) is **merged**, never replaced —
+otherwise the session silently loses trust in every host the other proxy
+re-signs.
+
+The proxy also requires a per-daemon credential on `CONNECT`: it listens on
+loopback, which carries no identity, and without one any local process could
+have a junk bearer replaced with the pinned account's real token.
+
+## License
+
+MIT

cswap_pin-0.1.0/README.md

@@ -0,0 +1,92 @@
+# cswap-pin
+
+Keep Claude Code's **Remote Control** and **Artifacts** on one account while
+inference keeps following [`cswap`](https://github.com/realiti4/claude-swap)'s
+account swap.
+
+## The problem
+
+cswap swaps the on-disk credential, so *everything* follows the swap —
+including two things that are not inference and that you usually want to stay
+put:
+
+- **Remote Control** — a session's owner is fixed at creation by whichever
+  bearer created it. Swap accounts and the phone/web loses the session; stale
+  "ghost" sessions pile up on the old account.
+- **Artifacts** — owned by the publishing bearer. After a swap a republish
+  403s and the artifact "disappears" from the account you are logged into.
+
+Claude Code resolves all of these through one credential accessor and has no
+per-operation token selector, so splitting auth *per operation inside one
+session* means intercepting the requests.
+
+## How it works
+
+A local MITM forward proxy that swaps the `Authorization` bearer on exactly
+the routes whose server-side ownership is decided by it, and passes everything
+else — `/v1/messages` above all — through untouched.
+
+```
+claude session
+  HTTPS_PROXY ─► cswap pin proxy ──► (whatever HTTPS_PROXY was already set) ──► api.anthropic.com
+                   swaps bearer on: /v1/code/sessions*, /v1/sessions/*,
+                                    /api/frame/*, /v1/ultrareview/*
+                   passes through:  /v1/messages, /api/oauth/usage, everything else
+```
+
+Inference keeps billing whichever account cswap has swapped onto. Only the
+claude.ai-side assets are pinned.
+
+## Install
+
+```bash
+uv tool install 'claude-swap[pin]'      # or: pipx install 'claude-swap[pin]'
+```
+
+The pin is an optional extra of claude-swap, not a standalone tool: it reads
+cswap's account store and rewrites the config cswap already manages. Installing
+`cswap-pin` on its own does nothing useful.
+
+## Use
+
+```bash
+cswap pin 2          # RC / artifacts / ultrareview → account 2
+cswap pin            # show the current pin
+cswap pin --clear    # remove it
+```
+
+The pinned account is re-read per request, so `cswap pin <other>` takes effect
+under a live daemon — no session restart. The one thing a re-pin cannot move is
+a Remote Control session that is **already open**: the server fixed its owner
+when it was created, so reconnecting inside it is what mints a new one under
+the new pin.
+
+## Requirements
+
+- Python 3.10+
+- [`claude-swap`](https://github.com/realiti4/claude-swap) — a peer, not a
+  dependency: this package is loaded *by* it (see `src/cswap_pin/_host.py` for
+  the exact surface it borrows)
+- `cryptography` (installed automatically) for the MITM CA
+
+## Why a separate package
+
+Upstream did not want a MITM proxy shipped inside claude-swap itself and asked
+for a companion distribution exposed through an optional extra. See
+[realiti4/claude-swap#198](https://github.com/realiti4/claude-swap/issues/198).
+
+## Trust
+
+The proxy generates its own CA to re-sign `api.anthropic.com` and names it in
+`NODE_EXTRA_CA_CERTS`. Node accepts exactly one file there, so an existing CA
+(a corporate MITM, another local proxy) is **merged**, never replaced —
+otherwise the session silently loses trust in every host the other proxy
+re-signs.
+
+The proxy also requires a per-daemon credential on `CONNECT`: it listens on
+loopback, which carries no identity, and without one any local process could
+have a junk bearer replaced with the pinned account's real token.
+
+## License
+
+MIT

cswap_pin-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "cswap-pin"
+version = "0.1.0"
+description = "Keep Claude Code's Remote Control and Artifacts on one account while inference follows cswap's account swap"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Junyong Lee" }]
+keywords = ["claude", "claude-code", "claude-swap", "cswap", "proxy", "remote-control"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Topic :: Utilities",
+]
+
+# claude-swap is a PEER, not a dependency. cswap-pin is loaded BY claude-swap
+# (via `claude-swap[pin]`), so depending on it here would make the pair
+# circular and let `pip install cswap-pin` drag in the whole switcher for
+# someone who already has it. The import surface it needs is small and
+# declared in _host.py.
+dependencies = ["cryptography>=41.0"]
+
+[project.urls]
+Homepage = "https://github.com/codeslake/cswap-pin"
+Repository = "https://github.com/codeslake/cswap-pin"
+Issues = "https://github.com/codeslake/cswap-pin/issues"
+"Upstream discussion" = "https://github.com/realiti4/claude-swap/issues/198"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cswap_pin"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

cswap_pin-0.1.0/src/cswap_pin/__init__.py

@@ -0,0 +1,35 @@
+"""Keep Claude Code's Remote Control and Artifacts on one account.
+
+cswap swaps the on-disk credential, so everything follows the swap — including
+two things that are not inference and usually should not move: Remote Control
+(a session's owner is fixed at creation by the bearer that created it) and
+Artifacts (owned by the publishing bearer). This package keeps those on one
+account while inference keeps following ``cswap switch`` / ``cswap auto``.
+
+Companion to claude-swap. Installed as ``claude-swap[pin]``; see
+https://github.com/realiti4/claude-swap/issues/198 for why it lives apart.
+
+**Nothing is imported from :mod:`cswap_pin.proxy` here.** That module reaches
+into claude-swap at import time, so re-exporting its symbols made
+``import cswap_pin`` itself raise ``HostMissing`` when the host was absent —
+from proxy.py line 43, naming neither package, and before any caller could
+catch it. Importing a package must never require the thing the package is
+meant to report on. Reach for ``cswap_pin.proxy`` directly; use
+:func:`host_available` first if you want to check rather than catch.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__", "host_available"]
+
+
+def host_available() -> bool:
+    """Whether claude-swap is importable, i.e. whether the pin can do anything.
+
+    Safe to call with the host missing — that is the case it exists for.
+    """
+    from cswap_pin._host import available
+
+    return available()

cswap_pin-0.1.0/src/cswap_pin/_host.py

@@ -0,0 +1,68 @@
+"""Everything cswap-pin borrows from claude-swap, in one place.
+
+The pin runs INSIDE claude-swap: it is loaded by `claude-swap[pin]`, reads the
+account store cswap owns, and rewrites the config file cswap already rewrites.
+So it needs part of cswap's internals — but "needs part of" is exactly the
+coupling that made splitting the two hard in the first place, and an import
+scattered across 2800 lines is a dependency nobody can see the shape of.
+
+This module IS that shape. Seven symbols, six modules, listed once:
+
+    paths.get_global_config_path      where the env block lives
+    paths.get_claude_config_home      the config dir root
+    settings                          read/write the pin record
+    exceptions.AccountNotFoundError   pin resolution failures
+    exceptions.ConfigError            ...
+    switcher.ClaudeAccountSwitcher    the account store
+    oauth                             token extraction and refresh
+    claude_locks.claude_config_lock   serialize config rewrites
+
+Two rules follow from putting it here:
+
+1. **Nothing else in cswap_pin imports claude_swap directly.** A new import
+   elsewhere grows the contract silently; a new name in this file is a
+   deliberate change to it, visible in one diff.
+2. **claude-swap is a PEER, not a dependency.** It is not in our
+   ``dependencies``: cswap-pin is loaded by claude-swap, so declaring it here
+   would make the pair circular and pull the whole switcher into anyone who
+   installs cswap-pin alone. The import therefore has to be able to fail, and
+   ``require()`` is where that failure gets a readable message instead of a
+   traceback from line 2000 of the proxy.
+"""
+
+from __future__ import annotations
+
+from types import ModuleType
+
+_HINT = (
+    "cswap-pin runs inside claude-swap and cannot find it. "
+    "Install the pair together: pip install 'claude-swap[pin]'"
+)
+
+
+class HostMissing(RuntimeError):
+    """claude-swap is not importable, so the pin has nothing to pin."""
+
+
+def require(name: str) -> ModuleType:
+    """Import a claude_swap submodule, or fail with something readable.
+
+    ``name`` is the part after ``claude_swap.`` — ``require("paths")`` gets
+    ``claude_swap.paths``.
+    """
+    import importlib
+
+    try:
+        return importlib.import_module(f"claude_swap.{name}")
+    except ImportError as exc:  # noqa: TRY003 — the message IS the point
+        raise HostMissing(_HINT) from exc
+
+
+def available() -> bool:
+    """Whether the host is importable at all. For callers that want to check
+    rather than catch."""
+    try:
+        require("paths")
+    except HostMissing:
+        return False
+    return True