tenant.openagents/omega

1use std::{
2    path::{Path, PathBuf},
3    str::FromStr,
4    sync::Arc,
5};
6
7use anyhow::{Context, Result};
8use async_trait::async_trait;
9use collections::HashMap;
10use dap::{
11    StartDebuggingRequestArgumentsRequest,
12    adapters::{
13        DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, DebugTaskDefinition,
14    },
15};
16use extension::{Extension, WorktreeDelegate};
17use gpui::AsyncApp;
18use task::{DebugScenario, ZedDebugConfig};
19use util::rel_path::RelPath;
20
21pub(crate) struct ExtensionDapAdapter {
22    extension: Arc<dyn Extension>,
23    debug_adapter_name: Arc<str>,
24    schema: serde_json::Value,
25}
26
27impl ExtensionDapAdapter {
28    pub(crate) fn new(
29        extension: Arc<dyn extension::Extension>,
30        debug_adapter_name: Arc<str>,
31        schema_path: &Path,
32    ) -> Result<Self> {
33        let schema = std::fs::read_to_string(&schema_path).with_context(|| {
34            format!(
35                "Failed to read debug adapter schema for {debug_adapter_name} (from path: `{schema_path:?}`)"
36            )
37        })?;
38        let schema = serde_json::Value::from_str(&schema).with_context(|| {
39            format!("Debug adapter schema for {debug_adapter_name} is not a valid JSON")
40        })?;
41        Ok(Self {
42            extension,
43            debug_adapter_name,
44            schema,
45        })
46    }
47}
48
49/// An adapter that allows an [`dap::adapters::DapDelegate`] to be used as a [`WorktreeDelegate`].
50struct WorktreeDelegateAdapter(pub Arc<dyn DapDelegate>);
51
52#[async_trait]
53impl WorktreeDelegate for WorktreeDelegateAdapter {
54    fn id(&self) -> u64 {
55        self.0.worktree_id().to_proto()
56    }
57
58    fn root_path(&self) -> String {
59        self.0.worktree_root_path().to_string_lossy().into_owned()
60    }
61
62    async fn read_text_file(&self, path: &RelPath) -> Result<String> {
63        self.0.read_text_file(path).await
64    }
65
66    async fn which(&self, binary_name: String) -> Option<String> {
67        self.0
68            .which(binary_name.as_ref())
69            .await
70            .map(|path| path.to_string_lossy().into_owned())
71    }
72
73    async fn shell_env(&self) -> Vec<(String, String)> {
74        self.0.shell_env().await.into_iter().collect()
75    }
76}
77
78#[async_trait(?Send)]
79impl DebugAdapter for ExtensionDapAdapter {
80    fn name(&self) -> DebugAdapterName {
81        self.debug_adapter_name.as_ref().into()
82    }
83
84    fn dap_schema(&self) -> serde_json::Value {
85        self.schema.clone()
86    }
87
88    async fn get_binary(
89        &self,
90        delegate: &Arc<dyn DapDelegate>,
91        config: &DebugTaskDefinition,
92        user_installed_path: Option<PathBuf>,
93        // TODO support user args in the extension API
94        _user_args: Option<Vec<String>>,
95        // TODO support user env in the extension API
96        _user_env: Option<HashMap<String, String>>,
97        _cx: &mut AsyncApp,
98    ) -> Result<DebugAdapterBinary> {
99        self.extension
100            .get_dap_binary(
101                self.debug_adapter_name.clone(),
102                config.clone(),
103                user_installed_path,
104                Arc::new(WorktreeDelegateAdapter(delegate.clone())),
105            )
106            .await
107    }
108
109    async fn config_from_zed_format(&self, zed_scenario: ZedDebugConfig) -> Result<DebugScenario> {
110        self.extension.dap_config_to_scenario(zed_scenario).await
111    }
112
113    async fn request_kind(
114        &self,
115        config: &serde_json::Value,
116    ) -> Result<StartDebuggingRequestArgumentsRequest> {
117        self.extension
118            .dap_request_kind(self.debug_adapter_name.clone(), config.clone())
119            .await
120    }
121}
122