spinup

spinup

Set up every computer you code with AI on, keep them the same, and share your Claude and Codex accounts between them.

You have a desktop, a laptop, maybe a Mac. On each one you install the same tools, copy the same skills, and sign in to the same accounts — then watch them drift apart.

spinup does that once, per machine:

spinup setup my-desktop --hub

That installs your dev tools, joins your private network, installs your skills and agent settings, and ends with a health check.

One Go binary, no dependencies. Windows, macOS, Linux. Every command is safe to re-run — re-running is how you repair.

What you get

Your accounts, everywhere. One machine holds your Claude and Codex logins. Every other machine uses them at http://localhost:8317. If the holder goes offline, a standby takes over and hands them back when it returns.

The same agents, everywhere. Your skills and instructions live in one folder (~/.spinup) that spinup keeps identical on all your machines. Change it anywhere; the others follow within seconds.

A straight answer when something breaks. spinup doctor checks everything and prints the command that fixes each problem.

Quick start

1. Install

# macOS, Linux
curl -fsSL https://raw.githubusercontent.com/darkyeg/spinup/main/scripts/install.sh | sh

# Windows
irm https://raw.githubusercontent.com/darkyeg/spinup/main/scripts/install.ps1 | iex

Check it worked: spinup --version. Open a new terminal if the command isn't found.

2. Set up the machine that holds your accounts

This is the hub — usually the desktop that's on most. The name you pick becomes its address on your network.

spinup setup my-desktop --hub

Then add your accounts in the dashboard it opens (http://localhost:8317/management.html → OAuth Login).

3. Set up your other machines

Use the same Tailscale account on every machine.

spinup setup my-laptop --standby   # takes over while the hub is off
spinup setup my-mac                # just uses the accounts

Each asks for a key, which spinup keys prints on a machine you already set up.

4. Use it

Run ccp instead of claude to use Claude Code with the shared accounts. Plain claude keeps its own login.

Prefer your agent to do all this? Tell it "set up this machine with spinup" and it will follow docs/SETUP.md.

Commands

spinup <command> --help explains each one.

Skills

Your skills live in one folder, your library (~/.spinup/skills). spinup copies it to every machine and links it into Claude Code and Codex. Edit a skill on any machine; the others follow within seconds.

spinup skills        # see them all, and change them

It opens a list with three tabs:

Arrows move, space marks, tab switches list, q quits. Then d remove, a keep everywhere, r restore, m auto/manual, n rename. Outside a terminal, or with --plain, it prints the list and changes nothing.

Bring a skill in

Auto or manual? An auto skill's description costs tokens in every session. A manual one costs nothing until you call it (/name in Claude Code, $name in Codex). Press m to switch.

spinup installs for the agents it finds on the machine; you don't list them. More: docs/LIBRARY.md.

Make it yours

For complete plugins such as Superpowers, use spinup packages add obra/superpowers. Spinup keeps the package intact, pins its revision and installs it through each tool's native plugin manager. spinup packages plan, update, rollback and remove manage its lifecycle. Existing standalone skills keep working. See plugin packages before enabling package synchronization across older machines.

Create the optional ~/.spinup/AGENTS.md yourself, then run spinup agents. Spinup appends your instructions to both Claude Code and Codex, and the library service syncs them between your machines. Models, effort and limits stay in your local agent settings; spinup does not choose them or bundle subagents. See agent configuration. To change shared guidelines or supply your own defaults (stack rules, agents/, tools.json), fork the repo: spinup uses the checkout it runs in, or SPINUP_REPO.

How it works

 computer running spinup ── localhost:8317 ─────────┐
 phone on Tailscale ─────── <hub-or-standby>:8317 ──┴── current holder's CLIProxyAPI
                         private Tailscale network

spinup runs on each machine and routes to whichever one currently holds the accounts.

• Names, not IPs. Tailscale gives each machine a fixed private address and the name you chose. At home, traffic goes straight over your router; away, over the internet.
• No machine list to keep. Tailscale is the list; spinup reads it.
• One holder at a time. A standby takes over only when Tailscale reports the holder offline and three minutes have passed — never just because it can't be reached. This is what stops two machines refreshing the same login and locking you out.
• Changes travel in seconds. With a hub or standby online, your library reaches every machine; disconnected ones catch up when they return.

Port 8317 is spinup's router; CLIProxyAPI uses 8327 internally, and only on the holder. Each machine has its own localhost, so the same port everywhere is fine.

In plain words: docs/HOW-IT-WORKS.md. The safety design: docs/DESIGN.md. Day-to-day: docs/SERVICE.md.

Good to know

• A Mac shouldn't be your hub. Its service runs as a LaunchAgent, so it holds the accounts only while you're logged in. Use an always-on Linux or Windows machine.
• Agent settings are merged locally, not copied between machines. Run spinup agents on each. Keep credentials and machine-specific paths local: docs/AGENT-CONFIG.md.
• A phone without spinup points at an online hub or standby by name (http://my-desktop:8317) with the API key. If that machine goes offline, point it at another; spinup doesn't move one address between machines.
• Before trusting a new build across machines, follow the validation guide. A local health check doesn't exercise failover.
• Building from source? go install ./cmd/spinup from a checkout. Unreleased changes don't arrive through spinup update.
• Trying a nightly? Main builds publish GitHub prereleases with a -nightly suffix. Download the matching binary and verify it against that release's checksums.txt. Normal installers and spinup update use stable releases; they do not subscribe a machine to nightlies. A nightly can update to the same version's stable release once published.

Security

• Nothing faces the internet. The accounts are reachable only on your tailnet, and Tailscale traffic is end-to-end encrypted. On Windows a firewall rule limits the port to Tailscale addresses.
• Keys stay on your machines (secrets.json, never committed). Machines prove they know the key before any login is sent to them.
• Downloads are checksum-verified, both spinup's updates and CLIProxyAPI's.
• Turn on 2FA for GitHub and Tailscale, and disable Tailscale key expiry for your machines — doctor warns you.
• Found a problem? SECURITY.md.

Important

Routing subscription accounts through a proxy may conflict with your provider's terms. Read them and decide for yourself; you are responsible for how you use your accounts. spinup's own rule: use Claude accounts only through Claude Code (ccp, or T3 Code's Claude provider), never from other apps.

The accounts service keeps one holder active to avoid competing login refreshes. An abrupt failure just after a refresh can still mean logging that account in again: the service limits.

Contributing

Ideas and fixes are welcome: CONTRIBUTING.md. Terms used everywhere: GLOSSARY.md.

License

MIT