Open source Grok Bot alternative, Bring your own agent and subscription: message Claude Code, Codex, Gemini CLI, Cursor, Copilot and 40+ AI agents as bots on your own computer, from iPhone, Mac, Windows, Linux or terminal. Agent-agnostic and free. Also a Muse and Dots alternative. Built in Rust.
Rust acpagent-client-protocolai-agentsai-assistantclaudeclaude-codecodexcoding-agentscursorgeminigemini-cligrok-bot-alternativeiosiphonelinuxmacosmcpopen-sourcerustself-hosted
fix(host): give bots on Pi Codync's tools
leepokaiacb192f063d5
diff --git a/docs/architecture/file-structure.md b/docs/architecture/file-structure.mdindex f47a4bde..66c5e382 100644--- a/docs/architecture/file-structure.md+++ b/docs/architecture/file-structure.md@@ -92,7 +92,7 @@ Codync/| CLI and background service | `host/src/main.rs`, `service/`; subcommands `cloud_cli.rs`, `network_cli.rs`, `send_cli.rs` (+ `send_cli/events.rs`, `wait.rs`) || API, caller permissions, event ordering | `host/src/api/`, `hub.rs` || SQLite transcript, bots, lanes and sessions | `host/src/store/` (`entries.rs`, `bots.rs`, `model.rs`, `devices.rs`, `schema.rs`) |-| Agent process, ACP, queue and session lifecycle | `host/src/agent/bot/` (`launch.rs`, `queue.rs`, `session.rs`, `turn.rs`, `updates.rs`), `acp.rs` (+ `acp/codebuddy.rs`, CodeBuddy's ACP extensions), `process.rs` (process-tree ownership; `process_windows.rs` on Windows) |+| Agent process, ACP, queue and session lifecycle | `host/src/agent/bot/` (`launch.rs`, `queue.rs`, `session.rs`, `turn.rs`, `updates.rs`; `codex_names.rs` / `pi_tools.rs` how Codex and pi get Codync's MCP servers), `acp.rs` (+ `acp/codebuddy.rs`, CodeBuddy's ACP extensions), `process.rs` (process-tree ownership; `process_windows.rs` on Windows) || Compaction timing and rollover | `host/src/agent/bot/compaction.rs`, the handoff card in `host/src/chat/handoff.rs`; the rules in `codync-mem`'s `compaction.rs` || Group room turns / bot-to-bot requests | `host/src/chat/group.rs` / `team.rs` || Voice calls (the call, the voice's instructions and tools, transcripts, call lines) | `host/src/chat/calls/` (`mod.rs`, `context.rs`, `project.rs` the git state, `tools.rs`, `announce.rs` what the voice hears while the call lasts, `speech.rs` text as a voice says it); the user's messages it relays go through `host/src/chat/messages.rs` like typed ones; clients' `CallLink` (iPhone `CodyncUI/Call/CallLink.swift`, desktop `views/call/call-link.ts`, Android `core/Calls.kt` + `HostCallLink.kt`) and call rows (`CallRows`); the call on the iPhone's Lock Screen (`CodyncUI/Call/CallActivity.swift`, the Live Activity) and Android's call notification (`VoiceService.kt`) |diff --git a/docs/features/marketplace.md b/docs/features/marketplace.mdindex f66d01da..b961a603 100644--- a/docs/features/marketplace.md+++ b/docs/features/marketplace.md@@ -32,7 +32,7 @@ Registry package installs use pinned package references: npm, PyPI and NuGet reqA custom connector is a command line (split like a shell), a URL, or a pasted MCP config (`importConnectors {config}`: the `mcpServers` / `servers` JSON from READMEs, Claude, Cursor or VS Code, or one server's entry); every server in a config is added.-A connector installed on the computer (or an app connected through Composio) is turned on for every existing bot, and a new bot starts with all of them on; each bot can turn one off in its settings. An enabled connector is passed to the agent as an MCP server when its session starts or resumes. Local connectors are spawned by the agent; remote ones always go through the host's stdio proxy (`codync-host mcp remote`, `host/src/mcp.rs`), so they work with agents that only speak stdio and always carry a fresh token. The proxy speaks streamable HTTP and falls back to the older HTTP+SSE transport when the first POST fails with 400/404/405, as the MCP spec suggests. Each server is named after its connector id. codex-acp leaves out a requested server whose name Codex's own config already uses (its `[mcp_servers.<name>]`, disabled ones too, in `$CODEX_HOME` (a saved one first, else `~/.codex`), `/etc/codex` or a `.codex` folder from the bot's folder up) and says so only in a startup notice, so for a Codex bot such a server is named `codync-<name>` instead, or `codync-<name>-2`… when that is taken too (`agent/bot/codex_names.rs`, #217). The calls of Codync's own `chat` and `memory` servers are recognized by the name the agent got, so a user's own `memory` server stays in the working steps.+A connector installed on the computer (or an app connected through Composio) is turned on for every existing bot, and a new bot starts with all of them on; each bot can turn one off in its settings. An enabled connector is passed to the agent as an MCP server when its session starts or resumes. Local connectors are spawned by the agent; remote ones always go through the host's stdio proxy (`codync-host mcp remote`, `host/src/mcp.rs`), so they work with agents that only speak stdio and always carry a fresh token. The proxy speaks streamable HTTP and falls back to the older HTTP+SSE transport when the first POST fails with 400/404/405, as the MCP spec suggests. Each server is named after its connector id. codex-acp leaves out a requested server whose name Codex's own config already uses (its `[mcp_servers.<name>]`, disabled ones too, in `$CODEX_HOME` (a saved one first, else `~/.codex`), `/etc/codex` or a `.codex` folder from the bot's folder up) and says so only in a startup notice, so for a Codex bot such a server is named `codync-<name>` instead, or `codync-<name>-2`… when that is taken too (`agent/bot/codex_names.rs`, #217). pi-acp never hands a session's servers to pi, so a Pi bot gets them when its agent starts instead (`agent/bot/pi_tools.rs`): `PI_ACP_PI_COMMAND` points pi-acp at Codync's launcher (`~/.codync/pi/pi-codync`, `pi-codync.cmd` on Windows), which starts pi with the extension beside it (`codync.js`) registering the servers in `CODYNC_PI_MCP_SERVERS` (`pi.registerMcpServer`, so pi 0.99 or later; older pi starts without them, and nothing is registered when pi-acp's own bridge `PI_ACP_MCP_SERVERS` is there). Each gets a call timeout past the host's longest (pi's default is 60 s), and a server whose name pi's own `mcp.json` has (pi's agent folder's or the project's `.pi`, `-` and `_` alike, disabled ones too) is renamed as for Codex, since pi would use its own entry. The calls of Codync's own `chat` and `memory` servers are recognized by the name the agent got, so a user's own `memory` server stays in the working steps.Every `codync-host mcp` server Codync gives an agent, connectors and built-in tools alike, carries the host's data directory as `CODYNC_HOME` in its ACP `env` (`mcp::acp_server`): some agents start MCP servers with only a few environment variables (Hermes keeps PATH, HOME and the like), and without it a host with a custom `CODYNC_HOME` (a sandbox, a server) would leave those tools reading the wrong token.diff --git a/host/src/agent/bot/codex_names.rs b/host/src/agent/bot/codex_names.rsindex 9541e075..43d7d2c9 100644--- a/host/src/agent/bot/codex_names.rs+++ b/host/src/agent/bot/codex_names.rs@@ -1,6 +1,7 @@//! codex-acp leaves out a requested MCP server whose name Codex's own config already uses ("Codex uses its own//! entry, or no server if that entry is disabled"), and says so only in a notice before the first turn. A connector//! named like one of the user's Codex servers (`notion`) then never reaches the bot (#217), so it gets a free name.+//! pi drops one its own config names the same way (`pi_tools`).use serde_json::Value;use std::collections::{BTreeMap, HashSet};@@ -18,32 +19,42 @@ pub(super) fn name_of<'a>(renamed: &'a Renamed, name: &'a str) -> &'a str {/// Renames each of `servers` whose name a Codex config for `cwd` already defines. `codex_home` is the agent's/// own `CODEX_HOME` when it has one.pub(super) async fn avoid_clashes(servers: &mut Value, cwd: &str, codex_home: Option<PathBuf>) -> Renamed {- let files = config_files(Path::new(cwd), codex_home);+ rename_taken(servers, config_files(Path::new(cwd), codex_home), taken).await+}++/// Renames each of `servers` whose name `taken` reads from the agent's config `files` (blocking).+pub(super) async fn rename_taken(+ servers: &mut Value,+ files: Vec<PathBuf>,+ taken: fn(&[PathBuf]) -> HashSet<String>,+) -> Renamed {match tokio::task::spawn_blocking(move || taken(&files)).await {Ok(taken) => rename(servers, &taken),Err(e) => {- tracing::warn!(error = format!("{e:#}"), "couldn't read Codex's MCP server names");+ tracing::warn!(error = format!("{e:#}"), "couldn't read the agent's MCP server names");Renamed::new()}}}-/// A clashing server becomes `codync-<name>`, or `codync-<name>-2`… when that is taken too: by Codex's config-/// or by another requested server.+/// A clashing server becomes `codync-<name>`, or `codync-<name>-2`… when that is taken too: by the agent's config+/// or by another requested server. Names that differ only in `-` and `_` count as one, as they do for pi.fn rename(servers: &mut Value, taken: &HashSet<String>) -> Renamed {+ let fold = |name: &str| name.replace('-', "_");+ let taken: HashSet<String> = taken.iter().map(|name| fold(name)).collect();let list = servers.as_array_mut().map(Vec::as_mut_slice).unwrap_or_default();- let mut used: HashSet<String> = taken.clone();- used.extend(list.iter().filter_map(|s| s["name"].as_str().map(str::to_owned)));+ let mut used = taken.clone();+ used.extend(list.iter().filter_map(|s| s["name"].as_str().map(fold)));let mut renamed = Renamed::new();for server in list {- let Some(name) = server["name"].as_str().filter(|name| taken.contains(*name)).map(str::to_owned) else {+ let Some(name) = server["name"].as_str().filter(|name| taken.contains(&fold(name))).map(str::to_owned) else {continue;};let free = (1..=used.len() + 1).map(|n| if n == 1 { format!("codync-{name}") } else { format!("codync-{name}-{n}") })- .find(|candidate| !used.contains(candidate))+ .find(|candidate| !used.contains(&fold(candidate))).expect("one of more names than are used is free");- used.insert(free.clone());+ used.insert(fold(&free));server["name"] = free.clone().into();renamed.insert(name, free);}diff --git a/host/src/agent/bot/mod.rs b/host/src/agent/bot/mod.rsindex eeb5d3d4..2706e3c5 100644--- a/host/src/agent/bot/mod.rs+++ b/host/src/agent/bot/mod.rs@@ -25,6 +25,7 @@ mod files;mod launch;mod lifecycle;mod modes;+mod pi_tools;mod queue;mod session;mod tool_entry;diff --git a/host/src/agent/bot/pi_tools.rs b/host/src/agent/bot/pi_tools.rsnew file mode 100644index 00000000..f0f18471--- /dev/null+++ b/host/src/agent/bot/pi_tools.rs@@ -0,0 +1,154 @@+//! pi-acp takes a session's `mcpServers` and never hands them to pi (its README's "Limitations"), so a bot on pi+//! had none of Codync's tools. pi-acp starts the command in `PI_ACP_PI_COMMAND`: Codync's launcher, which starts pi+//! with an extension that registers the servers it finds in `CODYNC_PI_MCP_SERVERS` (`pi.registerMcpServer`, pi+//! 0.99 or later).+// ponytail: drop this once pi-acp passes `mcpServers` to pi itself (svkozak/pi-acp#164).++use super::codex_names::{self, Renamed};+use anyhow::{Context, Result};+use serde_json::{Map, Value, json};+use std::collections::HashSet;+use std::path::{Path, PathBuf};++/// Older pi has no `registerMcpServer` and starts without the tools. With pi-acp's own bridge (`PI_ACP_MCP_SERVERS`)+/// pi already has them, and registering them twice would stop pi. A server that can't register (another extension+/// already has its name) is the only one left out: pi doesn't start when an extension throws.+const EXTENSION: &str = r#"export default function (pi) {+ if (typeof pi.registerMcpServer !== "function" || process.env.PI_ACP_MCP_SERVERS) return;+ const servers = JSON.parse(process.env.CODYNC_PI_MCP_SERVERS || "{}");+ for (const [name, config] of Object.entries(servers)) {+ try {+ pi.registerMcpServer(name, config);+ } catch (e) {+ console.error(`codync: ${name}: ${e.message}`);+ }+ }+}+"#;++/// pi-acp's own command for pi, plus the extension beside the launcher.+#[cfg(unix)]+const LAUNCHER: (&str, &str) = ("pi-codync", "#!/bin/sh\nexec pi -e \"$(dirname \"$0\")/codync.js\" \"$@\"\n");+#[cfg(windows)]+const LAUNCHER: (&str, &str) = ("pi-codync.cmd", "@pi.cmd -e \"%~dp0codync.js\" %*\r\n");++/// Seconds pi waits for a tool call (60 by default): past the host's own limit for any of them (`mcp::call`, the+/// longest a team change waiting for its approval).+const CALL_TIMEOUT: u64 = crate::chat::manage::APPROVAL_TIMEOUT.as_secs() + 60;++/// The environment that gives pi `servers` (ACP `mcpServers`).+pub(super) async fn env(servers: &Value) -> Result<Vec<(String, String)>> {+ let dir = crate::service::data_dir().join("pi");+ let launcher = tokio::task::spawn_blocking(move || write_launcher(&dir)).await??;+ Ok(vec![+ ("PI_ACP_PI_COMMAND".into(), launcher.to_string_lossy().into_owned()),+ ("CODYNC_PI_MCP_SERVERS".into(), pi_servers(servers).to_string()),+ ])+}++/// Renames each of `servers` whose name pi's own MCP config has (`mcp.json` in pi's agent folder or the project's+/// `.pi`, disabled entries too): pi leaves out a registered server its config names. `agent_dir` is the agent's+/// own `PI_CODING_AGENT_DIR` when it has one.+pub(super) async fn avoid_clashes(servers: &mut Value, cwd: &str, agent_dir: Option<PathBuf>) -> Renamed {+ let agent_dir = agent_dir+ .or_else(|| std::env::var_os("PI_CODING_AGENT_DIR").map(PathBuf::from))+ .or_else(|| dirs::home_dir().map(|h| h.join(".pi/agent")));+ let files = agent_dir.into_iter().chain([Path::new(cwd).join(".pi")]).map(|dir| dir.join("mcp.json")).collect();+ codex_names::rename_taken(servers, files, taken).await+}++/// Every server name in the `mcpServers` of `files`.+fn taken(files: &[PathBuf]) -> HashSet<String> {+ files+ .iter()+ .filter_map(|file| std::fs::read_to_string(file).ok())+ .filter_map(|text| serde_json::from_str::<Value>(text.trim_start_matches('\u{feff}')).ok())+ .filter_map(|config| config["mcpServers"].as_object().map(|s| s.keys().cloned().collect::<Vec<_>>()))+ .flatten()+ .collect()+}++/// Blocking: the launcher and the extension in `dir`, each written beside the old one and renamed over it, and+/// only when it changed, so a pi starting meanwhile never reads half a file.+fn write_launcher(dir: &Path) -> Result<PathBuf> {+ std::fs::create_dir_all(dir).with_context(|| format!("creating {}", dir.display()))?;+ let launcher = dir.join(LAUNCHER.0);+ for (path, text) in [(dir.join("codync.js"), EXTENSION), (launcher.clone(), LAUNCHER.1)] {+ if std::fs::read_to_string(&path).is_ok_and(|t| t == text) {+ continue;+ }+ let temporary = path.with_extension(format!("{}.tmp", uuid::Uuid::new_v4()));+ std::fs::write(&temporary, text).with_context(|| format!("writing {}", temporary.display()))?;+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ std::fs::set_permissions(&temporary, std::fs::Permissions::from_mode(0o755))?;+ }+ std::fs::rename(&temporary, &path).with_context(|| format!("writing {}", path.display()))?;+ }+ Ok(launcher)+}++/// ACP's `[{name, command, args, env: [{name, value}]}]` as pi's `{name: {command, args, env: {name: value}}}`,+/// declared to the model like built-in tools (`direct`), as every other harness has them.+fn pi_servers(servers: &Value) -> Value {+ let mut out = Map::new();+ for s in servers.as_array().into_iter().flatten() {+ let Some(name) = s["name"].as_str() else { continue };+ let env: Map<String, Value> = s["env"]+ .as_array()+ .into_iter()+ .flatten()+ .filter_map(|e| Some((e["name"].as_str()?.to_owned(), e["value"].clone())))+ .collect();+ out.insert(+ name.to_owned(),+ json!({"command": s["command"], "args": s["args"], "env": env, "exposure": "direct", "timeout": CALL_TIMEOUT}),+ );+ }+ Value::Object(out)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn acp_servers_become_direct_pi_servers() {+ let acp = json!([{"name": "manage", "command": "/bin/codync-host", "args": ["mcp", "manage"],+ "env": [{"name": "CODYNC_HOME", "value": "/h"}]}]);+ assert_eq!(+ pi_servers(&acp),+ json!({"manage": {"command": "/bin/codync-host", "args": ["mcp", "manage"],+ "env": {"CODYNC_HOME": "/h"}, "exposure": "direct", "timeout": 330}})+ );+ }++ #[test]+ fn the_launcher_is_written_once() {+ let dir = std::env::temp_dir().join(format!("codync-pi-tools-{}", uuid::Uuid::new_v4()));+ let launcher = write_launcher(&dir).unwrap();+ let written = std::fs::metadata(&launcher).unwrap().modified().unwrap();+ assert_eq!(write_launcher(&dir).unwrap(), launcher);+ assert_eq!(std::fs::metadata(&launcher).unwrap().modified().unwrap(), written);+ assert_eq!(std::fs::read_to_string(dir.join("codync.js")).unwrap(), EXTENSION);+ assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 2, "no temporary file is left");+ std::fs::remove_dir_all(dir).unwrap();+ }++ #[tokio::test]+ async fn servers_pis_config_names_get_a_free_name() {+ let dir = std::env::temp_dir().join(format!("codync-pi-names-{}", uuid::Uuid::new_v4()));+ std::fs::create_dir_all(dir.join("agent")).unwrap();+ std::fs::create_dir_all(dir.join("app/.pi")).unwrap();+ std::fs::write(dir.join("agent/mcp.json"), "\u{feff}{\"mcpServers\": {\"memory\": {\"enabled\": false}}}")+ .unwrap();+ std::fs::write(dir.join("app/.pi/mcp.json"), r#"{"mcpServers": {"google_drive": {"command": "x"}}}"#).unwrap();+ let mut servers = json!([{"name": "memory"}, {"name": "google-drive"}, {"name": "chat"}]);+ let cwd = dir.join("app").display().to_string();+ let renamed = avoid_clashes(&mut servers, &cwd, Some(dir.join("agent"))).await;+ assert_eq!(servers, json!([{"name": "codync-memory"}, {"name": "codync-google-drive"}, {"name": "chat"}]));+ assert_eq!(renamed.len(), 2);+ std::fs::remove_dir_all(dir).unwrap();+ }+}diff --git a/host/src/agent/bot/session.rs b/host/src/agent/bot/session.rsindex 2eb63cdb..1dbfac08 100644--- a/host/src/agent/bot/session.rs+++ b/host/src/agent/bot/session.rs@@ -2,7 +2,7 @@use super::fast_mode::Listing;use super::launch::{claude_meta, launch_commands, select_model, start_agent, system_prompt};-use super::{Actor, Adapter, Conn, Instructions, codex_names};+use super::{Actor, Adapter, Conn, Instructions, codex_names, pi_tools};use crate::agent::acp::{self, Incoming};use crate::agent::own_memory;use crate::agent::registry::Candidate;@@ -83,6 +83,15 @@ impl Actor {self.conn.as_ref().zip(sid).and_then(|(c, sid)| c.renamed.get(sid)).unwrap_or(&NONE)}+ /// A folder saved for the bot's agent (`setAgentEnv`) as `key`, such as where its own config is (`CODEX_HOME`).+ fn saved_env(&self, key: &str) -> Option<std::path::PathBuf> {+ let saved = crate::agent::auth::env(&self.hub.store, &self.cfg.backend).unwrap_or_else(|e| {+ tracing::warn!(error = format!("{e:#}"), "couldn't read the agent's saved environment");+ Vec::new()+ });+ saved.into_iter().find(|(k, _)| k == key).map(|(_, v)| v.into())+ }+/// ACP connectors, team collaboration, and optional team management and computer control.pub(super) fn mcp_servers(&self) -> Result<Value> {let Ok(exe) = std::env::current_exe() else {@@ -157,6 +166,14 @@ impl Actor {{c.acp.kill().await;}+ let mut servers = self.mcp_servers()?;+ // pi gets its servers when it starts (`pi_tools`), so they take pi's names before that.+ let pi = self.cfg.backend == "pi";+ let mut renamed = if pi {+ pi_tools::avoid_clashes(&mut servers, &self.cfg.cwd, self.saved_env("PI_CODING_AGENT_DIR")).await+ } else {+ codex_names::Renamed::new()+ };if self.conn.is_none() {let (hub, id) = (self.hub.clone(), self.cfg.id.clone());let progress = move |msg: &str| {@@ -171,6 +188,9 @@ impl Actor {let config = json!({"compact_prompt": codync_mem::compaction::KEEP});env.push(("CODEX_CONFIG".into(), config.to_string()));}+ if pi {+ env.extend(pi_tools::env(&servers).await?);+ }let mut last_err = None;let count = candidates.len();for (i, candidate) in candidates.into_iter().enumerate() {@@ -189,18 +209,9 @@ impl Actor {return Err(last_err.unwrap_or_else(|| anyhow!("agent failed to start")));}}- let mut servers = self.mcp_servers()?;- let renamed = if self.conn.as_ref().is_some_and(|c| c.adapter == Adapter::Codex) {- // A `CODEX_HOME` saved for Codex (`setAgentEnv`) is where its own config is.- let saved = crate::agent::auth::env(&self.hub.store, &self.cfg.backend).unwrap_or_else(|e| {- tracing::warn!(error = format!("{e:#}"), "couldn't read Codex's saved environment");- Vec::new()- });- let home = saved.into_iter().find(|(k, _)| k == "CODEX_HOME").map(|(_, v)| v.into());- codex_names::avoid_clashes(&mut servers, &self.cfg.cwd, home).await- } else {- codex_names::Renamed::new()- };+ if self.conn.as_ref().is_some_and(|c| c.adapter == Adapter::Codex) {+ renamed = codex_names::avoid_clashes(&mut servers, &self.cfg.cwd, self.saved_env("CODEX_HOME")).await;+ }let instructions = self.conn.as_ref().map_or(Instructions::FirstMessage, Conn::instructions);// Claude gets the frozen instructions as its system prompt. When a compaction// re-rendered them, loading the session again swaps the prompt in (the adapterdiff --git a/host/src/agent/bot/tool_entry.rs b/host/src/agent/bot/tool_entry.rsindex 0690f37b..5bc9aabd 100644--- a/host/src/agent/bot/tool_entry.rs+++ b/host/src/agent/bot/tool_entry.rs@@ -68,12 +68,14 @@ fn diff_summary(path: &str, old: &str, new: &str) -> Value {}/// A call of Codync's MCP server `server` (a tool starting with `tool`), by the name the agent titles it with:-/// Claude's `mcp__chat__send_message`, codex-acp's `mcp.chat.send_message` (older ones `chat.send_message`), the-/// server under the name Codex knows it by (`codync-chat` when the user's Codex config has its own `chat`).+/// Claude's and pi's `mcp__chat__send_message`, codex-acp's `mcp.chat.send_message` (older ones+/// `chat.send_message`), the server under the name Codex or pi knows it by (`codync-chat` when the user's config+/// has its own `chat`, which pi titles `mcp__codync_chat__…`).fn calls(title: &str, renamed: &Renamed, server: &str, tool: &str) -> bool {+ let name = name_of(renamed, server);let codex = title.strip_prefix("mcp.").unwrap_or(title);- title.starts_with(&format!("mcp__{server}__{tool}"))- || codex.starts_with(&format!("{}.{tool}", name_of(renamed, server)))+ title.starts_with(&format!("mcp__{}__{tool}", name.replace('-', "_")))+ || codex.starts_with(&format!("{name}.{tool}"))}/// Composing the bot's message: the `chat` MCP server's `send_message`.@@ -129,7 +131,7 @@ mod tests {data}- /// Marked for a Codex bot whose Codex config has its own `memory` server.+ /// Marked for a bot whose agent's own config (Codex's, pi's) has its own `memory` server.fn marked_renamed(mut data: Value) -> Value {let cfg = serde_json::from_value(json!({"id": "b", "name": "Bot", "backend": "codex", "cwd": "/tmp"})).expect("a bot config");@@ -172,6 +174,8 @@ mod tests {assert_eq!(marked_renamed(json!({"title": "mcp.codync-memory.edit_memory"}))["bookkeeping"], true);assert_eq!(marked_renamed(json!({"title": "mcp.memory.create_entities"}))["bookkeeping"], false);assert_eq!(marked_renamed(json!({"title": "mcp.chat.send_message"}))["bookkeeping"], true);+ assert_eq!(marked_renamed(json!({"title": "mcp__codync_memory__edit_memory"}))["bookkeeping"], true);+ assert_eq!(marked_renamed(json!({"title": "mcp__memory__create_entities"}))["bookkeeping"], false);}#[test]diff --git a/web/content/docs/agents.mdx b/web/content/docs/agents.mdxindex d1f7c045..78fbabc0 100644--- a/web/content/docs/agents.mdx+++ b/web/content/docs/agents.mdx@@ -51,6 +51,8 @@ For these agents, Codync knows the command it looks for, how to install it and h| Poolside | `pool` | `pool login` || DeepSeek Harness | `dsh` | run `dsh web` and save your DeepSeek API key under **Settings → Models** |+A Pi bot gets Codync's tools (messages, memory, routines, connectors, managing the team) through pi's own MCP support, so it needs pi 0.99 or later. With an older pi the bot still runs, but without those tools until you update pi. If your pi `mcp.json` has a server with the same name as one of Codync's, such as `memory`, Codync's is called `codync-memory` for that bot, so the bot has both.+Signing in to Google Antigravity with `agy` in a terminal doesn't sign in the part Codync runs, so use the sign-in option in Codync's setup sheet for it.WorkBuddy is separate from CodeBuddy Code. Codync runs the CLI bundled in the WorkBuddy app: `WorkBuddy AI.app` (from workbuddy.ai) or `WorkBuddy.app` (from codebuddy.cn) on macOS, or its install folder on Windows (`%LOCALAPPDATA%\Programs\WorkBuddy AI` or `WorkBuddy`). That CLI only ships WorkBuddy's lite build, so Codync starts it the way the app does. It runs on Node.js: if the computer has none, Codync offers to add its own. Codync does not install WorkBuddy, and there is no Linux build, so Codync on Linux doesn't list it. Sign in from Codync: the WorkBuddy app's login stays in the app, so this CLI asks again and opens a browser. A `codebuddy` command on your `PATH` stays CodeBuddy Code.