English | 中文

Control your local AI agents from any chat app. Anywhere, anytime.

cc-connect bridges AI agents running on your machine to the messaging platforms you already use. Code review, research, automation, data analysis — anything an AI agent can do, now accessible from your phone, tablet, or any device with a chat app.

         You (Phone / Laptop / Tablet)
                    │
    ┌───────────────┼───────────────┐
    ▼               ▼               ▼
 Feishu          Slack          Telegram  ...9 platforms
    │               │               │
    └───────────────┼───────────────┘
                    ▼
              ┌────────────┐
              │ cc-connect │  ← your dev machine
              └────────────┘
              ┌─────┼─────┐
              ▼     ▼     ▼
         Claude  Gemini  Codex  ...7 agents
          Code    CLI   OpenCode / iFlow

Time to uninstall OpenClaw — cc-connect gives you access to the most powerful AI agents available, not just one.

• 7 AI Agents — Claude Code, Codex, Cursor Agent, Qoder CLI, Gemini CLI, OpenCode, iFlow CLI. Use whichever fits your workflow, or all of them at once.
• 9 Chat Platforms — Feishu, DingTalk, Slack, Telegram, Discord, WeChat Work, LINE, QQ, QQ Bot (Official). Most need zero public IP.
• Multi-Bot Relay — Bind multiple bots in a group chat and let them communicate with each other. Ask Claude, get insights from Gemini — all in one conversation.
• Full Control from Chat — Switch models (/model), change permission modes (/mode), manage sessions, all via slash commands.
• Agent Memory — Read and write agent instruction files (/memory) without touching the terminal.
• Scheduled Tasks — Set up cron jobs in natural language. "Every day at 6am, summarize GitHub trending" just works.
• Voice & Images — Send voice messages or screenshots; cc-connect handles STT/TTS and multimodal forwarding.
• Multi-Project — One process, multiple projects, each with its own agent + platform combo.

Left：Lark  |  Telegram  |  Right：Wechat

