A local web UI to manage multiple Claude Code profiles on one machine.

Quick Start • Features • Screenshots • How It Works • Usage • Documentation • Configuration • Troubleshooting • License

cc-profiles keeps your Claude Code profiles in order: work and personal accounts side by side, each with its own memory, conversations, skills, MCP servers and settings. Move projects and memories between profiles, relink projects whose folder moved, share skills and plugins, and edit settings with safe dropdowns, all from a page in your browser. Every change is backed up first, so anything you do can be undone with one click.

Quick Start

Install with a single command:

curl -fsSL https://raw.githubusercontent.com/andreaiannarone/cc-profiles/main/install.sh | sh

The script installs cc-profiles with pipx or uv, whichever you have, and adds a /cc-profiles command to Claude Code in every profile. It never uses sudo and writes only in your home folder; read it first if you like. Run it again to update. To install the app without touching your profiles:

curl -fsSL https://raw.githubusercontent.com/andreaiannarone/cc-profiles/main/install.sh | sh -s -- --no-command

Then open it, from a terminal or from inside Claude Code:

cc-profiles          # starts on http://127.0.0.1:4777 and opens your browser

/cc-profiles         # inside any Claude Code session: opens the app and the session goes on
/cc-profiles restart # restarts it, e.g. after an update (/cc-profiles stop stops it)

On the first run, cc-profiles finds ~/.claude and every ~/.claude-<name> folder that looks like a profile. Rename them from the Profiles tab.

pipx install cc-profiles        # or: uv tool install cc-profiles
cc-profiles                     # the first start adds /cc-profiles to Claude Code

brew install andreaiannarone/cc-profiles/cc-profiles

uvx cc-profiles

/plugin marketplace add andreaiannarone/cc-profiles
/plugin install cc-profiles@cc-profiles

git clone https://github.com/andreaiannarone/cc-profiles.git
cd cc-profiles
python3 -m pip install -e .
cc-profiles

Unofficial. cc-profiles is a community project, not affiliated with or endorsed by Anthropic. It works with Claude Code's on-disk files, whose format is undocumented and may change between releases. That is why every operation it performs creates a backup you can restore with one click.

Key Features

• 🗂️ Projects: see which profile each project belongs to and what it holds in each one. Move a project to another profile with its conversations, memories, file snapshots, prompt history and per-project settings, after a preview of every file it touches. Relink a project whose folder you moved or renamed. Assign projects with simple path rules.
• 🧠 Memories: browse, edit, move and delete the memories of every project, with the MEMORY.md indexes kept in sync.
• 💬 Conversations: read the conversations of every project, and move a single one to another profile, with its file snapshots, or delete it.
• 📊 Usage: tokens per day, per project, per model and per profile, with an estimated cost at list price (subscription plans are not billed per token), read from the conversations Claude Code saves.
• 👤 Profiles: see the account each profile is signed in with. Create a profile, empty, copied from another one or from a template you saved (settings, permissions, skills, MCP servers; never conversations or credentials); rename it, change its command, or delete it, optionally merging its content into another profile first, after a preview of everything it touches.
• 🧩 Skills: browse, create, edit, copy and delete the skills of each profile, or copy one to every profile at once.
• 🔌 MCP servers: add, edit, copy (to one profile or to all) and remove MCP servers, for every project or for one. Tokens in environment variables and headers stay out of the list.
• 🧳 Export and import: move a profile to another computer as a .zip, with or without conversations. Login credentials never travel.
• 🧷 Plugins: see the plugins installed in each profile, their version and marketplace, and turn them on or off.
• 📁 Profile by folder: type claude in a work folder and it starts in your Work profile. One switch in the Profiles tab adds one marked line to your ~/.zshrc (backed up, undoable); the folder rules you already use for projects decide the profile, and a CLAUDE_CONFIG_DIR you set yourself still wins.
• 🔗 Sharing: share skills, plugins, agents, commands, CLAUDE.md or settings.json with the source profile through symlinks. Install once, use everywhere. The confirmation previews what the link replaces.
• ⚙️ Settings: every setting of Claude Code's /config panel, in groups, plus the commit and pull request attribution switches. Dropdowns offer only the values Claude Code accepts and show which file each value comes from. Apply a value or a permission rule to every profile in one undoable step. Edit CLAUDE.md, permissions and the raw JSON, with validation.
• 📟 Status line: build Claude Code's status line without writing a script. Tick what to show (profile, model, path, git branch, context used, tokens, session cost, 5-hour and weekly limits and more), drag it into order, pick brackets, separator and colors or start from a preset, and check the live preview; one click puts it in every profile. A small sh + jq script, never your own one overwritten. How it works
• ⏪ Backups: every operation is journaled. Restore undoes it, and a restore can itself be undone. Old ones are deleted automatically after 90 days (or 15, 30, 60), except those you mark Keep.
• 🩺 Health: login status, config validity, broken links, memory indexes, and projects whose folder disappeared, with candidate folders to relink them to.
• 🔍 Search everything: one field searches projects, memories, skills, MCP servers and CLAUDE.md in every profile, and opens what you pick.
• ⚖️ Compare two profiles: settings, permissions, skills, MCP servers, CLAUDE.md and plugins side by side, with one-click copies of what differs.
• 🧭 Fast to get around: keyboard shortcuts (/ to search, g then a letter to open a tab, ? for the list), and quick even on homes with thousands of projects.
• ⌨️ Inside Claude Code: /cc-profiles opens the app from any session, /cc-profiles restart restarts it after an update; cc-profiles label shows the active profile in your status line.
• 🌓 Light and dark: the theme button in the header picks System, Light or Dark; System follows your operating system.
• 🔒 Local and private: listens on 127.0.0.1 only, with a token on every request. Nothing is sent anywhere unless you click to check for updates or to install Claude Code.
• 🔄 Updates from the app: cc-profiles checks PyPI once a day (or when you click Check for updates in the (i) panel) and shows a dot when a new version is out; one click updates and restarts it (pipx, uv or Homebrew), then it shows what's new. Report a problem… opens a bug report with the versions filled in.

