use super::tool_permissions::{    ResolvedProjectPath, authorize_symlink_access, canonicalize_worktree_roots,    resolve_project_path,};use crate::{AgentTool, ToolInput};use agent_client_protocol::ToolKind;use futures::FutureExt as _;use gpui::{App, AppContext as _, Entity, SharedString, Task};use project::Project;use schemars::JsonSchema;use serde::{Deserialize, Serialize};use std::{path::PathBuf, sync::Arc};use util::markdown::MarkdownEscaped; /// This tool opens a file or URL with the default application associated with it on the user's operating system:////// - On macOS, it's equivalent to the `open` command/// - On Windows, it's equivalent to `start`/// - On Linux, it uses something like `xdg-open`, `gio open`, `gnome-open`, `kde-open`, `wslview` as appropriate////// For example, it can open a web browser with a URL, open a PDF file with the default PDF viewer, etc.////// You MUST ONLY use this tool when the user has explicitly requested opening something. You MUST NEVER assume that the user would like for you to use this tool.#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]pub struct OpenToolInput {    /// The path or URL to open with the default application.    path_or_url: String,} pub struct OpenTool {    project: Entity<Project>,} impl OpenTool {    pub fn new(project: Entity<Project>) -> Self {        Self { project }    }} impl AgentTool for OpenTool {    type Input = OpenToolInput;    type Output = String;     const NAME: &'static str = "open";     fn kind() -> ToolKind {        ToolKind::Execute    }     fn initial_title(        &self,        input: Result<Self::Input, serde_json::Value>,        _cx: &mut App,    ) -> SharedString {        if let Ok(input) = input {            format!("Open `{}`", MarkdownEscaped(&input.path_or_url)).into()        } else {            "Open file or URL".into()        }    }     fn run(        self: Arc<Self>,        input: ToolInput<Self::Input>,        event_stream: crate::ToolCallEventStream,        cx: &mut App,    ) -> Task<Result<Self::Output, Self::Output>> {        let project = self.project.clone();        cx.spawn(async move |cx| {            let input = input                .recv()                .await                .map_err(|e| format!("Failed to receive tool input: {e}"))?;             // If path_or_url turns out to be a path in the project, make it absolute.            let (abs_path, initial_title) = cx.update(|cx| {                let abs_path = to_absolute_path(&input.path_or_url, project.clone(), cx);                let initial_title = self.initial_title(Ok(input.clone()), cx);                (abs_path, initial_title)            });             let fs = project.read_with(cx, |project, _cx| project.fs().clone());            let canonical_roots = canonicalize_worktree_roots(&project, &fs, cx).await;             // Symlink escape authorization replaces (rather than supplements)            // the normal tool-permission prompt. The symlink prompt already            // requires explicit user approval with the canonical target shown,            // which is strictly more security-relevant than a generic confirm.            let symlink_escape = project.read_with(cx, |project, cx| {                match resolve_project_path(                    project,                    PathBuf::from(&input.path_or_url),                    &canonical_roots,                    cx,                ) {                    Ok(ResolvedProjectPath::SymlinkEscape {                        canonical_target, ..                    }) => Some(canonical_target),                    _ => None,                }            });             let authorize = if let Some(canonical_target) = symlink_escape {                cx.update(|cx| {                    authorize_symlink_access(                        Self::NAME,                        &input.path_or_url,                        &canonical_target,                        &event_stream,                        cx,                    )                })            } else {                cx.update(|cx| {                    let context = crate::ToolPermissionContext::new(                        Self::NAME,                        vec![input.path_or_url.clone()],                    );                    event_stream.authorize(initial_title, context, cx)                })            };             futures::select! {                result = authorize.fuse() => result.map_err(|e| e.to_string())?,                _ = event_stream.cancelled_by_user().fuse() => {                    return Err("Open cancelled by user".to_string());                }            }             let path_or_url = input.path_or_url.clone();            cx.background_spawn(async move {                match abs_path {                    Some(path) => open::that(path),                    None => open::that(path_or_url),                }                .map_err(|e| format!("Failed to open URL or file path: {e}"))            })            .await?;             Ok(format!("Successfully opened {}", input.path_or_url))        })    }} fn to_absolute_path(    potential_path: &str,    project: Entity<Project>,    cx: &mut App,) -> Option<PathBuf> {    let project = project.read(cx);    project        .find_project_path(PathBuf::from(potential_path), cx)        .and_then(|project_path| project.absolute_path(&project_path, cx))} #[cfg(test)]mod tests {    use super::*;    use gpui::TestAppContext;    use project::{FakeFs, Project};    use settings::SettingsStore;    use std::path::Path;    use tempfile::TempDir;     #[gpui::test]    async fn test_to_absolute_path(cx: &mut TestAppContext) {        init_test(cx);        let temp_dir = TempDir::new().expect("Failed to create temp directory");        let temp_path = temp_dir.path().to_string_lossy().into_owned();         let fs = FakeFs::new(cx.executor());        fs.insert_tree(            &temp_path,            serde_json::json!({                "src": {                    "main.rs": "fn main() {}",                    "lib.rs": "pub fn lib_fn() {}"                },                "docs": {                    "readme.md": "# Project Documentation"                }            }),        )        .await;         // Use the temp_path as the root directory, not just its filename        let project = Project::test(fs.clone(), [temp_dir.path()], cx).await;         // Test cases where the function should return Some        cx.update(|cx| {            // Project-relative paths should return Some            // Create paths using the last segment of the temp path to simulate a project-relative path            let root_dir_name = Path::new(&temp_path)                .file_name()                .unwrap_or_else(|| std::ffi::OsStr::new("temp"))                .to_string_lossy();             assert!(                to_absolute_path(&format!("{root_dir_name}/src/main.rs"), project.clone(), cx)                    .is_some(),                "Failed to resolve main.rs path"            );             assert!(                to_absolute_path(                    &format!("{root_dir_name}/docs/readme.md",),                    project.clone(),                    cx,                )                .is_some(),                "Failed to resolve readme.md path"            );             // External URL should return None            let result = to_absolute_path("https://example.com", project.clone(), cx);            assert_eq!(result, None, "External URLs should return None");             // Path outside project            let result = to_absolute_path("../invalid/path", project.clone(), cx);            assert_eq!(result, None, "Paths outside the project should return None");        });    }     fn init_test(cx: &mut TestAppContext) {        cx.update(|cx| {            let settings_store = SettingsStore::test(cx);            cx.set_global(settings_store);        });    }}