Bee
1e4cdbda61
* Revert "feat(desktop): Composio connectors on desktop-experimental (#13685)"
This reverts commit 7844ae9250.
* feat(desktop): current Composio connectors state for desktop-experimental
Replaces the Aug 30 snapshot (#13685) with the reviewed state of
bee/poc-connectors-composio (PR #13684, Greptile 5/5): reverts the
snapshot commit, then applies the feature diff from that branch's
merge base, resolved against desktop-experimental's own changes
(cloud-agents flag wiring, marketplace layout).
This brings the fix for the beta-blocking bug - connector tools now
register in-process at session bootstrap from composio.json instead of
through a generated drop-in plugin, which packaged apps cannot load
(the plugin sandbox needs a JS runtime and bootstrap file on real disk
that the .app bundle does not ship). It also brings everything else
from review: durable cancellation tombstones with confirmed-revocation
pruning, fail-closed revocation error handling, serialized state
writes, per-slug delta reconciliation, connect/disconnect race
anchoring, zero-tools self-heal and warning, the @cline.bot
internal-feature gate with persisted account context, and the
env-var-only managed key model (no key in build artifacts).
* fix(desktop,core): revoke upstream grants on delete, scope flag cache per identity, paginate reconciliation
Review findings from johnwschoi on #13684 plus the follow-up Greptile
finding on #13739, all verified against the installed SDKs:
- Upstream revocation: @composio/core's connectedAccounts.delete never
sends revoke_on_delete and the API defaults it to false - a soft
delete that removes the Composio record while leaving the provider
OAuth grant (the actual Gmail/Calendar/GitHub token) authorized after
the UI reports a disconnect. All deletions now go through the raw
client (getClient()) with revoke_on_delete=true, covering disconnects
and every cancelled/abandoned-attempt revocation.
- Feature-flag identity scoping: FeatureFlagsService.setContext kept
the previous identity's cached flag values, so after an account
switch whose poll fails, the new account inherited the old one's
flags (including internal-feature access). An identity change now
resets the cache to defaults until a successful poll for the new
identity, and constructor hydration skips a persisted snapshot
written by a different known identity; the unresolved-at-startup
fallback is preserved.
- Pagination: reconciliation listed only the first page of connected
accounts while treating absence as "revoked remotely", so an account
on a later page was disconnected locally. The listing now follows
nextCursor to the end (capped), and absence-based removals are
skipped entirely if the cap is ever hit.
- Disconnect id-guard: a redirect-less reconnect that finalized while a
disconnect awaited the old account's revocation was blindly deleted
from local state, orphaning its still-authorized account for the next
refresh to import as a resurrection. Disconnect now removes only the
exact account it revoked and stamps lastDisconnectedAt only when the
removal took effect - the newer reconnect survives, consistent with
newest-intent-wins everywhere else.
- Schema resilience: one stored tool schema that createTool rejects
(e.g. an unsupported top-level allOf) threw during extension setup
and blocked session initialization; registration is now per-tool
fault-isolated (skip and log).
Regression tests for each: revoke flag asserted on every delete call,
identity-switch and failed-poll flag scoping, cross-identity persistent
cache, two-page reconciliation, disconnect-vs-reconnect race, malformed
schema skip.
Cline
The open source coding agent in your IDE and terminal.
CLIRun Cline in your terminal. Interactive chat or fully headless for CI/CD and scripting. |
KanbanRun many agents in parallel from a web-based task board. Each card gets its own worktree, auto-commit, and dependency chains. |
VS Code ExtensionAI coding assistant in your editor. Create files, run commands, browse the web, and use tools with human-in-the-loop approval. |
JetBrains PluginThe same Cline experience in IntelliJ IDEA, PyCharm, WebStorm, GoLand, and the rest of the JetBrains family. |
SDKBuild your own AI agents and integrations powered by the same engine that runs the CLI, Kanban, VS Code extension, and JetBrains plugin. Custom tools, multi-agent teams, connectors, scheduled automations, and more. |
Index
| Product | Description | Location | CHANGELOG |
|---|---|---|---|
| SDK | Node.js programmatic agent API and extension exports. | sdk/ |
CHANGELOG.md |
| CLI | Terminal UI, headless mode, shell commands, and CLI-specific flows. | apps/cli/ |
CHANGELOG.md |
| VS Code Extension | The Marketplace extension and extension host integration. | / (WIP migrating) |
CHANGELOG.md |
| JetBrains Plugin | JetBrains-hosted client that talks to the shared agent core. | Currently we are not open-sourcing JetBrains plugins | - |
| Kanban | Web-based multi-agent task board. | cline/kanban |
CHANGELOG.md |
| Docs site | Public documentation pages. | docs/ |
- |
Edits Code Across Your Project
Cline reads your project structure, understands the relationships between files, and makes coordinated changes across your codebase. It monitors linter and compiler errors as it works, fixing issues like missing imports, type mismatches, and syntax errors before you even see them. In VS Code and JetBrains, every edit shows up as a diff you can review, modify, or revert. All changes are tracked with checkpoints, so you can easily undo the agent's work.
Runs Bash Commands
Cline executes commands directly in your terminal and watches the output in real time. Install packages, run build scripts, execute tests, deploy applications, manage databases. For long-running processes like dev servers, Cline continues working in the background and reacts to new output as it appears, catching compile errors, test failures, and server crashes as they happen.
Plan and Act
Toggle between Plan mode and Act mode. In Plan mode, Cline explores your codebase, asks clarifying questions, and lays out a strategy. Once you're aligned, switch to Act mode and Cline executes the plan. Every file edit and terminal command requires your approval, so you stay in control of what actually changes. Or toggle auto-approve and let Cline run autonomously.
Rules and Skills
Define project-specific rules in .clinerules files that guide how Cline works in your codebase: coding standards, architecture conventions, deployment procedures, testing requirements. Rules are picked up automatically by the CLI, VS Code extension, and JetBrains plugin. Use skills to let the model load specific rules when needed.
Works With Every Model
Cline is not locked to a single AI provider. Use whichever model fits your workflow:
| Provider | Models |
|---|---|
| Anthropic | Claude Opus, Sonnet, Haiku |
| OpenAI | GPT series models |
| Gemini series models | |
| OpenRouter | 200+ models from any provider |
| Vercel AI Gateway | Route to many providers through one gateway |
| AWS Bedrock | Claude, Llama, and more |
| Azure / GCP Vertex | All hosted models |
| Cerebras / Groq | Fast inference models |
| Ollama / LM Studio | Run local models on your machine |
| Any OpenAI-compatible API | Self-hosted or third-party endpoints |
Extend With Plugins or MCP Servers
Extend Cline's capabilities with plugins. Using the SDK, register tools and lifecycle hooks programmatically through the plugin system for logging, auditing, policy enforcement, or adding domain-specific capabilities. Simple plugin example below.
import { Agent, createTool } from "@cline/sdk"
const deployTool = createTool({
name: "deploy",
description: "Deploy the current branch to staging.",
inputSchema: { type: "object", properties: { env: { type: "string" } }, required: ["env"] },
execute: async (input) => {
// your deployment logic
},
})
const agent = new Agent({ tools: [deployTool], /* ... */ })
...or use MCP servers to connect to databases, query APIs, manage cloud infrastructure, and interact with external systems. Use community-built servers or ask Cline to create custom tools on the fly. In the CLI, manage servers with cline mcp.
Multi-Agent Teams
Coordinate multiple agents working together on complex tasks. A coordinator agent breaks the work into subtasks and delegates to specialist agents, each with their own tools and context. Team state persists across sessions so you can pick up where you left off.
cline --team-name auth-sprint "Plan and implement user authentication with tests"
Scheduled Agents
Run agents on cron schedules for recurring automations. Daily PR summaries, weekly dependency checks, codebase health reports. Schedules persist across restarts and run independently of any terminal session.
cline schedule create "PR summary" \
--cron "0 9 * * MON-FRI" \
--prompt "List all open PRs and their review status" \
--workspace /path/to/repo
Connect to Slack, Telegram, Discord, and More
Chat with your agent from any messaging platform: Telegram, Slack, Discord, Google Chat, WhatsApp, and Linear. Each conversation thread maps to an agent session with full context. Set up access control to restrict who can interact with your agent.
# Connect to Telegram
cline connect telegram -k $BOT_TOKEN
# Connect to Slack through webhook
cline connect slack --bot-token $SLACK_TOKEN --signing-secret $SECRET --base-url $URL
# Connect to Slack using socket mode
cline connect slack --bot-token $SLACK_TOKEN --app-token $SLACK_APP_TOKEN
Headless CLI for CI/CD
Run Cline with zero interaction for scripting and automation. Pipe input, get JSON output, chain commands, integrate into CI/CD pipelines.
cline "Run tests and fix any failures"
git diff origin/main | cline "Review these changes for issues"
cline --json "List all TODO comments" | jq -r 'select(.type == "agent_event" and .event.text) | .event.text'
Contributing
Start with the Contributing Guide. Join our Discord and head to the #contributors channel to connect with other contributors. Check our careers page for full-time roles.