Screenshots

Memories: every project's memories, with an editor	Conversations: read, move or delete a single conversation
Usage: tokens and estimated cost per day, project and model	Status line: build it by ticking boxes, with a live preview
Skills: browse, create, edit and copy skills	MCP: servers for every project or for one
Compare: two profiles side by side, one-click copies	Settings: everything in /config, applied to one profile or all

The screenshots show sample data from the /sandbox skill. GitHub shows them in your theme, light or dark.

Why

Claude Code reads its configuration from ~/.claude, or from whatever directory CLAUDE_CONFIG_DIR points to. Each directory is a separate profile with its own memory, conversations, prompt history, settings and login:

claude                                     # default profile (~/.claude)
CLAUDE_CONFIG_DIR=~/.claude-work claude    # a second profile

That is great for keeping contexts apart, but maintaining profiles by hand is painful:

• Conversations live in folders named like -Users-you-code-client--api, one per project path.
• The prompt history is one JSONL file to filter line by line.
• The default profile's settings live in ~/.claude.json, outside ~/.claude.
• When you move a project folder, Claude Code silently loses its history.

cc-profiles does all of this for you, from a page in your browser.

How It Works

Core components:

1. Local server: a small Python package, standard library only, one module per area. It listens on 127.0.0.1, checks the Host header against DNS rebinding and a random token against requests from other websites.
2. Single-page UI: one HTML file with inline CSS and vanilla JavaScript, no build step and nothing loaded from the internet. Light and dark themes, or the system's.
3. Backups with a journal: before any change, the files it touches are copied to ~/.cc-profiles/backups/<date>_<operation>/, and every step (copy, move, new folder, new link) is written to a manifest.json. Restore replays the journal backwards.
4. Atomic writes: every file is written to a temporary file in the same folder and then renamed, so a running Claude Code never reads a half-written file. Writes follow symlinks, so shared files stay shared.
5. Path recovery: Claude Code's project folder names cannot be turned back into paths. cc-profiles rebuilds them from config files, prompt history and the cwd of conversations, and walks the disk when nothing mentions them.
6. Launchers and commands: new profiles get a small claude-<id> script in ~/.local/bin; the app adds /cc-profiles to Claude Code the first time it starts and keeps it up to date. Files cc-profiles creates carry a mark, and it never overwrites a file without it.

See Architecture and Claude Code's on-disk formats for details.

Usage

cc-profiles                   # starts on http://127.0.0.1:4777 and opens the browser; ctrl+C stops it
cc-profiles --port 4800       # another port
cc-profiles --no-browser      # just the server
cc-profiles open              # starts it in the background if needed, opens the browser and returns
cc-profiles restart           # stops it and starts it again, e.g. after an update (cc-profiles stop only stops it)
cc-profiles install-command   # adds /cc-profiles again (the app does it by itself); --off: never add it
cc-profiles label             # prints the name of the active profile, for status lines

Open it from Claude Code

Type /cc-profiles in any Claude Code session: the app starts in the background, your browser opens on it, and the session goes on. /cc-profiles restart and /cc-profiles stop restart or stop the app. The command is a small file, commands/cc-profiles.md: cc-profiles writes it in every profile the first time it starts, rewrites it after an update, and adds it to the profiles you create from the app. A copy you delete stays deleted. Profiles that share commands with the source profile get it through the link.

Commands for each profile

When cc-profiles creates a profile, it adds a launcher to ~/.local/bin. For a profile called work that is claude-work:

#!/bin/sh
CLAUDE_CONFIG_DIR="$HOME/.claude-work" exec claude "$@"

The script works in every shell. Make sure ~/.local/bin is in your PATH; the official Claude Code installer usually adds it.

Show the profile in your status line

cc-profiles label prints the name of the profile in use, based on CLAUDE_CONFIG_DIR. Call it from your Claude Code status line script:

