Janus

A small macOS app for people who keep more than one Claude Code account, and who have noticed how much disk the tools they use every day quietly hold onto.

One click moves the live session, and the account it displaces is saved first.

It does two things:

• Switches Claude Code accounts. Signing in as another account normally means signing out first and typing the whole thing again. Janus saves each account's session and puts it back on demand, so the second account is one click away instead of one login away.
• Clears developer caches. A list of directories that are safe to delete, measured and shown with what each one costs to lose. Everything goes to the Trash rather than being deleted, so any decision can be taken back.

Install

With Homebrew:

brew install --cask --no-quarantine ramitvishwakarma/tap/janus

Or download the latest .dmg from Releases, open it, and drag Janus to Applications. The build is universal, covering Apple silicon and Intel.

The app is signed ad-hoc rather than with a paid Apple Developer certificate, so macOS quarantines it on first launch and says the developer cannot be verified. --no-quarantine tells Homebrew to skip that flag. After a download by hand, clear it once:

xattr -dr com.apple.quarantine /Applications/Janus.app
open /Applications/Janus.app

To have it start with the Mac, add it under System Settings → General → Login Items, or:

osascript -e 'tell application "System Events" to make login item \
  at end with properties {path:"/Applications/Janus.app", hidden:true}'

Build it yourself

Needs the Xcode Command Line Tools (xcode-select --install). Xcode itself is not required.

git clone https://github.com/RamitVishwakarma/Janus.git
cd Janus
./build.sh
open Janus.app

Using it

Janus cannot sign in for you, so the first account has to be signed in already. Press Save current account and it is captured.

For the second: sign out of Claude Code, sign in as the other account, come back, and press Save current account again. From then on both are in the list and switching between them is one click, or ⌘S from the menu bar.

The menu bar item shows which account is live. The window shows both accounts with how much of their five-hour and weekly limits each has spent. That is the number to look at when the decision you are making is which account has room left.

Where the usage figures come from

Claude Code asks Anthropic for your limits while a session is running and writes the answer into its own settings file. Janus reads that file for nothing, which is what every row shows to begin with. For the account that is signed in, those figures are as current as your last session. For an account that is not, they are whatever it had spent at the moment you switched away — frozen, and increasingly wrong the longer it sits there.

Refresh goes and asks. It calls Anthropic's usage endpoint once per account, with the tokens that account already has saved, and shows what comes back. That is the only network request Janus makes, it goes nowhere but api.anthropic.com and platform.claude.com, and nothing is sent that is not the account's own credentials. The line under each pair of bars says which of the two you are looking at, so a fetched figure and a three-day-old one are never confusable.

Two things happen on their own, without the button:

• The window keeps its own time. Countdowns tick down and a limit that passes its reset empties itself while you are looking at it, rather than waiting for the next time something forces a redraw.
• A window turning over is fetched. That is the one moment the old figure becomes actively misleading — it is the spend of a window that has ended — so it is the one moment Janus spends a request without being asked.

A limit past its reset shows a dash until it has been fetched. Guessing at the replacement would be worse than admitting there isn't one yet.

Saved accounts are renewed as needed: an access token that has expired is refreshed before the usage request, and the tokens that come back are written into the vault before anything else is attempted with them. The signed-in account's token is never renewed by Janus, because a running Claude Code session is holding it, and rotating it underneath that session is how a sign-in that was working stops working. Claude Code keeps that one fresh itself.

How switching works

A signed-in Claude Code session is two things on disk:

Switching is just moving that pair. Janus copies the live pair into storage under the account it belongs to, then writes the other account's saved pair into place. Saved tokens go into the login keychain under the service Janus; saved settings go to ~/Library/Application Support/Janus/, readable only by you.

Three things follow from that, and are worth knowing before you trust it:

• Nothing leaves the Mac except a usage request you asked for. There is no server and no telemetry. The one thing that goes out is Refresh asking Anthropic for your own figures with your own tokens, described above.
• The settings file is written back whole. It belongs to another program and gains keys between releases, so Janus parses what it needs and preserves everything else byte for byte.
• Switching does not affect a running session. Claude Code reads credentials at startup, so restart it to pick up the new account.

If something goes wrong halfway

Every switch fetches the replacement session before it touches anything live, and saves the session it is about to displace before overwriting it. If a step fails, say a declined keychain prompt or a missing saved session, the Mac is left signed into the account it was already signed into.

Signing in outside the app is handled too. If the live account is not one Janus knows about, it is saved as a new account rather than overwritten, because those credentials exist nowhere else.

Clearing caches

The Storage tab measures a fixed list of cache directories: package managers, build caches, browser and editor caches. Two rules keep it boring:

• Nothing is deleted. FileManager.trashItem moves things to the Trash.
• Only caches inside your home directory can be touched. Anything outside it is refused, as are the directories everything else lives inside, among them ~/Desktop, ~/Library, ~/.ssh and ~/.claude. This is enforced in code, not by being careful when editing the list, and there is a test asserting every entry in the catalogue passes it.

Caches belonging to a running app are shown greyed out with a Quit it link rather than cleared underneath it. Clearing an editor's cache while the editor holds files open in it is a good way to confuse the editor.

Some paths, ~/Downloads and ~/.Trash among them, are behind macOS privacy controls. Grant Full Disk Access in System Settings → Privacy & Security if you want them covered.

Adding a cache to the list

Add an entry to CacheEntry.developerTools or CacheEntry.applications in Sources/JanusCore/CacheCatalog.swift:

CacheEntry(id: "cargo", name: "Cargo registry",
           note: "Downloaded crate sources, refetched on the next build.",
           path: ".cargo/registry")

Paths are relative to the home directory. Entries that do not exist on a given Mac are filtered out when scanning, so listing something niche costs nothing.

Known limitations

• Ad-hoc signed. Every build produces a different signature, so macOS treats each new version as a new app and may ask for keychain permission again after an update. Signing with a self-signed certificate from Keychain Access gives a stable identity if that becomes annoying.
• Not sandboxed. The App Sandbox would cut the app off from the keychain entry and settings file it exists to move, which also means it cannot ship on the App Store.
• macOS only. Both halves of a session are stored in macOS-specific places.

Development

swift build          # build
swift test           # run the tests (needs Xcode for XCTest)
./build.sh           # assemble Janus.app

The code is split so the interesting half can be tested without a window on screen:

swift build needs only the Command Line Tools; swift test needs XCTest, which ships with Xcode. CI runs the tests on every push and pull request.

Contributing

Issues and pull requests are welcome. See CONTRIBUTING.md. Security reports have their own route in SECURITY.md.

License

MIT.

Janus is not affiliated with, endorsed by, or supported by Anthropic. It reads and writes files and keychain entries belonging to Claude Code,