zed-industries · Swiftaff · Jan 8, 2025 · Jan 9, 2025
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/extension/src/extension_builder.rs b/crates/extension/src/extension_builder.rs
@@ -351,7 +351,9 @@ impl ExtensionBuilder {
             .arg("sysroot")
             .output()
             .context("failed to run rustc")?;
-        if !rustc_output.status.success() {
+        if !rustc_output.status.success()
+        //TEMPORARY TEST - comment out above line to fail dev extension loading
+        {
             bail!(
                 "failed to retrieve rust sysroot: {}",
                 String::from_utf8_lossy(&rustc_output.stderr)

diff --git a/crates/extension_host/src/extension_host.rs b/crates/extension_host/src/extension_host.rs
@@ -125,14 +125,17 @@ pub enum ExtensionOperation {
 }
 
 #[derive(Clone)]
-pub enum Event {
+pub enum ExtensionEvent {
     ExtensionsUpdated,
     StartedReloading,
+    DevExtensionInstalling(Arc<str>),
+    DevExtensionInstallFailed(Arc<str>),
+    DevExtensionInstallSuccess,
     ExtensionInstalled(Arc<str>),
     ExtensionFailedToLoad(Arc<str>),
 }
 
-impl EventEmitter<Event> for ExtensionStore {}
+impl EventEmitter<ExtensionEvent> for ExtensionStore {}
 
 struct GlobalExtensionStore(Model<ExtensionStore>);
 
@@ -167,6 +170,8 @@ pub struct ExtensionIndexLanguageEntry {
 }
 
 actions!(zed, [ReloadExtensions]);
+//moved from extension_us to avoid circular dependency
+actions!(zed, [InstallDevExtension]);
 
 pub fn init(
     extension_host_proxy: Arc<ExtensionHostProxy>,
@@ -399,7 +404,7 @@ impl ExtensionStore {
         self.reload_tx
             .unbounded_send(modified_extension)
             .expect("reload task exited");
-        cx.emit(Event::StartedReloading);
+        cx.emit(ExtensionEvent::StartedReloading);
 
         async move {
             rx.await.ok();
@@ -688,7 +693,7 @@ impl ExtensionStore {
 
             if let ExtensionOperation::Install = operation {
                 this.update(&mut cx, |_, cx| {
-                    cx.emit(Event::ExtensionInstalled(extension_id));
+                    cx.emit(ExtensionEvent::ExtensionInstalled(extension_id));
                 })
                 .ok();
             }
@@ -826,9 +831,22 @@ impl ExtensionStore {
 
         cx.spawn(move |this, mut cx| async move {
             let mut extension_manifest =
-                ExtensionManifest::load(fs.clone(), &extension_source_path).await?;
-            let extension_id = extension_manifest.id.clone();
+                ExtensionManifest::load(fs.clone(), &extension_source_path)
+                    .await
+                    .or_else(|e| {
+                        this.update(&mut cx, |_, cx| {
+                            let arc_string = Arc::new("invalid manifest".to_string());
+                            let arc_str: Arc<str> = Arc::from((&*arc_string).to_string());
+                            cx.emit(ExtensionEvent::DevExtensionInstallFailed(arc_str));
+                        })?;
+                        Err(e)
+                    })?;
 
+            let extension_id = extension_manifest.id.clone();
+            this.update(&mut cx, |_, cx| {
+                let arc_str: Arc<str> = extension_manifest.id.clone();
+                cx.emit(ExtensionEvent::DevExtensionInstalling(arc_str));
+            })?;
             if !this.update(&mut cx, |this, cx| {
                 match this.outstanding_operations.entry(extension_id.clone()) {
                     btree_map::Entry::Occupied(_) => return false,
@@ -866,7 +884,14 @@ impl ExtensionStore {
                             .await
                     }
                 })
-                .await?;
+                .await
+                .or_else(|e| {
+                    this.update(&mut cx, |_, cx| {
+                        let arc_str: Arc<str> = Arc::from(e.to_string());
+                        cx.emit(ExtensionEvent::DevExtensionInstallFailed(arc_str));
+                    })?;
+                    Err(e)
+                })?;
 
             let output_path = &extensions_dir.join(extension_id.as_ref());
             if let Some(metadata) = fs.metadata(output_path).await? {
@@ -889,6 +914,9 @@ impl ExtensionStore {
 
             this.update(&mut cx, |this, cx| this.reload(None, cx))?
                 .await;
+            this.update(&mut cx, |_, cx| {
+                cx.emit(ExtensionEvent::DevExtensionInstallSuccess);
+            })?;
             Ok(())
         })
     }
@@ -1132,7 +1160,7 @@ impl ExtensionStore {
 
         self.extension_index = new_index;
         cx.notify();
-        cx.emit(Event::ExtensionsUpdated);
+        cx.emit(ExtensionEvent::ExtensionsUpdated);
 
         cx.spawn(|this, mut cx| async move {
             cx.background_executor()
@@ -1177,7 +1205,9 @@ impl ExtensionStore {
                     wasm_extensions.push((extension.manifest.clone(), wasm_extension));
                 } else {
                     this.update(&mut cx, |_, cx| {
-                        cx.emit(Event::ExtensionFailedToLoad(extension.manifest.id.clone()))
+                        cx.emit(ExtensionEvent::ExtensionFailedToLoad(
+                            extension.manifest.id.clone(),
+                        ))
                     })
                     .ok();
                 }

diff --git a/crates/extension_host/src/extension_store_test.rs b/crates/extension_host/src/extension_store_test.rs
@@ -1,5 +1,5 @@
 use crate::{
-    Event, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
+    ExtensionEvent, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
     ExtensionIndexThemeEntry, ExtensionManifest, ExtensionSettings, ExtensionStore,
     GrammarManifestEntry, SchemaVersion, RELOAD_DEBOUNCE_DURATION,
 };
@@ -592,15 +592,15 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
     let executor = cx.executor();
     let _task = cx.executor().spawn(async move {
         while let Some(event) = events.next().await {
-            if let Event::StartedReloading = event {
+            if let ExtensionEvent::StartedReloading = event {
                 executor.advance_clock(RELOAD_DEBOUNCE_DURATION);
             }
         }
     });
 
     extension_store.update(cx, |_, cx| {
         cx.subscribe(&extension_store, |_, _, event, _| {
-            if matches!(event, Event::ExtensionFailedToLoad(_)) {
+            if matches!(event, ExtensionEvent::ExtensionFailedToLoad(_)) {
                 panic!("extension failed to load");
             }
         })

diff --git a/crates/extensions_ui/src/extensions_ui.rs b/crates/extensions_ui/src/extensions_ui.rs
@@ -10,10 +10,10 @@ use std::{ops::Range, sync::Arc};
 use client::ExtensionMetadata;
 use collections::{BTreeMap, BTreeSet};
 use editor::{Editor, EditorElement, EditorStyle};
-use extension_host::{ExtensionManifest, ExtensionOperation, ExtensionStore};
+use extension_host::{ExtensionManifest, ExtensionOperation, ExtensionStore, InstallDevExtension};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
-    actions, uniform_list, Action, AppContext, ClipboardItem, EventEmitter, Flatten, FocusableView,
+    uniform_list, Action, AppContext, ClipboardItem, EventEmitter, Flatten, FocusableView,
     InteractiveElement, KeyContext, ParentElement, Render, Styled, Task, TextStyle,
     UniformListScrollHandle, View, ViewContext, VisualContext, WeakView, WindowContext,
 };
@@ -34,8 +34,6 @@ use crate::extension_version_selector::{
     ExtensionVersionSelector, ExtensionVersionSelectorDelegate,
 };
 
-actions!(zed, [InstallDevExtension]);
-
 pub fn init(cx: &mut AppContext) {
     cx.observe_new_views(move |workspace: &mut Workspace, cx| {
         workspace
@@ -201,8 +199,10 @@ impl ExtensionsPage {
             let subscriptions = [
                 cx.observe(&store, |_, _, cx| cx.notify()),
                 cx.subscribe(&store, move |this, _, event, cx| match event {
-                    extension_host::Event::ExtensionsUpdated => this.fetch_extensions_debounced(cx),
-                    extension_host::Event::ExtensionInstalled(extension_id) => {
+                    extension_host::ExtensionEvent::ExtensionsUpdated => {
+                        this.fetch_extensions_debounced(cx)
+                    }
+                    extension_host::ExtensionEvent::ExtensionInstalled(extension_id) => {
                         this.on_extension_installed(workspace_handle.clone(), extension_id, cx)
                     }
                     _ => {}
@@ -844,6 +844,7 @@ impl ExtensionsPage {
     }
 
     fn fetch_extensions_debounced(&mut self, cx: &mut ViewContext<ExtensionsPage>) {
+        //self.is_installing_dev_extension(None);
         self.extension_fetch_task = Some(cx.spawn(|this, mut cx| async move {
             let search = this
                 .update(&mut cx, |this, cx| this.search_query(cx))

diff --git a/crates/workspace/Cargo.toml b/crates/workspace/Cargo.toml
@@ -36,6 +36,7 @@ clock.workspace = true
 collections.workspace = true
 db.workspace = true
 derive_more.workspace = true
+extension_host.workspace = true
 fs.workspace = true
 futures.workspace = true
 gpui.workspace = true

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
@@ -22,6 +22,7 @@ use client::{
 use collections::{hash_map, HashMap, HashSet};
 use derive_more::{Deref, DerefMut};
 use dock::{Dock, DockPosition, Panel, PanelButtons, PanelHandle, RESIZE_HANDLE_SIZE};
+use extension_host::{ExtensionEvent, ExtensionStore, InstallDevExtension};
 use futures::{
     channel::{
         mpsc::{self, UnboundedReceiver, UnboundedSender},
@@ -914,6 +915,21 @@ impl Workspace {
         });
         cx.subscribe(&center_pane, Self::handle_pane_event).detach();
 
+        let store = ExtensionStore::global(cx);
+        cx.subscribe(&store, |workspace, _, event, cx| match event {
+            ExtensionEvent::DevExtensionInstalling(m) => {
+                on_dev_extension_install(workspace, cx, &m.clone(), false)
+            }
+            ExtensionEvent::DevExtensionInstallSuccess => {
+                on_dev_extension_install(workspace, cx, &"Complete", false)
+            }
+            ExtensionEvent::DevExtensionInstallFailed(e) => {
+                on_dev_extension_install(workspace, cx, &e.clone(), true);
+            }
+            _ => {}
+        })
+        .detach();
+
         cx.focus_view(&center_pane);
         cx.emit(Event::PaneAdded(center_pane.clone()));
 
@@ -6253,6 +6269,33 @@ pub fn move_active_item(
     });
 }
 
+fn on_dev_extension_install(
+    workspace: &mut Workspace,
+    cx: &mut ViewContext<Workspace>,
+    message: &str,
+    is_error: bool,
+) {
+    if is_error {
+        let t = Toast::new(
+            NotificationId::unique::<InstallDevExtension>(),
+            format!("ERROR Installing Dev Extension: {}", message),
+        )
+        .on_click("Read more about creating Dev Extensions", {
+            move |cx| {
+                cx.open_url("https://zed.dev/docs/extensions/developing-extensions");
+            }
+        });
+        workspace.show_toast(t, cx);
+    } else {
+        let t = Toast::new(
+            NotificationId::unique::<InstallDevExtension>(),
+            format!("Installing Dev Extension: {}", message),
+        )
+        .autohide();
+        workspace.show_toast(t, cx);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::{cell::RefCell, rc::Rc};