• Claude Code: Claude Code CLI installed and configured, OR
• Codex: Codex CLI installed (npm install -g @openai/codex), OR
• Cursor Agent: Cursor Agent CLI installed (agent --version to verify), OR
• Gemini CLI: Gemini CLI installed (npm install -g @google/gemini-cli), OR
• Qoder CLI: Qoder CLI installed (curl -fsSL https://qoder.com/install | bash), OR
• OpenCode: OpenCode installed (opencode --version to verify), OR
• iFlow CLI: iFlow CLI installed (npm i -g @iflow-ai/iflow-cli or iflow --version)

Send this to Claude Code or any AI coding agent, and it will handle the entire installation and configuration for you:

Please refer to https://raw.githubusercontent.com/chenhg5/cc-connect/refs/heads/main/INSTALL.md to help me install and configure cc-connect

Via npm:

npm install -g cc-connect

Download binary from GitHub Releases:

# Linux amd64
curl -L -o cc-connect https://github.com/chenhg5/cc-connect/releases/latest/download/cc-connect-linux-amd64
chmod +x cc-connect
sudo mv cc-connect /usr/local/bin/

Build from source (requires Go 1.22+):

git clone https://github.com/chenhg5/cc-connect.git
cd cc-connect
make build

# Global config (recommended)
mkdir -p ~/.cc-connect
cp config.example.toml ~/.cc-connect/config.toml
vim ~/.cc-connect/config.toml

# Or local config (also supported)
cp config.example.toml config.toml

./cc-connect                              # auto: ./config.toml → ~/.cc-connect/config.toml
./cc-connect -config /path/to/config.toml # explicit path
./cc-connect --version                    # show version info

# npm
npm install -g cc-connect

# Binary self-update
cc-connect update

cc-connect update --pre

Each platform requires creating a bot/app on the platform's developer console. We provide detailed step-by-step guides:

Quick config examples for each platform:

# Feishu
[[projects.platforms]]
type = "feishu"
[projects.platforms.options]
app_id = "cli_xxxx"
app_secret = "xxxx"

# DingTalk
[[projects.platforms]]
type = "dingtalk"
[projects.platforms.options]
client_id = "dingxxxx"
client_secret = "xxxx"

# Telegram
[[projects.platforms]]
type = "telegram"
[projects.platforms.options]
token = "123456:ABC-xxx"

# Slack
[[projects.platforms]]
type = "slack"
[projects.platforms.options]
bot_token = "xoxb-xxx"
app_token = "xapp-xxx"

# Discord
[[projects.platforms]]
type = "discord"
[projects.platforms.options]
token = "your-discord-bot-token"

# LINE (requires public URL)
[[projects.platforms]]
type = "line"
[projects.platforms.options]
channel_secret = "xxx"
channel_token = "xxx"
port = "8080"

# WeChat Work (requires public URL)
[[projects.platforms]]
type = "wecom"
[projects.platforms.options]
corp_id = "wwxxx"
corp_secret = "xxx"
agent_id = "1000002"
callback_token = "xxx"
callback_aes_key = "xxx"
port = "8081"
enable_markdown = false  # true only if all users use WeChat Work app (not personal WeChat)

# QQ (via NapCat/OneBot v11, no public IP needed)
[[projects.platforms]]
type = "qq"
[projects.platforms.options]
ws_url = "ws://127.0.0.1:3001"
allow_from = "*"  # QQ user IDs, e.g. "12345,67890" or "*" for all

# QQ Bot Official (no public IP needed, no third-party adapter)
[[projects.platforms]]
type = "qqbot"
[projects.platforms.options]
app_id = "your-app-id"
app_secret = "your-app-secret"

All agents support permission modes switchable at runtime via /mode.

Claude Code modes (maps to --permission-mode):

Codex modes (maps to --ask-for-approval):

Cursor Agent modes (maps to --force / --mode):

Gemini CLI modes (maps to -y / --approval-mode):

Qoder CLI modes:

OpenCode modes:

iFlow CLI modes:

# Claude Code
[projects.agent.options]
mode = "default"
# allowed_tools = ["Read", "Grep", "Glob"]

# Codex
[projects.agent.options]
mode = "full-auto"
# model = "o3"

# Cursor Agent
[projects.agent.options]
mode = "default"

# Gemini CLI
[projects.agent.options]
mode = "default"

# Qoder CLI
[projects.agent.options]
mode = "default"

# OpenCode
[projects.agent.options]
mode = "default"

# iFlow CLI
[projects.agent.options]
mode = "default"

Switch mode at runtime from the chat:

/mode          # show current mode and all available modes
/mode yolo     # switch to YOLO mode
/mode default  # switch back to default

Switch between different API providers (e.g. Anthropic direct, relay services, AWS Bedrock) at runtime — no restart needed. Provider credentials are injected as environment variables into the agent subprocess, so your local config stays untouched.

In config.toml:

[projects.agent.options]
work_dir = "/path/to/project"
provider = "anthropic"   # active provider name

[[projects.agent.providers]]
name = "anthropic"
api_key = "sk-ant-xxx"

[[projects.agent.providers]]
name = "relay"
api_key = "sk-xxx"
base_url = "https://api.relay-service.com"
model = "claude-sonnet-4-20250514"

# For special setups (Bedrock, Vertex, etc.), use the env map:
[[projects.agent.providers]]
name = "bedrock"
env = { CLAUDE_CODE_USE_BEDROCK = "1", AWS_PROFILE = "bedrock" }

Via CLI:

cc-connect provider add --project my-backend --name relay --api-key sk-xxx --base-url https://api.relay.com
cc-connect provider add --project my-backend --name bedrock --env CLAUDE_CODE_USE_BEDROCK=1,AWS_PROFILE=bedrock
cc-connect provider list --project my-backend
cc-connect provider remove --project my-backend --name relay

Import from cc-switch:

If you already use cc-switch to manage providers, import them with one command (requires sqlite3):

cc-connect provider import --project my-backend
cc-connect provider import --project my-backend --type claude     # only Claude providers
cc-connect provider import --db-path ~/.cc-switch/cc-switch.db    # explicit DB path

/provider                   Show current active provider
/provider list              List all configured providers
/provider add <name> <key> [url] [model]   Add a provider
/provider add {"name":"relay","api_key":"sk-xxx","base_url":"https://..."}
/provider remove <name>     Remove a provider
/provider switch <name>     Switch to a provider
/provider <name>            Shortcut for switch

Adding, removing, and switching providers all persist to config.toml automatically. Switching restarts the agent session with the new credentials.

Env var mapping by agent type:

The env map in provider config lets you set arbitrary environment variables for any setup (Bedrock, Vertex, Azure, custom proxies, etc.).

Claude Code Router is a powerful tool that routes Claude Code requests to different model providers (OpenRouter, DeepSeek, Gemini, etc.) with custom transformations. cc-connect now supports seamless integration with Claude Code Router.

• Multi-Provider Support: Route requests to OpenRouter, DeepSeek, Ollama, Gemini, Volcengine, SiliconFlow, and more
• Model Routing: Use different models for different tasks (background, thinking, long context, web search)
• Request/Response Transformation: Automatic adaptation for different provider APIs
• Dynamic Model Switching: Switch models on-the-fly without restarting

1. Install Claude Code Router:

npm install -g @musistudio/claude-code-router

2. Configure Router (create ~/.claude-code-router/config.json):

{
  "APIKEY": "your-secret-key",
  "Providers": [
    {
      "name": "openrouter",
      "api_base_url": "https://openrouter.ai/api/v1/chat/completions",
      "api_key": "sk-xxx",
      "models": ["anthropic/claude-sonnet-4", "google/gemini-2.5-pro-preview"],
      "transformer": { "use": ["openrouter"] }
    },
    {
      "name": "deepseek",
      "api_base_url": "https://api.deepseek.com/chat/completions",
      "api_key": "sk-xxx",
      "models": ["deepseek-chat", "deepseek-reasoner"],
      "transformer": { "use": ["deepseek"] }
    }
  ],
  "Router": {
    "default": "deepseek,deepseek-chat",
    "think": "deepseek,deepseek-reasoner",
    "longContext": "openrouter,google/gemini-2.5-pro-preview"
  }
}

3. Start Router:

ccr start

4. Configure cc-connect (in config.toml):

[projects.agent.options]
work_dir = "/path/to/project"
mode = "default"

# Router integration
router_url = "http://127.0.0.1:3456"        # Router URL (default port)
router_api_key = "your-secret-key"          # Optional: if router requires auth

When router_url is configured, cc-connect automatically:

• Sets ANTHROPIC_BASE_URL to the router URL
• Sets NO_PROXY=127.0.0.1 to prevent proxy interference
• Disables telemetry and cost warnings for cleaner integration

All Claude Code requests are then routed through the router, which handles model selection and provider communication.

Once configured, use cc-connect as usual. The router transparently handles model routing:

You: Help me refactor this code
Router → DeepSeek (default model)

You: Think through this architecture decision
Router → DeepSeek Reasoner (thinking model)

You: Analyze this large codebase
Router → Gemini Pro (long context model)

• Provider settings are ignored: When using router, the [[projects.agent.providers]] settings are bypassed as the router manages model selection
• Router must be running: Ensure ccr start is executed before starting cc-connect
• Configuration changes: After modifying router config, restart with ccr restart

For more details, see the Claude Code Router documentation.

Send voice messages directly — cc-connect transcribes them to text using a configurable STT provider, then forwards the text to the agent.

Supported platforms: Feishu, WeChat Work, Telegram, LINE, Discord, Slack

Prerequisites:

• An API key for OpenAI or Groq (for Whisper STT)
• ffmpeg installed (for audio format conversion — most platforms send AMR/OGG which Whisper doesn't accept directly)

[speech]
enabled = true
provider = "openai"    # "openai" or "groq"
language = ""          # e.g. "zh", "en"; empty = auto-detect

[speech.openai]
api_key = "sk-xxx"     # your OpenAI API key
# base_url = ""        # custom endpoint (optional, for OpenAI-compatible APIs)
# model = "whisper-1"  # default model

# -- OR use Groq (faster and cheaper) --
# [speech.groq]
# api_key = "gsk_xxx"
# model = "whisper-large-v3-turbo"

1. User sends a voice message on any supported platform
2. cc-connect downloads the audio from the platform
3. If the format needs conversion (AMR, OGG → MP3), ffmpeg handles it
4. Audio is sent to the Whisper API for transcription
5. Transcribed text is shown to the user and forwarded to the agent

# Ubuntu / Debian
sudo apt install ffmpeg

# macOS
brew install ffmpeg

# Alpine
apk add ffmpeg

cc-connect can synthesize AI text replies into voice messages and send them back to users via supported platforms.

Supported platforms: Feishu (Lark)

Prerequisites:

• An API key for Qwen (DashScope) or OpenAI TTS
• ffmpeg installed (for audio format conversion — Feishu requires Opus format)

[tts]
enabled  = true
provider = "qwen"        # "qwen" or "openai"
voice    = "Cherry"      # default voice name
tts_mode = "voice_only"  # "voice_only" (default) | "always"
max_text_len = 0         # max rune count before skipping TTS; 0 = no limit

[tts.qwen]
api_key = "sk-xxx"       # Alibaba DashScope API key
# base_url = ""          # leave empty for default endpoint
# model = "qwen3-tts-flash"

# -- OR use OpenAI TTS --
# [tts.openai]
# api_key = "sk-xxx"
# model = "tts-1"

Switch mode at runtime: /tts always or /tts voice_only

1. Agent produces a text reply
2. cc-connect calls the TTS API to synthesize audio
3. For Feishu: WAV audio is converted to Opus via ffmpeg
4. Voice message is sent back to the user alongside the text reply

Create scheduled tasks that run automatically — like daily code reviews, periodic trend summaries, or weekly reports. When a cron job fires, cc-connect sends the prompt to the agent in your chat session and delivers the result back to you.

/cron                                          List all cron jobs
/cron add <min> <hour> <day> <mon> <wk> <prompt>   Create a cron job
/cron del <id>                                 Delete a cron job
/cron enable <id>                              Enable a job
/cron disable <id>                             Disable a job

Example:

/cron add 0 6 * * * Collect GitHub trending repos and send me a summary

cc-connect cron add --cron "0 6 * * *" --prompt "Summarize GitHub trending" --desc "Daily Trending"
cc-connect cron list
cc-connect cron del <job-id>

Claude Code supports this out of the box — just tell it in natural language:

"每天早上6点帮我总结 GitHub trending" "Every Monday at 9am, generate a weekly status report"

Claude Code will automatically translate your request into a cc-connect cron add command via --append-system-prompt.

For other agents (Codex, Cursor, Gemini CLI, Qoder CLI, OpenCode, iFlow CLI), you need to add instructions to the agent's project-level instruction file so it knows how to create cron jobs. Add the following content to the corresponding file in your project root:

Content to add:

# cc-connect Integration

This project is managed via cc-connect, a bridge to messaging platforms.

## Scheduled tasks (cron)
When the user asks you to do something on a schedule (e.g. "every day at 6am",
"every Monday morning"), use the Bash/shell tool to run:

  cc-connect cron add --cron "<min> <hour> <day> <month> <weekday>" --prompt "<task description>" --desc "<short label>"

Environment variables CC_PROJECT and CC_SESSION_KEY are already set — do NOT
specify --project or --session-key.

Examples:
  cc-connect cron add --cron "0 6 * * *" --prompt "Collect GitHub trending repos and send a summary" --desc "Daily GitHub Trending"
  cc-connect cron add --cron "0 9 * * 1" --prompt "Generate a weekly project status report" --desc "Weekly Report"

To list or delete cron jobs:
  cc-connect cron list
  cc-connect cron del <job-id>

## Send message to current chat
To proactively send a message back to the user's chat session (use --stdin heredoc for long/multi-line messages):

  cc-connect send --stdin <<'CCEOF'
  your message here (any special characters are safe)
  CCEOF

For short single-line messages:

  cc-connect send -m "short message"

Run cc-connect as a background service managed by the OS init system (Linux systemd user service, macOS launchd LaunchAgent).

cc-connect daemon install --config ~/.cc-connect/config.toml   # install service
cc-connect daemon install --work-dir ~/.cc-connect             # same, using config dir
cc-connect daemon start
cc-connect daemon stop
cc-connect daemon restart
cc-connect daemon status
cc-connect daemon logs [-f] [-n N] [--log-file PATH]
cc-connect daemon uninstall

Install flags: --config PATH, --log-file PATH, --log-max-size N (MB), --work-dir DIR, --force. --config points to a config file; --work-dir points to the directory containing config.toml. Logs auto-rotate at the size limit and keep one backup.

Each user gets an independent session with full conversation context. Manage sessions via slash commands:

/new [name]       Start a new session
/list             List all agent sessions for this project
/switch <id>      Switch to a different session
/current          Show current session info
/history [n]      Show last n messages (default 10)
/provider [...]   Manage API providers (list/add/remove/switch)
/allow <tool>     Pre-allow a tool (takes effect on next session)
/mode [name]      View or switch permission mode
/quiet            Toggle thinking/tool progress messages
/stop             Stop current execution
/help             Show available commands

During a session, the agent may request tool permissions. Reply allow / deny / allow all (auto-approve all remaining requests this session).

cc-connect supports cross-platform bot communication, enabling multiple AI agents to collaborate in a single group chat.

Bind multiple bots in a group chat so users can interact with all of them in one place:

/bind              Show current bindings
/bind claudecode   Add claudecode project to this chat
/bind gemini       Add gemini project to this chat
/bind -claudecode  Remove claudecode from this chat

After binding, all bound bots receive messages in the group. Users can @mention specific bots or let all of them respond.

Use CLI or internal API to send messages between bots:

# CLI: Send message to another project and get response
cc-connect relay send --to gemini "What do you think about this architecture?"

# In chat, ask one bot to consult another
# The bot can use cc-connect relay to communicate with other agents

This enables powerful workflows like:

• Ask Claude Code to review code, then ask Gemini for a second opinion
• Let one agent handle frontend questions while another handles backend
• Cross-validate solutions from multiple AI models

Each [[projects]] entry binds one code directory to its own agent and platforms. A single cc-connect process can manage multiple projects simultaneously.

# Project 1
[[projects]]
name = "my-backend"

[projects.agent]
type = "claudecode"

[projects.agent.options]
work_dir = "/path/to/backend"
mode = "default"

[[projects.platforms]]
type = "feishu"

[projects.platforms.options]
app_id = "cli_xxxx"
app_secret = "xxxx"

# Project 2 — Codex agent with Telegram
[[projects]]
name = "my-frontend"

[projects.agent]
type = "codex"

[projects.agent.options]
work_dir = "/path/to/frontend"
mode = "full-auto"

[[projects.platforms]]
type = "telegram"

[projects.platforms.options]
token = "xxxx"

See config.example.toml for a fully commented configuration template.

Implement the core.Platform interface and register it:

package myplatform

import "github.com/chenhg5/cc-connect/core"

func init() {
    core.RegisterPlatform("myplatform", New)
}

func New(opts map[string]any) (core.Platform, error) {
    return &MyPlatform{}, nil
}

// Implement Name(), Start(), Reply(), Send(), Stop()

Then add a blank import in cmd/cc-connect/main.go:

_ "github.com/chenhg5/cc-connect/platform/myplatform"

Same pattern — implement core.Agent and register via core.RegisterAgent.

cc-connect/
├── cmd/cc-connect/          # Entrypoint
│   └── main.go
├── core/                    # Core abstractions
│   ├── interfaces.go        # Platform + Agent interfaces
│   ├── registry.go          # Plugin-style factory registry
│   ├── message.go           # Unified message / event types
│   ├── session.go           # Multi-session management
│   ├── i18n.go              # Internationalization (en/zh)
│   ├── speech.go            # Speech-to-text (Whisper API + ffmpeg)
│   └── engine.go            # Routing engine + slash commands
├── platform/                # Platform adapters
│   ├── feishu/              # Feishu / Lark (WebSocket)
│   ├── dingtalk/            # DingTalk (Stream)
│   ├── telegram/            # Telegram (Long Polling)
│   ├── slack/               # Slack (Socket Mode)
│   ├── discord/             # Discord (Gateway WebSocket)
│   ├── line/                # LINE (HTTP Webhook)
│   ├── wecom/               # WeChat Work (HTTP Webhook)
│   ├── qq/                  # QQ (NapCat / OneBot v11 WebSocket)
│   └── qqbot/               # QQ Bot (Official API v2 WebSocket)
├── agent/                   # Agent adapters
│   ├── claudecode/          # Claude Code CLI (interactive sessions)
│   ├── codex/               # OpenAI Codex CLI (exec --json)
│   ├── cursor/              # Cursor Agent CLI (--print stream-json)
│   ├── qoder/               # Qoder CLI (-p -f stream-json)
│   ├── gemini/              # Gemini CLI (-p --output-format stream-json)
│   ├── opencode/            # OpenCode (run --format json)
│   └── iflow/               # iFlow CLI (-p, -r, -o)
├── docs/                    # Platform setup guides
├── config.example.toml      # Config template
├── INSTALL.md               # AI-agent-friendly install guide
├── Makefile
└── README.md

• Discord
• Telegram

Thanks to all the people who contributed to this project:

MIT