Refine ACP and watcher handling

Author: vipmax

.gitignore

@@ -7,3 +7,4 @@ anycode/dist
 anycode-base/dist
 anycode-backend/dist/*
 !anycode-backend/dist/.gitkeep
+csharp-test-project

README.md

@@ -1,6 +1,6 @@
 # anycode
 
-**anycode** is a lightning-fast web-based IDE that allows you to write, edit, and manage code directly from your browser. Built for speed and performance, anycode supports a wide range of programming languages and provides an intuitive interface with powerful features for a seamless development experience.
+**anycode** is a web platform where people and agents build together. Run it locally or remotely and work from any device you want: desktop, laptop, mobile, or even VR. Use any agent, including Codex, Claude Code, OpenCode, as well as local models.
 
 ![editor](anycode/imgs/screen.png)
 ![agents](anycode/imgs/agents.png)
@@ -60,35 +60,6 @@ One-shot installer:
 curl -fsSL https://raw.githubusercontent.com/anycode-ade/anycode/main/install.sh | sh
 ```
 
-You can also pin a version:
-```bash
-curl -fsSL https://raw.githubusercontent.com/anycode-ade/anycode/main/install.sh | sh -s -- --version v0.0.10
-```
-
-Linux (x86_64):
-```bash
-curl -L https://github.com/anycode-ade/anycode/releases/latest/download/anycode-linux-x86_64-musl.tar.gz | tar -xz
-sudo mv anycode /usr/local/bin/
-sudo chmod +x /usr/local/bin/anycode
-anycode
-```
-
-Linux (ARM64):
-```bash
-curl -L https://github.com/anycode-ade/anycode/releases/latest/download/anycode-linux-aarch64-musl.tar.gz | tar -xz
-sudo mv anycode /usr/local/bin/
-sudo chmod +x /usr/local/bin/anycode
-anycode
-```
-
-MacOS:
-```bash
-curl -L https://github.com/anycode-ade/anycode/releases/latest/download/anycode-universal-apple-darwin.tar.gz | tar -xz
-sudo mv anycode /usr/local/bin/
-sudo chmod +x /usr/local/bin/anycode
-anycode
-```
-
 ## Development
 
 1. **Start frontend:**

anycode-backend/src/acp.rs

@@ -11,7 +11,7 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 use tokio::io::{self, AsyncBufReadExt, BufReader};
 use tokio::process::Command;
-use tokio::sync::{Mutex, RwLock, broadcast, mpsc, oneshot::Sender};
+use tokio::sync::{Mutex, RwLock, broadcast, mpsc, oneshot};
 use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
 use tracing::{debug, error, info};
 
@@ -229,7 +229,7 @@ struct AcpClientImpl {
     message_sender: broadcast::Sender<AcpMessage>,
     history: Arc<tokio::sync::Mutex<Vec<AcpMessage>>>,
     /// Pending permission requests waiting for user response
-    pending_permissions: Arc<Mutex<HashMap<String, Sender<PermissionResponse>>>>,
+    pending_permissions: Arc<Mutex<HashMap<String, oneshot::Sender<PermissionResponse>>>>,
     /// Channel to send file operations to the ACP filesystem background task
     fs_sender: Option<mpsc::Sender<AcpFsCommand>>,
 }
@@ -1099,7 +1099,7 @@ impl AcpClientImpl {
 
 /// Type alias for pending permissions map
 pub type PendingPermissionsMap =
-    Arc<tokio::sync::Mutex<HashMap<String, tokio::sync::oneshot::Sender<PermissionResponse>>>>;
+    Arc<tokio::sync::Mutex<HashMap<String, oneshot::Sender<PermissionResponse>>>>;
 
 enum RestoreSessionOutcome {
     Restored(SessionBootstrap),
@@ -1204,7 +1204,7 @@ impl AcpAgent {
             *cancel_sender_guard = Some(cancel_tx.clone());
         }
 
-        let (session_tx, mut session_rx) = mpsc::channel::<acp::SessionId>(1);
+        let (bootstrap_tx, bootstrap_rx) = oneshot::channel::<Result<SessionBootstrap>>();
 
         // Spawn agent process
         let (mut child, stdin, stdout, stderr) = Self::spawn_agent_process(cmd, args)?;
@@ -1237,7 +1237,7 @@ impl AcpAgent {
                             prompt_rx,
                             config_rx,
                             cancel_rx,
-                            session_tx,
+                            bootstrap_tx,
                             resume_session_id,
                         )
                         .await;
@@ -1255,15 +1255,19 @@ impl AcpAgent {
         });
         self.process_handle = Some(process_handle);
 
-        match tokio::time::timeout(tokio::time::Duration::from_secs(15), session_rx.recv()).await {
-            Ok(Some(session_id)) => {
-                self.session_id = Some(session_id.clone());
-                Ok(session_id.to_string())
+        match tokio::time::timeout(tokio::time::Duration::from_secs(15), bootstrap_rx).await {
+            Ok(Ok(Ok(bootstrap))) => {
+                self.session_id = Some(bootstrap.session_id.clone());
+                Ok(bootstrap.session_id.to_string())
             }
-            Ok(None) => {
+            Ok(Ok(Err(e))) => {
+                self.stop().await;
+                Err(e)
+            }
+            Ok(Err(_)) => {
                 self.stop().await;
                 Err(anyhow!(
-                    "ACP agent session channel closed before initialization"
+                    "ACP agent initialization channel closed before initialization"
                 ))
             }
             Err(_) => {
@@ -1313,7 +1317,7 @@ impl AcpAgent {
         mut prompt_rx: mpsc::Receiver<String>,
         mut config_rx: mpsc::Receiver<PendingConfigUpdate>,
         mut cancel_rx: mpsc::Receiver<()>,
-        session_tx: mpsc::Sender<acp::SessionId>,
+        bootstrap_tx: oneshot::Sender<Result<SessionBootstrap>>,
         resume_session_id: Option<String>,
     ) {
         // Clone history before moving client_impl
@@ -1353,47 +1357,41 @@ impl AcpAgent {
         let bootstrap = match Self::initialize_connection(&conn, &agent_id, resume_session_id).await
         {
             Ok(bootstrap) => {
-                let _ = session_tx.send(bootstrap.session_id.clone()).await;
                 ready.store(true, Ordering::SeqCst);
+                let _ = bootstrap_tx.send(Ok(bootstrap.clone()));
                 Some(bootstrap)
             }
             Err(e) => {
-                error!("Failed to initialize ACP agent {}: {}", agent_id, e);
+                let err = anyhow!("Failed to initialize ACP agent {}: {}", agent_id, e);
+                error!("{}", err);
+                let _ = bootstrap_tx.send(Err(err));
                 None
             }
         };
 
-        // Handle prompts in a loop
-        if let Some(bootstrap) = bootstrap {
-            Self::emit_session_config_messages(
-                &message_sender,
-                &history_for_prompt,
-                bootstrap.model_selector.clone(),
-                bootstrap.reasoning_selector.clone(),
-            )
-            .await;
+        let Some(bootstrap) = bootstrap else {
+            return;
+        };
 
-            Self::run_prompt_loop(
-                &conn,
-                &agent_id,
-                &message_sender,
-                history_for_prompt,
-                bootstrap.session_id,
-                &mut prompt_rx,
-                &mut config_rx,
-                &mut cancel_rx,
-            )
-            .await;
-        } else {
-            error!(
-                "No session ID for agent {}, cannot handle prompts",
-                agent_id
-            );
-            // Keep the connection alive if no session
-            loop {
-                tokio::time::sleep(tokio::time::Duration::from_secs(3600)).await;
-            }
-        }
+        Self::emit_session_config_messages(
+            &message_sender,
+            &history_for_prompt,
+            bootstrap.model_selector.clone(),
+            bootstrap.reasoning_selector.clone(),
+        )
+        .await;
+
+        Self::run_prompt_loop(
+            &conn,
+            &agent_id,
+            &message_sender,
+            history_for_prompt,
+            bootstrap.session_id,
+            &mut prompt_rx,
+            &mut config_rx,
+            &mut cancel_rx,
+        )
+        .await;
     }
 
     fn spawn_stderr_reader(

anycode-backend/src/handlers/acp_handler.rs

@@ -78,6 +78,16 @@ pub async fn handle_acp_start(
         }
         Err(e) => {
             error!("Failed to start ACP agent {}: {}", agent_id, e);
+            let _ = socket.emit(
+                "acp:message",
+                &json!({
+                    "agent_id": agent_id,
+                    "item": {
+                        "role": "error",
+                        "message": format!("Failed to start agent: {}", e),
+                    }
+                }),
+            );
             error_ack!(ack, &agent_id, "Failed to start agent: {}", e);
         }
     }

anycode-backend/src/handlers/watch_handler.rs

@@ -14,6 +14,7 @@ use crate::code::Code;
 use crate::diff::compute_text_edits;
 use crate::handlers::io_handler::apply_edits_to_code;
 use crate::lsp::LspManager;
+use crate::utils::normalize_watch_path;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 enum FileState {
@@ -147,10 +148,8 @@ pub async fn handle_watch_event(
     git_manager: &Arc<Mutex<crate::git::GitManager>>,
     lsp_manager: &Arc<Mutex<LspManager>>,
 ) {
-    let path_str = match path.to_str() {
-        Some(s) => s.to_string(),
-        None => return,
-    };
+    let normalized_path = normalize_watch_path(path);
+    let path_str = normalized_path.to_string_lossy().to_string();
 
     let (should_spawn, rx) = {
         let mut states = file_states.lock().await;
@@ -181,7 +180,7 @@ pub async fn handle_watch_event(
     let mut rx = rx.unwrap();
 
     // Spawn a single debounce task for this file
-    let path = path.clone();
+    let path = normalized_path.clone();
     let socket = socket.clone();
     let file2code = file2code.clone();
     let socket2data = socket2data.clone();
@@ -384,6 +383,8 @@ async fn handle_file_modification(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::utils::current_dir;
+    use std::path::Path;
 
     #[test]
     fn unopened_new_file_is_classified_as_create() {
@@ -408,4 +409,14 @@ mod tests {
             WatchAction::Modify
         );
     }
+
+    #[test]
+    fn watcher_paths_are_normalized_before_comparison() {
+        let cwd = current_dir();
+        let normalized = normalize_watch_path(Path::new("./test.js"));
+        assert_eq!(normalized, cwd.join("test.js"));
+
+        let normalized = normalize_watch_path(Path::new(&cwd.join("./test.js")));
+        assert_eq!(normalized, cwd.join("test.js"));
+    }
 }

anycode-backend/src/search.rs

@@ -270,7 +270,6 @@ pub async fn global_search(
 }
 
 pub mod search_exp {
-    
 
     #[test]
     fn test_line_search_simple() {

anycode-backend/src/utils.rs

@@ -1,6 +1,6 @@
 use lsp_types::Uri;
 use pathdiff::diff_paths;
-use std::path::{Path, PathBuf};
+use std::path::{Component, Path, PathBuf};
 
 pub const DEFAULT_IGNORE_DIRS: &[&str] = &[
     // Version control and IDEs
@@ -182,6 +182,34 @@ pub fn abs_file(input: &str) -> anyhow::Result<String> {
     Ok(c.to_string_lossy().to_string())
 }
 
+/// Normalize a path for watcher comparisons without requiring the file to exist.
+///
+/// This resolves `.` and `..` segments and makes relative paths absolute against the
+/// current working directory, but does not follow symlinks.
+pub fn normalize_watch_path(path: &Path) -> PathBuf {
+    let absolute = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        current_dir().join(path)
+    };
+
+    let mut normalized = PathBuf::new();
+
+    for component in absolute.components() {
+        match component {
+            Component::Prefix(prefix) => normalized.push(prefix.as_os_str()),
+            Component::RootDir => normalized.push(component.as_os_str()),
+            Component::CurDir => {}
+            Component::ParentDir => {
+                normalized.pop();
+            }
+            Component::Normal(part) => normalized.push(part),
+        }
+    }
+
+    normalized
+}
+
 pub fn file_name(input: &str) -> String {
     let path_buf = std::path::PathBuf::from(input);
     let file_name = path_buf.file_name().unwrap().to_string_lossy().into_owned();

anycode/components/agent/AcpInput.css

@@ -64,9 +64,9 @@
 
 .acp-input-preview-text {
     flex: 1;
-    font-weight: 500;
-    font-size: 14px;
-    line-height: 1.5;
+
+    font-size: 12px;
+
     color: rgba(255, 255, 255, 0.7);
     white-space: nowrap;
     overflow: hidden;

anycode/components/agent/AcpMessage.tsx

@@ -55,7 +55,7 @@ const SUPPORTED_LANGUAGES: Record<string, string> = {
   cxx: 'cpp',
   hpp: 'cpp',
   h: 'c',
-  md: 'text',
+  md: 'markdown',
   markdown: 'text',
   diff: 'text',
   text: 'text',

anycode/hooks/useAgents.ts

@@ -427,7 +427,8 @@ export const useAgents = ({
                 setSelectedAgentId(aid);
                 onAgentStarted?.();
             } else {
-                alert('Failed to start agent ' + aid + ': ' + response.error);
+                const errorMessage = response.error || `Failed to start agent ${aid}`;
+                alert(errorMessage);
             }
         });
         return aid;