feat: add CodeBuddy agent support

.gitignore

@@ -1,2 +1,4 @@
 /target
 /.claude
+.idea/
+.serena/

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## What this repo is
 
-Edgee is an **open-source AI Gateway** written in Rust. It sits between coding agents (Claude Code, Codex, OpenCode — Cursor and OpenClaw coming soon) or any llm client and LLM providers (Anthropic, OpenAI) and compresses token-heavy traffic on the fly. A hosted / edge version of the same gateway is available at [`www.edgee.ai`](https://www.edgee.ai); **this repository is the OSS core** you can self-host.
+Edgee is an **open-source AI Gateway** written in Rust. It sits between coding agents (Claude Code, CodeBuddy, Codex, OpenCode — Cursor and OpenClaw coming soon) or any llm client and LLM providers (Anthropic, OpenAI) and compresses token-heavy traffic on the fly. A hosted / edge version of the same gateway is available at [`www.edgee.ai`](https://www.edgee.ai); **this repository is the OSS core** you can self-host.
 
 The distinguishing feature is the compression engine. Today it ships a single technique — **tool-results compression** — but the architecture is explicitly designed to host **multiple composable techniques** that a developer selects and combines per request. When extending compression, add a new technique alongside the existing ones rather than threading a new code path through the provider dispatch layer.
 
@@ -20,7 +20,7 @@ If `edgee stats` fails, you have the wrong package installed.
 
 Entry point: `crates/cli/src/main.rs`. Subcommands declared in `crates/cli/src/commands/mod.rs`:
 
-- `edgee launch {claude|codex|opencode|crush}` — launches the agent with `ANTHROPIC_BASE_URL` and custom headers pointing at the local gateway. Implementation per agent under `crates/cli/src/commands/launch/`.
+- `edgee launch {claude|codebuddy|codex|opencode|crush}` — launches the agent with `ANTHROPIC_BASE_URL` and custom headers pointing at the local gateway. Implementation per agent under `crates/cli/src/commands/launch/`.
 - `edgee auth {login|status|list|switch}` — OAuth-style flow against the Edgee console. See `crates/cli/src/api.rs` and `crates/cli/src/commands/auth/`.
 - `edgee stats` (visible alias `report`) — prints session token counts and compression savings.
 - `edgee alias` — installs shell aliases for quick access.

README.md

@@ -76,6 +76,9 @@ edgee launch codex
 # Opencode
 edgee launch opencode
 
+# CodeBuddy
+edgee launch codebuddy
+
 # Crush
 edgee launch crush
 ```
@@ -86,21 +89,22 @@ Any extra flags you pass after the subcommand are forwarded straight to the unde
 edgee launch claude --resume abcd # continue the last Claude Code session
 edgee launch codex resume         # resume the last Codex session
 edgee launch opencode -c          # continue the last OpenCode session
+edgee launch codebuddy --resume <id>  # resume the last CodeBuddy session
 ```
 
 ### Route plain `claude` / `codex` / `opencode` / `crush` through Edgee
 
 If you'd rather type `claude` (or have another tool spawn `claude` for you), install Edgee's shims:
 
 ```bash
-edgee alias            # installs all four; pass `claude`, `codex`, `opencode`, `crush` to scope
+edgee alias            # installs all five; pass `claude`, `codebuddy`, `codex`, `opencode`, `crush` to scope
 edgee alias remove     # to undo
 ```
 
 This does two things:
 
 1. Adds a shell alias to `~/.bashrc`, `~/.zshrc`, and `~/.config/fish/config.fish` (`alias claude='edgee launch claude'`, etc.) so interactive shells route through Edgee.
-2. Writes executable shim scripts to `~/.edgee/bin/{claude,codex,opencode,crush}` and prepends `~/.edgee/bin` to `PATH` in the same rc block. This means **non-interactive** shells, including `bash -c '...'`, scripts, and tools that spawn Claude Code via `exec`, also get routed through Edgee. Reopen your terminal (or `exec $SHELL -l`) once after install.
+2. Writes executable shim scripts to `~/.edgee/bin/{claude,codebuddy,codex,opencode,crush}` and prepends `~/.edgee/bin` to `PATH` in the same rc block. This means **non-interactive** shells, including `bash -c '...'`, scripts, and tools that spawn Claude Code via `exec`, also get routed through Edgee. Reopen your terminal (or `exec $SHELL -l`) once after install.
 
 ### Use as a standalone gateway
 
@@ -195,6 +199,7 @@ The `SessionStart` hook installed by `edgee statusline claude install` (or by th
 | Claude Code | `edgee launch claude` | ✅ Supported |
 | Codex | `edgee launch codex` | ✅ Supported |
 | Opencode | `edgee launch opencode` | ✅ Supported |
+| CodeBuddy | `edgee launch codebuddy` | ✅ Supported |
 | Crush | `edgee launch crush` | ✅ Supported |
 | Cursor | `edgee launch cursor` | 🔜 Coming soon |
 | Any OpenAI-compatible client | `edgee serve` | ✅ Supported |

crates/cli/src/commands/alias.rs

@@ -13,18 +13,20 @@ const SHIM_DIR_REL: &str = ".edgee/bin";
 const USES_SHIMS: bool = cfg!(unix);
 
 const CLAUDE_ALIAS: AliasSpec = AliasSpec::new("claude", "edgee launch claude");
+const CODEBUDDY_ALIAS: AliasSpec = AliasSpec::new("codebuddy", "edgee launch codebuddy");
 const CODEX_ALIAS: AliasSpec = AliasSpec::new("codex", "edgee launch codex");
 const OPENCODE_ALIAS: AliasSpec = AliasSpec::new("opencode", "edgee launch opencode");
 const CRUSH_ALIAS: AliasSpec = AliasSpec::new("crush", "edgee launch crush");
 
-const ALL_ALIASES: [AliasSpec; 4] = [CLAUDE_ALIAS, CODEX_ALIAS, OPENCODE_ALIAS, CRUSH_ALIAS];
+const ALL_ALIASES: [AliasSpec; 5] = [CLAUDE_ALIAS, CODEBUDDY_ALIAS, CODEX_ALIAS, OPENCODE_ALIAS, CRUSH_ALIAS];
 
 const PATH_EXPORT_POSIX: &str = "case \":$PATH:\" in\n  *\":$HOME/.edgee/bin:\"*) ;;\n  *) export PATH=\"$HOME/.edgee/bin:$PATH\" ;;\nesac\n";
 const PATH_EXPORT_FISH: &str = "fish_add_path -p \"$HOME/.edgee/bin\"\n";
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, clap::ValueEnum)]
 pub enum Agent {
     Claude,
+    Codebuddy,
     Codex,
     Opencode,
     Crush,
@@ -35,6 +37,7 @@ impl Agent {
     fn aliases(self) -> &'static [AliasSpec] {
         match self {
             Self::Claude => std::slice::from_ref(&CLAUDE_ALIAS),
+            Self::Codebuddy => std::slice::from_ref(&CODEBUDDY_ALIAS),
             Self::Codex => std::slice::from_ref(&CODEX_ALIAS),
             Self::Opencode => std::slice::from_ref(&OPENCODE_ALIAS),
             Self::Crush => std::slice::from_ref(&CRUSH_ALIAS),
@@ -45,10 +48,11 @@ impl Agent {
     fn label(self) -> &'static str {
         match self {
             Self::Claude => "claude",
+            Self::Codebuddy => "codebuddy",
             Self::Codex => "codex",
             Self::Opencode => "opencode",
             Self::Crush => "crush",
-            Self::All => "claude, codex, opencode, and crush",
+            Self::All => "claude, codebuddy, codex, opencode, and crush",
         }
     }
 }
@@ -650,11 +654,13 @@ mod tests {
         let dir = tmp.path().join("bin");
         write_shims(&dir, &ALL_ALIASES).unwrap();
         assert!(dir.join("claude").exists());
+        assert!(dir.join("codebuddy").exists());
         assert!(dir.join("codex").exists());
         assert!(dir.join("opencode").exists());
 
         remove_shims(&dir, &codex_only()).unwrap();
         assert!(dir.join("claude").exists());
+        assert!(dir.join("codebuddy").exists());
         assert!(!dir.join("codex").exists());
         assert!(dir.join("opencode").exists());
     }

crates/cli/src/commands/auth/login.rs

@@ -204,6 +204,7 @@ pub async fn ensure_onboarded(provider: &str) -> Result<()> {
 pub fn agent_label(provider: &str) -> &'static str {
     match provider {
         "claude" => "Claude Code",
+        "codebuddy" => "CodeBuddy",
         "codex" => "Codex",
         "opencode" => "OpenCode",
         "crush" => "Crush",
@@ -284,6 +285,7 @@ pub async fn fetch_provider_key(provider: &str) -> Result<crate::api::ApiKeyItem
 fn coding_assistant_name(provider: &str) -> Result<&'static str> {
     match provider {
         "claude" => Ok("claude_code"),
+        "codebuddy" => Ok("codebuddy"),
         "codex" => Ok("codex"),
         "opencode" => Ok("opencode"),
         "crush" => Ok("crush"),
@@ -297,6 +299,7 @@ fn provider_config_mut<'a>(
 ) -> Result<&'a mut Option<crate::config::ProviderConfig>> {
     match provider {
         "claude" => Ok(&mut creds.claude),
+        "codebuddy" => Ok(&mut creds.codebuddy),
         "codex" => Ok(&mut creds.codex),
         "opencode" => Ok(&mut creds.opencode),
         "crush" => Ok(&mut creds.crush),
@@ -310,6 +313,7 @@ fn provider_config<'a>(
 ) -> Result<Option<&'a crate::config::ProviderConfig>> {
     match provider {
         "claude" => Ok(creds.claude.as_ref()),
+        "codebuddy" => Ok(creds.codebuddy.as_ref()),
         "codex" => Ok(creds.codex.as_ref()),
         "opencode" => Ok(creds.opencode.as_ref()),
         "crush" => Ok(creds.crush.as_ref()),
@@ -475,6 +479,7 @@ mod tests {
     #[test]
     fn maps_provider_to_coding_assistant_name() {
         assert_eq!(coding_assistant_name("claude").unwrap(), "claude_code");
+        assert_eq!(coding_assistant_name("codebuddy").unwrap(), "codebuddy");
         assert_eq!(coding_assistant_name("codex").unwrap(), "codex");
         assert_eq!(coding_assistant_name("opencode").unwrap(), "opencode");
         assert!(coding_assistant_name("unknown").is_err());
@@ -487,6 +492,9 @@ mod tests {
         provider_config_mut(&mut creds, "claude")
             .unwrap()
             .replace(crate::config::ProviderConfig::default());
+        provider_config_mut(&mut creds, "codebuddy")
+            .unwrap()
+            .replace(crate::config::ProviderConfig::default());
         provider_config_mut(&mut creds, "codex")
             .unwrap()
             .replace(crate::config::ProviderConfig::default());
@@ -495,6 +503,7 @@ mod tests {
             .replace(crate::config::ProviderConfig::default());
 
         assert!(creds.claude.is_some());
+        assert!(creds.codebuddy.is_some());
         assert!(creds.codex.is_some());
         assert!(creds.opencode.is_some());
     }

crates/cli/src/commands/launch/codebuddy.rs

@@ -0,0 +1,124 @@
+use anyhow::Result;
+
+use super::util;
+
+#[derive(Debug, clap::Parser)]
+#[command(disable_help_flag = true)]
+pub struct Options {
+    /// Route traffic through a local gateway instead of the hosted Edgee service.
+    /// Session tracking is disabled in this mode.
+    #[arg(long)]
+    pub local_gateway: bool,
+
+    /// Extra args passed through to the codebuddy CLI
+    #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+    pub args: Vec<String>,
+}
+
+pub async fn run(opts: Options) -> Result<()> {
+    let mut creds = crate::config::read()?;
+
+    // Step 1: ensure we are authenticated
+    if creds.user_token.as_deref().unwrap_or("").is_empty() {
+        crate::commands::auth::login::perform_login().await?;
+    }
+
+    // Step 1b: ensure an org is selected (handles partial state after aborted login)
+    crate::commands::auth::login::ensure_org_selected().await?;
+
+    // Step 2: ensure we have a live api_key for CodeBuddy. Re-provisions if the
+    // cached key was deleted in the console; re-runs onboarding for a fresh key.
+    let reprovisioned =
+        crate::commands::auth::login::ensure_valid_provider_key("codebuddy").await?;
+    if reprovisioned {
+        crate::commands::auth::login::ensure_onboarded("codebuddy").await?;
+    }
+    creds = crate::config::read()?;
+
+    // Step 3: ensure we have a connection choice (default to "plan" for codebuddy)
+    if creds
+        .codebuddy
+        .as_ref()
+        .and_then(|c| c.connection.as_deref())
+        .is_none()
+    {
+        let provider = creds.codebuddy.get_or_insert_with(Default::default);
+        provider.connection = Some("plan".to_string());
+        crate::config::write(&creds)?;
+    }
+
+    // Step 4: launch codebuddy with the correct env vars
+    let codebuddy = creds.codebuddy.as_ref().unwrap();
+    let api_key = &codebuddy.api_key;
+    let session_id = uuid::Uuid::new_v4().to_string();
+
+    // First-run: install the persistent user-level statusline integration
+    // exactly once. CodeBuddy itself doesn't render an Edgee statusline today,
+    // but users typically also use Claude Code in the same shell — running
+    // the installer on the first `edgee launch` of any agent matches the
+    // "set it up once" flow we want.
+    util::ensure_first_run_installed().await;
+
+    if opts.local_gateway {
+        return run_with_local_gateway(opts.args).await;
+    }
+
+    util::spawn_cli_version_report(&creds, &session_id);
+
+    let repo_entry = crate::git::detect_origin()
+        .map(|url| format!(",\"x-edgee-repo\"=\"{url}\""))
+        .unwrap_or_default();
+    let base_url = format!("{}/v1", super::resolve_gateway_base_url(&creds).await);
+    let mut cmd = std::process::Command::new(util::resolve_binary("codebuddy"));
+    cmd.env("EDGEE_SESSION_ID", &session_id);
+    cmd.env("CODEBUDDY_BASE_URL", &base_url);
+    cmd.env(
+        "CODEBUDDY_CUSTOM_HEADERS",
+        format!(
+            "x-edgee-api-key: {api_key}\nx-edgee-session-id: {session_id}{repo_entry}"
+        ),
+    );
+    cmd.args(&opts.args);
+
+    let status = cmd.status().map_err(|e| {
+        if e.kind() == std::io::ErrorKind::NotFound {
+            anyhow::anyhow!(
+                "CodeBuddy is not installed. Install it from https://cnb.cool/codebuddy/codebuddy-code"
+            )
+        } else {
+            anyhow::anyhow!(e)
+        }
+    })?;
+
+    super::print_session_stats(&creds, &session_id, "CodeBuddy").await;
+
+    if let Some(code) = status.code() {
+        std::process::exit(code);
+    }
+
+    Ok(())
+}
+
+/// Launch CodeBuddy routed through a local gateway. Session tracking and version
+/// reporting are skipped — the backend never sees this traffic.
+async fn run_with_local_gateway(args: Vec<String>) -> Result<()> {
+    use std::net::Ipv4Addr;
+
+    let log_path = crate::config::local_gateway_log_path();
+    crate::local_gateway::init_file_tracing(&log_path)?;
+    eprintln!("edgee: gateway logs -> {}", log_path.display());
+
+    let gateway = crate::local_gateway::start((Ipv4Addr::LOCALHOST, 0).into()).await?;
+    let addr = gateway.addr;
+
+    let mut cmd = tokio::process::Command::new(util::resolve_binary("codebuddy"));
+    cmd.env("CODEBUDDY_BASE_URL", format!("http://{addr}"));
+    cmd.args(&args);
+
+    util::run_with_gateway(
+        gateway,
+        cmd,
+        "CodeBuddy is not installed. Install it from https://cnb.cool/codebuddy/codebuddy-code",
+    )
+    .await
+}

crates/cli/src/commands/launch/mod.rs

@@ -1,4 +1,5 @@
 pub mod claude;
+pub mod codebuddy;
 pub mod codex;
 pub mod crush;
 pub mod opencode;
@@ -18,6 +19,9 @@ enum Command {
     /// Launch OpenCode routed through Edgee
     #[command(name = "opencode")]
     OpenCode(opencode::Options),
+    /// Launch CodeBuddy routed through Edgee
+    #[command(name = "codebuddy")]
+    CodeBuddy(codebuddy::Options),
     /// Launch Crush routed through Edgee
     Crush(crush::Options),
 }
@@ -31,6 +35,7 @@ pub struct Options {
 pub async fn run(opts: Options) -> anyhow::Result<()> {
     match opts.command {
         Command::Claude(o) => claude::run(o).await,
+        Command::CodeBuddy(o) => codebuddy::run(o).await,
         Command::Codex(o) => codex::run(o).await,
         Command::OpenCode(o) => opencode::run(o).await,
         Command::Crush(o) => crush::run(o).await,

crates/cli/src/commands/settings.rs

@@ -8,7 +8,7 @@ use crate::api::{ApiClient, Compression, GatewayModel, KeySettings, ModelRoute,
 use crate::commands::auth::login;
 
 /// Coding agents whose keys can be configured. Order is reused for the interactive picker.
-const PROVIDERS: [&str; 4] = ["claude", "codex", "opencode", "crush"];
+const PROVIDERS: [&str; 5] = ["claude", "codebuddy", "codex", "opencode", "crush"];
 
 #[derive(Debug, clap::Parser)]
 pub struct Options {

crates/cli/src/config.rs

@@ -33,6 +33,7 @@ pub struct Profile {
     /// When false, no MCP config or system prompt is injected into the coding assistant.
     pub enable_mcp: Option<bool>,
     pub claude: Option<ProviderConfig>,
+    pub codebuddy: Option<ProviderConfig>,
     pub codex: Option<ProviderConfig>,
     pub opencode: Option<ProviderConfig>,
     pub crush: Option<ProviderConfig>,

crates/compression-layer/README.md

@@ -7,7 +7,7 @@ Tower `Layer`/`Service` that compresses LLM tool outputs in-flight.
 This crate wraps any downstream Tower service and intercepts requests before they leave the gateway. It calls `edgee-compressor` to shrink tool-result payloads, then forwards the mutated request to the inner service. Only tool results are modified; all other request fields pass through unchanged.
 
 ```
-coding agent (Claude Code / Codex / OpenCode)
+coding agent (Claude Code / CodeBuddy / Codex / OpenCode)
         |
   edgee-compression-layer               <-- this crate
     CompressionLayer

crates/gateway-core/README.md

@@ -7,7 +7,7 @@ Core LLM request/response pipeline for the Edgee AI Gateway.
 This crate is the foundation that all other gateway crates build on. It defines the canonical request/response types (OpenAI Chat Completions format), the `Provider` trait, and the two working passthrough services for Anthropic and OpenAI. It has no hard dependency on tokio or reqwest, making it portable to any async runtime including `wasm32-wasip1`.
 
 ```
-coding agent (Claude Code / Codex / OpenCode)
+coding agent (Claude Code / CodeBuddy / Codex / OpenCode)
         |
   compression-layer (edgee-compression-layer)
         |

doc/architecture.md

@@ -4,7 +4,7 @@ This document describes the design of the Edgee AI Gateway OSS codebase: the Tow
 
 ## Overview
 
-Edgee is an LLM gateway that sits between a coding agent (Claude Code, Codex, OpenCode) and an LLM provider (Anthropic, OpenAI). Its primary function today is **tool-output compression**: before each API request is forwarded, tool results in the context window are analyzed and shrunk to reduce token count without changing the model's view of the conversation.
+Edgee is an LLM gateway that sits between a coding agent (Claude Code, CodeBuddy, Codex, OpenCode) and an LLM provider (Anthropic, OpenAI). Its primary function today is **tool-output compression**: before each API request is forwarded, tool results in the context window are analyzed and shrunk to reduce token count without changing the model's view of the conversation.
 
 The gateway is built on **[Tower](https://docs.rs/tower/latest/tower/)**, a Rust middleware framework. Every processing step is a Tower [`Service`](https://docs.rs/tower/latest/tower/trait.Service.html), and processing steps are composed by stacking Tower [`Layer`](https://docs.rs/tower/latest/tower/trait.Layer.html)s. This design means the compression pipeline, the HTTP boundary, and the provider dispatch are all independently testable units that can be composed in different configurations using [`ServiceBuilder`](https://docs.rs/tower/latest/tower/builder/struct.ServiceBuilder.html).