Code Assistant Manager (CAM)

One CLI to Rule Them All.

Tired of juggling multiple AI coding assistants? CAM is a unified Go CLI to manage configurations, instructions, skills, plugins, MCP servers, and launch settings for 17 AI assistants including Claude, Codex, Gemini, Qwen, Copilot, Blackbox, Goose, Continue, and more from a single terminal interface.

Installation

Prerequisites

• Go 1.26.2 or newer

Quick Install (Recommended)

Since CAM is distributed from source, build and install the Go binaries locally:

# Clone the repository
git clone https://github.com/Chat2AnyLLM/code-agent-manager.git
cd code-agent-manager

# Run the install script
./install.sh

Alternative Methods

# Install using the install script directly
./install.sh

# Or install from the web
curl -fsSL https://raw.githubusercontent.com/Chat2AnyLLM/code-agent-manager/main/install.sh | bash

# Install from source directly
git clone https://github.com/Chat2AnyLLM/code-agent-manager.git
cd code-agent-manager
go test ./...
go build -o dist/cam ./cmd/cam

Quick Start

1. Create your base config files: bash mkdir -p ~/.config/code-agent-manager touch ~/.env chmod 600 ~/.env

2. Set up your API keys in .env: bash export ANTHROPIC_API_KEY="your-anthropic-key" export GITHUB_TOKEN="your-github-token" export GEMINI_API_KEY="your-gemini-key"

3. Source the environment file and verify setup: bash source ~/.env cam doctor

4. Launch the interactive menu: bash cam launch

5. Select your assistant and start coding!

Desktop App and Developer Workflow

CAM now uses a Tauri desktop shell with a Go sidecar API. The same Go backend packages power both the terminal CLI and the desktop UI, so provider and launch behavior stays consistent across interfaces.

Start the desktop app

Use make start from the repository root:

make start

make start, make app, and make dev all run the same full desktop startup path. They build the Go sidecar expected by Tauri, start the Vite frontend dev server through Tauri, and open the desktop window.

Start browser-only frontend

Use this when you only want the React UI in a browser with mock/fallback data or a manually configured sidecar URL:

make frontend

The browser frontend listens on http://127.0.0.1:5173 by default. Override the host or port when needed:

make frontend FRONTEND_HOST=127.0.0.1 FRONTEND_PORT=5174

Start the Go sidecar directly

Use this for API testing without opening the desktop window:

make sidecar

By default, the sidecar binds to 127.0.0.1 and chooses a random port (SIDECAR_PORT=0). It prints startup JSON containing the selected port and bearer token. Override values when needed:

make sidecar SIDECAR_PORT=54321

Build desktop assets and sidecar

make desktop-build

This runs the frontend production build, builds the Go sidecar, and checks the Tauri shell with Cargo. On Windows, the Makefile sets CARGO_HTTP_CHECK_REVOKE=false to avoid certificate revocation-check failures when Cargo downloads crates.

Other useful make targets

make start  # start the full Tauri desktop app
make build   # build CLI binaries and sidecar into dist/
make test    # run Go tests
make check   # run Go vet, Go tests, frontend tests/build, sidecar build, and cargo check
make clean   # remove generated build outputs

Configuration files

CAM uses these main configuration files:

• ~/.config/code-agent-manager/cam.db: SQLite app state database that stores providers and other state.
• ~/.env: API keys and sensitive environment variables.
• ~/.config/code-agent-manager/config.yaml: repository-source config for instructions, skills, agents, and plugins.

How config.yaml is used for instruction/skill/agent/plugin repos

• CAM loads ~/.config/code-agent-manager/config.yaml first; if missing, it falls back to the bundled Go config at internal/camconfig/embed/config.yaml.
• The file defines source lists for instructions, skills, agents, and plugins.
• Local JSON sources (instruction_repos.json, skill_repos.json, agent_repos.json, plugin_repos.json) are loaded first.
• Remote sources are merged after local sources and do not override existing local keys.
• Remote responses are cached in ~/.cache/code-agent-manager/repos (TTL controlled by config.yaml).

Why CAM?

In the era of AI-driven development, developers often use multiple powerful assistants like Claude, GitHub Copilot, and Gemini. However, this leads to a fragmented and inefficient workflow:

• Scattered Configurations: Each tool has its own setup, API keys, and configuration files.
• Inconsistent Behavior: System prompts and custom instructions diverge, leading to different AI behaviors across projects.
• Wasted Time: Constantly switching between different CLIs and UIs is a drain on productivity.

CAM solves this by providing a single, consistent interface to manage everything, turning a chaotic toolkit into a cohesive and powerful development partner.

Key Features

Core Capabilities

• Unified Management: One tool (cam) to install, configure, and run all your AI assistants
• Centralized Configuration: Manage API keys with environment variables in .env and persist provider settings in CAM's SQLite app state
• Interactive TUI: A polished, interactive menu (cam launch) for easy navigation and operation with arrow-key navigation
• MCP Registry: Built-in registry with 381 pre-configured MCP servers ready to install across all supported tools
• Extensible Framework: Standardized architecture for managing agents, instructions, skills, and plugins

Supported AI Assistants

CAM supports 17 AI coding assistants:

Agents, Instructions & Skills

Agents

Manage standalone assistant configurations with markdown-based definitions and YAML front matter.

Instructions

Managed coding-agent instruction files such as CLAUDE.md, AGENTS.md, GEMINI.md, and Copilot instruction files, installable at user or project scope where supported.

Skills

Custom tools and functionalities for your agents (directory-based with SKILL.md).

Plugins

Marketplace extensions for supported assistants (GitHub repos or local paths).

Command Reference

Note: non-boolean CLI options are long-form only. For example, use --config and --scope (not -c or -s).

Governance & Quality

CAM is governed by a speckit-driven development framework ensuring consistent, high-quality evolution with: - Constitutional Principles: Unified interface, security-first design, TDD practices, extensible architecture, quality assurance - Enterprise Security: Config-first approach eliminates shell injection vulnerabilities - Comprehensive Testing: Enterprise-grade test suite with 1,423+ tests - Automated Quality Assurance: Built-in complexity monitoring, file size limits, and CI/CD quality gates

Community & Support

• Discord: Join our community for discussions and support
• GitHub Issues: Report bugs and request features
• Contributing: See our Contributing Guidelines

License

This project is licensed under the MIT License.