profile=$(cc-profiles label 2>/dev/null)
printf '(%s) ' "$profile"

Rules

The Projects tab assigns each project to a profile using rules: "a path containing this text belongs to that profile". Create them from the UI with Assign…. They are checked in order, the first match wins and new rules go first:

{ "match": "code/work", "profile": "work" }

"profile": "shared" marks paths that may appear in every profile, like your home folder.

Documentation

📚 Full documentation at cc-profiles.andreaia.com

Getting Started

• Why cc-profiles: what it adds to CLAUDE_CONFIG_DIR and shell aliases
• Getting started: install, first run, launcher commands, /cc-profiles
• Concepts: profiles, the source profile, projects, rules, sharing, backups
• FAQ: several accounts, a profile per project, credentials, safety, undo

How-to

• Separate work and personal: a Work profile in five minutes
• Move a project: with its conversations, memories, history and settings
• Relink a moved folder: get the history back after renaming a folder
• Share skills between profiles: share the folder or copy one skill

Guides by Tab

• Projects: move, relink, assign
• Memories: browse, edit, move
• Conversations: read, move one to another profile, delete
• Usage: tokens and estimated cost per day, project, model and profile
• Profiles and sharing: create, edit, delete, share
• Profile by folder: claude starts in the profile of the folder you are in
• Skills and MCP servers: create, edit, copy, delete
• Plugins: see the installed plugins and turn them on or off
• Search and compare: search every profile at once, compare two side by side
• Export and import: move a profile to another computer
• Settings: the /config settings, CLAUDE.md, permissions, raw JSON
• Status line: build Claude Code's status line in Settings, or write your own
• Backups: what gets saved and how restoring works
• Health and About: checks, orphan projects, installing Claude Code

Reference

• Configuration: config.json, command line, environment variables
• Troubleshooting: common problems and their fixes
• Glossary: the words the app uses
• Uninstall: remove cc-profiles; your profiles stay as they are
• What's new: every release

For Contributors

• Architecture: how the code is organized and why
• Claude Code's on-disk formats: what the app reads and writes
• HTTP API: every endpoint the UI uses
• Contributing and design system

Configuration

cc-profiles keeps its own data in ~/.cc-profiles/, never in the repository:

See the Configuration reference for config.json and every option.

System Requirements

• macOS or Linux; on Windows, inside WSL 2
• Python 3.9 or later: macOS's built-in Python works
• pipx, uv or Homebrew to install it
• Claude Code, or let cc-profiles install it for you with the official installer

No dependencies: cc-profiles uses only the Python standard library.

Security

• The server listens on 127.0.0.1 only and accepts only Host: 127.0.0.1:<port> or localhost:<port>, which blocks DNS rebinding.
• Every API call needs a random token, generated at each start and embedded in the page, so other websites cannot control the app.
• Writes are atomic (temporary file, then rename), so Claude Code never reads a half-written file, even while it is running.
• Names of projects, memories, skills and backups are validated against path traversal.
• Login credentials are never copied between profiles: each profile signs in on its own. Copying an MCP server copies its configuration, never its sign-in.
• cc-profiles reaches the internet only to ask pypi.org for its latest version, once a day (PyPI sees your IP address; turn it off in the (i) panel to check only when you click), and when you click Install to run the official Claude Code installer.

See SECURITY.md to report a vulnerability.

Limitations

• Claude Code's file formats are not a public API. Settings dropdowns were checked against Claude Code 2.1.289; the About panel shows which version you have.
• "Session open" means a claude process is running in the profile (read from the process list on macOS and from /proc on Linux), or a conversation was written in the last 2 minutes.
• Claude Code keeps .claude.json in memory while it runs: restart open sessions after changing their MCP servers.
• Deleting a profile does not remove credentials that Claude Code may have stored in the macOS Keychain for it.

Troubleshooting

See the Troubleshooting guide for more.

Contributing

Contributions are welcome! Please:

1. Fork the repository and create a branch
2. Make your changes with tests: every operation that writes must go through Backup and have a test that restores it
3. Keep it standard library only and compatible with Python 3.9
4. Update the documentation and CHANGELOG.md
5. Open a pull request

See CONTRIBUTING.md to run the app and the tests locally. If you use Claude Code, the repository's .claude/ folder keeps you on a sandbox and has skills for the common chores. Good first contributions: translations (the UI is English only), Windows support, a "dry run" preview for big operations.

License

cc-profiles is licensed under the GNU General Public License v3.0 or later. © Andrea Iannarone

You can use, study, change and share it freely. If you distribute it, modified or not, you must do so under the same license and with the source code. Version 0.1.0 was released under MIT and stays available under it.

Support

• Documentation: cc-profiles.andreaia.com
• Issues: GitHub Issues
• Repository: github.com/andreaiannarone/cc-profiles
• Buy me a coffee: buymeacoffee.com/andreaiannarone
• Author: Andrea Iannarone (@andreaiannarone)

Built with Claude Code | Made for Claude Code | Pure Python standard library

© 2026 Andrea Iannarone