The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(agents): discover Claude commands before the first task (#2166)
l0ng-aicb6bcd2fa29d
diff --git a/crates/ide-agent/src/lib.rs b/crates/ide-agent/src/lib.rsindex 986ee777e..4f3400d70 100644--- a/crates/ide-agent/src/lib.rs+++ b/crates/ide-agent/src/lib.rs@@ -100,6 +100,8 @@ struct Shared {providers: RwLock<Vec<provider::ProviderSpec>>,/// Last probe of each provider.probes: Mutex<HashMap<String, AgentProbe>>,+ /// One pre-session command lookup per provider, including failed attempts.+ command_fetches: Mutex<HashMap<String, tokio::sync::watch::Receiver<bool>>>,/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).idle_release_ms: AtomicU64,}@@ -151,6 +153,40 @@ impl Shared {cache.get(provider).and_then(|k| k.commands.get(&self.root_key())).cloned().unwrap_or_default()}+ async fn fetch_commands(self: &Arc<Self>, spec: provider::ProviderSpec) {+ let mut ready = {+ let mut fetches = self.command_fetches.lock();+ fetches+ .entry(spec.id.clone())+ .or_insert_with(|| {+ let (done, ready) = tokio::sync::watch::channel(false);+ let shared = self.clone();+ // Keep the lookup alive if a composer unmounts while it is waiting.+ self.runtime.spawn(async move {+ if let Ok(commands) =+ native::claude::commands(spec.clone(), shared.paths.project_root.clone()).await+ {+ let commands = config::commands_of(&json!({ "availableCommands": commands }), &spec.id);+ let _ = tokio::task::spawn_blocking(move || {+ if shared.known_commands(&spec.id).is_empty() {+ shared.remember(&spec.id, None, Some(&commands), None);+ }+ })+ .await;+ }+ let _ = done.send(true);+ });+ ready+ })+ .clone()+ };+ while !*ready.borrow_and_update() {+ if ready.changed().await.is_err() {+ break;+ }+ }+ }+fn root_key(&self) -> String {self.paths.project_root.to_string_lossy().into_owned()}@@ -317,6 +353,7 @@ impl AgentManager {known: Mutex::new(known),providers,probes: Mutex::new(HashMap::new()),+ command_fetches: Mutex::new(HashMap::new()),idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),});let mut tasks = HashMap::new();@@ -420,6 +457,13 @@ impl AgentManager {// Commands the agent implements itself and never lists (its CLI builtins):// merged without duplicating what `availableCommands` or the disk offer.let mut offered = offered;+ if task.is_none()+ && offered.is_empty()+ && let Some(spec) = self.shared.spec(&provider).filter(|s| s.driver == provider::Driver::Claude)+ {+ self.shared.fetch_commands(spec).await;+ offered = self.shared.known_commands(&provider);+ }for &(name, description) in builtin_commands(&provider) {if !offered.iter().any(|c| c.name == name) {offered.push(AgentCommand {diff --git a/crates/ide-agent/src/native/claude/mod.rs b/crates/ide-agent/src/native/claude/mod.rsindex 18adee689..e4e557162 100644--- a/crates/ide-agent/src/native/claude/mod.rs+++ b/crates/ide-agent/src/native/claude/mod.rs@@ -69,6 +69,38 @@ pub(crate) fn connect(Ok(super::serve(shim, client))}+/// Discover commands without a prompt, ACP session, or pending session file.+pub(crate) async fn commands(spec: ProviderSpec, cwd: PathBuf) -> Result<Vec<Value>, String> {+ tokio::time::timeout(Duration::from_secs(5), async move {+ let spec = tokio::task::spawn_blocking(move || (spec.resolve_for_launch(&cwd), cwd));+ let (spec, cwd) = spec.await.map_err(|e| e.to_string())?;+ let mut args = spec.args;+ args.extend(Start::New { id: uuid::Uuid::new_v4().to_string() }.args());+ let launch = Launch { program: spec.command, args, cwd, env: spec.env };+ let mut io = cli::Process.launch(&launch, Arc::new(|_| {})).map_err(|e| e.to_string())?;+ let _stop = io.kill.clone().drop_guard();+ let request = json!({ "type": "control_request", "request_id": "commands",+ "request": { "subtype": "initialize", "perTaskStopAffordance": true } });+ io.stdin.write_all(format!("{request}\n").as_bytes()).await.map_err(|e| e.to_string())?;+ io.stdin.flush().await.map_err(|e| e.to_string())?;+ let mut lines = BufReader::new(io.stdout).lines();+ while let Some(line) = lines.next_line().await.map_err(|e| e.to_string())? {+ let Ok(msg) = serde_json::from_str::<Value>(&line) else { continue };+ if msg["type"] == "control_response" && msg["response"]["request_id"] == "commands" {+ let response = &msg["response"];+ return if response["subtype"] == "success" {+ Ok(Settings::from_cli(&response["response"], &Value::Null).commands)+ } else {+ Err("Claude Code did not initialize".into())+ };+ }+ }+ Err("Claude Code exited".into())+ })+ .await+ .map_err(|_| "Claude Code command discovery timed out".to_owned())?+}+struct Config {pub program: String,/// Extra arguments (a custom agent's), before the session's own.diff --git a/crates/ide-agent/src/tests.rs b/crates/ide-agent/src/tests.rsindex 6193d45f2..9d5e4ef86 100644--- a/crates/ide-agent/src/tests.rs+++ b/crates/ide-agent/src/tests.rs@@ -339,6 +339,9 @@ fn manager(dir: &Path, agent: Arc<FakeAgent>) -> AgentManager {}fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManager {+ // These tests speak to FakeAgent, never an installed CLI, including after a provider reload.+ let agents = dir.join("agents");+ provider::set_builtin_command(&agents, "claude", Some(&dir.join("missing-claude").to_string_lossy())).unwrap();let connector: Connector = Arc::new(move |_spec, _cwd, client, _stderr| {let (a, b) = duplex(1 << 20);let (ar, aw) = tokio::io::split(a);@@ -353,7 +356,7 @@ fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManstore_dir: dir.join("store"),worktrees_dir: dir.join("worktrees"),models_file: models_file.to_path_buf(),- custom_agents_dir: None,+ custom_agents_dir: Some(agents),home_dir: None,},tokio::runtime::Handle::current(),@@ -361,6 +364,87 @@ fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentMan)}+#[cfg(unix)]+#[tokio::test(flavor = "multi_thread")]+async fn claude_commands_before_session_are_fetched_once_and_saved() {+ use std::os::unix::fs::PermissionsExt;++ for outcome in ["success", "error", "exit", "timeout", "missing"] {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path();+ let script = root.join("fake-claude");+ std::fs::write(+ &script,+ r#"#!/usr/bin/env python3+import json, os, pathlib, sys, time+root = pathlib.Path.cwd()+with (root / 'launches').open('a') as f:+ f.write(json.dumps(sys.argv[1:]) + '\n')+request = json.loads(sys.stdin.readline())+with (root / 'requests').open('a') as f:+ f.write(json.dumps(request) + '\n')+outcome = os.environ['OUTCOME']+if outcome == 'exit':+ sys.exit(1)+if outcome == 'timeout':+ time.sleep(60)+response = {'subtype': outcome, 'request_id': request['request_id']}+if outcome == 'success':+ response['response'] = {'commands': [+ {'name': 'compact', 'description': 'Free up context', 'argumentHint': '[instructions]'},+ {'name': 'clear'}, {'name': 'model'}, {'name': 'context'}]}+else:+ response['error'] = 'Authentication required'+print(json.dumps({'type': 'control_response', 'response': response}), flush=True)+for line in sys.stdin:+ with (root / 'requests').open('a') as f:+ f.write(line)+"#,+ )+ .unwrap();+ std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();+ std::fs::create_dir_all(root.join(".claude/skills/triage")).unwrap();+ std::fs::write(root.join(".claude/skills/triage/SKILL.md"), "---\nname: triage\ndescription: Triage\n---\n")+ .unwrap();+ let mgr = manager(root, Arc::new(FakeAgent::default()));+ {+ let mut providers = mgr.shared.providers.write();+ let spec = providers.iter_mut().find(|p| p.id == "claude").unwrap();+ if outcome != "missing" {+ spec.command = script.to_string_lossy().into_owned();+ }+ spec.env = vec![("OUTCOME".into(), outcome.into())];+ }+ let (first, concurrent) = tokio::join!(mgr.commands("claude", None), mgr.commands("claude", None));+ let first = first.unwrap();+ assert_eq!(first, concurrent.unwrap());+ assert_eq!(first, mgr.commands("claude", None).await.unwrap());+ let names: Vec<_> = first.iter().map(|c| c.name.as_str()).collect();+ if outcome == "success" {+ assert_eq!(names, ["compact", "clear", "model", "context", "triage"]);+ assert_eq!(first[0].hint.as_deref(), Some("[instructions]"));+ let restored = manager(root, Arc::new(FakeAgent::default()));+ assert_eq!(first, restored.commands("claude", None).await.unwrap());+ } else {+ assert_eq!(names, ["triage"], "{outcome}");+ assert!(!root.join("models.json").exists());+ }+ assert!(mgr.tasks.read().is_empty());+ assert!(!root.join("store").exists());+ if outcome != "missing" {+ let launches = std::fs::read_to_string(root.join("launches")).unwrap();+ assert_eq!(launches.lines().count(), 1, "{outcome}");+ let args: Vec<String> = serde_json::from_str(launches.trim()).unwrap();+ assert!(args.windows(2).any(|a| a == ["--input-format", "stream-json"]));+ let requests = std::fs::read_to_string(root.join("requests")).unwrap();+ assert_eq!(requests.lines().count(), 1, "only initialize, no prompt or other control request");+ let request: Value = serde_json::from_str(requests.trim()).unwrap();+ assert_eq!(request["type"], "control_request");+ assert_eq!(request["request"]["subtype"], "initialize");+ }+ }+}+#[tokio::test(flavor = "multi_thread")]async fn authentication_failures_name_the_session_executable_at_start_and_during_prompts() {for auth_on_new in [true, false] {