WIP: Zed2: Add core mac app actions (#3316)

Add back cmd-q, cmd-n, etc.

TODO:
- [x] Fix quit checking workspace windows
- [ ] ~~See if GPUI2 has a DebugElements analog~~

Release Notes:

- N/A

Cargo.lock

@@ -4198,6 +4198,7 @@ dependencies = [
  "anyhow",
  "gpui2",
  "log",
+ "serde",
  "smol",
  "util",
 ]
@@ -11432,7 +11433,7 @@ dependencies = [
  "ignore",
  "image",
  "indexmap 1.9.3",
- "install_cli",
+ "install_cli2",
  "isahc",
  "journal2",
  "language2",

crates/Cargo.toml

@@ -1,38 +0,0 @@
-[package]
-name = "ai"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/ai.rs"
-doctest = false
-
-[features]
-test-support = []
-
-[dependencies]
-gpui = { path = "../gpui" }
-util = { path = "../util" }
-language = { path = "../language" }
-async-trait.workspace = true
-anyhow.workspace = true
-futures.workspace = true
-lazy_static.workspace = true
-ordered-float.workspace = true
-parking_lot.workspace = true
-isahc.workspace = true
-regex.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-postage.workspace = true
-rand.workspace = true
-log.workspace = true
-parse_duration = "2.1.1"
-tiktoken-rs.workspace = true
-matrixmultiply = "0.3.7"
-rusqlite = { version = "0.29.0", features = ["blob", "array", "modern_sqlite"] }
-bincode = "1.3.3"
-
-[dev-dependencies]
-gpui = { path = "../gpui", features = ["test-support"] }

crates/gpui/src/app.rs

@@ -2112,6 +2112,10 @@ impl AppContext {
         AsyncAppContext(self.weak_self.as_ref().unwrap().upgrade().unwrap())
     }
 
+    pub fn open_url(&self, url: &str) {
+        self.platform.open_url(url)
+    }
+
     pub fn write_to_clipboard(&self, item: ClipboardItem) {
         self.platform.write_to_clipboard(item);
     }

crates/gpui2/src/app.rs

@@ -431,6 +431,18 @@ impl AppContext {
         self.platform.activate(ignoring_other_apps);
     }
 
+    pub fn hide(&self) {
+        self.platform.hide();
+    }
+
+    pub fn hide_other_apps(&self) {
+        self.platform.hide_other_apps();
+    }
+
+    pub fn unhide_other_apps(&self) {
+        self.platform.unhide_other_apps();
+    }
+
     /// Returns the list of currently active displays.
     pub fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {
         self.platform.displays()

crates/gpui2/src/window.rs

@@ -1365,6 +1365,14 @@ impl<'a> WindowContext<'a> {
         self.window.platform_window.activate();
     }
 
+    pub fn minimize_window(&self) {
+        self.window.platform_window.minimize();
+    }
+
+    pub fn toggle_full_screen(&self) {
+        self.window.platform_window.toggle_full_screen();
+    }
+
     pub fn prompt(
         &self,
         level: PromptLevel,
@@ -2360,6 +2368,12 @@ impl<V: 'static + Render> WindowHandle<V> {
     {
         cx.read_window(self, |root_view, _cx| root_view.clone())
     }
+
+    pub fn is_active(&self, cx: &WindowContext) -> Option<bool> {
+        cx.windows
+            .get(self.id)
+            .and_then(|window| window.as_ref().map(|window| window.active))
+    }
 }
 
 impl<V> Copy for WindowHandle<V> {}

crates/install_cli2/Cargo.toml

@@ -14,5 +14,6 @@ test-support = []
 smol.workspace = true
 anyhow.workspace = true
 log.workspace = true
+serde.workspace = true
 gpui = { package = "gpui2", path = "../gpui2" }
 util = { path = "../util" }

crates/install_cli2/src/install_cli2.rs

@@ -1,10 +1,9 @@
 use anyhow::{anyhow, Result};
-use gpui::AsyncAppContext;
+use gpui::{actions, AsyncAppContext};
 use std::path::Path;
 use util::ResultExt;
 
-// todo!()
+actions!(Install);
-// actions!(cli, [Install]);
 
 pub async fn install_cli(cx: &AsyncAppContext) -> Result<()> {
     let cli_path = cx.update(|cx| cx.path_for_auxiliary_executable("cli"))??;

crates/workspace2/src/workspace2.rs

@@ -45,7 +45,7 @@ use gpui::{
 };
 use item::{FollowableItem, FollowableItemHandle, Item, ItemHandle, ItemSettings, ProjectItem};
 use itertools::Itertools;
-use language2::LanguageRegistry;
+use language2::{LanguageRegistry, Rope};
 use lazy_static::lazy_static;
 pub use modal_layer::*;
 use node_runtime::NodeRuntime;
@@ -72,7 +72,7 @@ pub use toolbar::{ToolbarItemLocation, ToolbarItemView};
 use ui::{h_stack, Button, ButtonVariant, Label, LabelColor};
 use util::ResultExt;
 use uuid::Uuid;
-use workspace_settings::{AutosaveSetting, WorkspaceSettings};
+pub use workspace_settings::{AutosaveSetting, WorkspaceSettings};
 
 lazy_static! {
     static ref ZED_WINDOW_SIZE: Option<Size<GlobalPixels>> = env::var("ZED_WINDOW_SIZE")
@@ -1052,29 +1052,29 @@ impl Workspace {
     //     self.titlebar_item.clone()
     // }
 
-    //     /// Call the given callback with a workspace whose project is local.
+    /// Call the given callback with a workspace whose project is local.
-    //     ///
+    ///
-    //     /// If the given workspace has a local project, then it will be passed
+    /// If the given workspace has a local project, then it will be passed
-    //     /// to the callback. Otherwise, a new empty window will be created.
+    /// to the callback. Otherwise, a new empty window will be created.
-    //     pub fn with_local_workspace<T, F>(
+    pub fn with_local_workspace<T, F>(
-    //         &mut self,
+        &mut self,
-    //         cx: &mut ViewContext<Self>,
+        cx: &mut ViewContext<Self>,
-    //         callback: F,
+        callback: F,
-    //     ) -> Task<Result<T>>
+    ) -> Task<Result<T>>
-    //     where
+    where
-    //         T: 'static,
+        T: 'static,
-    //         F: 'static + FnOnce(&mut Workspace, &mut ViewContext<Workspace>) -> T,
+        F: 'static + FnOnce(&mut Workspace, &mut ViewContext<Workspace>) -> T,
-    //     {
+    {
-    //         if self.project.read(cx).is_local() {
+        if self.project.read(cx).is_local() {
-    //             Task::Ready(Some(Ok(callback(self, cx))))
+            Task::Ready(Some(Ok(callback(self, cx))))
-    //         } else {
+        } else {
-    //             let task = Self::new_local(Vec::new(), self.app_state.clone(), None, cx);
+            let task = Self::new_local(Vec::new(), self.app_state.clone(), None, cx);
-    //             cx.spawn(|_vh, mut cx| async move {
+            cx.spawn(|_vh, mut cx| async move {
-    //                 let (workspace, _) = task.await;
+                let (workspace, _) = task.await?;
-    //                 workspace.update(&mut cx, callback)
+                workspace.update(&mut cx, callback)
-    //             })
+            })
-    //         }
+        }
-    //     }
+    }
 
     pub fn worktrees<'a>(&self, cx: &'a AppContext) -> impl 'a + Iterator<Item = Model<Worktree>> {
         self.project.read(cx).worktrees()
@@ -3435,13 +3435,14 @@ impl Workspace {
     pub fn register_action<A: Action>(
         &mut self,
         callback: impl Fn(&mut Self, &A, &mut ViewContext<Self>) + 'static,
-    ) {
+    ) -> &mut Self {
         let callback = Arc::new(callback);
 
         self.workspace_actions.push(Box::new(move |div| {
             let callback = callback.clone();
             div.on_action(move |workspace, event, cx| (callback.clone())(workspace, event, cx))
         }));
+        self
     }
 
     fn add_workspace_actions_listeners(
@@ -4383,32 +4384,32 @@ pub fn open_new(
     })
 }
 
-// pub fn create_and_open_local_file(
+pub fn create_and_open_local_file(
-//     path: &'static Path,
+    path: &'static Path,
-//     cx: &mut ViewContext<Workspace>,
+    cx: &mut ViewContext<Workspace>,
-//     default_content: impl 'static + Send + FnOnce() -> Rope,
+    default_content: impl 'static + Send + FnOnce() -> Rope,
-// ) -> Task<Result<Box<dyn ItemHandle>>> {
+) -> Task<Result<Box<dyn ItemHandle>>> {
-//     cx.spawn(|workspace, mut cx| async move {
+    cx.spawn(|workspace, mut cx| async move {
-//         let fs = workspace.read_with(&cx, |workspace, _| workspace.app_state().fs.clone())?;
+        let fs = workspace.update(&mut cx, |workspace, _| workspace.app_state().fs.clone())?;
-//         if !fs.is_file(path).await {
+        if !fs.is_file(path).await {
-//             fs.create_file(path, Default::default()).await?;
+            fs.create_file(path, Default::default()).await?;
-//             fs.save(path, &default_content(), Default::default())
+            fs.save(path, &default_content(), Default::default())
-//                 .await?;
+                .await?;
-//         }
+        }
 
-//         let mut items = workspace
+        let mut items = workspace
-//             .update(&mut cx, |workspace, cx| {
+            .update(&mut cx, |workspace, cx| {
-//                 workspace.with_local_workspace(cx, |workspace, cx| {
+                workspace.with_local_workspace(cx, |workspace, cx| {
-//                     workspace.open_paths(vec![path.to_path_buf()], false, cx)
+                    workspace.open_paths(vec![path.to_path_buf()], false, cx)
-//                 })
+                })
-//             })?
+            })?
-//             .await?
+            .await?
-//             .await;
+            .await;
 
-//         let item = items.pop().flatten();
+        let item = items.pop().flatten();
-//         item.ok_or_else(|| anyhow!("path {path:?} is not a file"))?
+        item.ok_or_else(|| anyhow!("path {path:?} is not a file"))?
-//     })
+    })
-// }
+}
 
 // pub fn join_remote_project(
 //     project_id: u64,

crates/zed2/Cargo.toml

@@ -43,7 +43,7 @@ fsevent = { path = "../fsevent" }
 fuzzy = { path = "../fuzzy" }
 go_to_line = { package = "go_to_line2", path = "../go_to_line2" }
 gpui = { package = "gpui2", path = "../gpui2" }
-install_cli = { path = "../install_cli" }
+install_cli = { package = "install_cli2", path = "../install_cli2" }
 journal = { package = "journal2", path = "../journal2" }
 language = { package = "language2", path = "../language2" }
 # language_selector = { path = "../language_selector" }

crates/zed2/src/main.rs

@@ -50,14 +50,16 @@ use util::{
 use uuid::Uuid;
 use workspace::{AppState, WorkspaceStore};
 use zed2::{
-    build_window_options, ensure_only_instance, handle_cli_connection, initialize_workspace,
+    build_window_options, ensure_only_instance, handle_cli_connection, init_zed_actions,
-    languages, Assets, IsOnlyInstance, OpenListener, OpenRequest,
+    initialize_workspace, languages, Assets, IsOnlyInstance, OpenListener, OpenRequest,
 };
 
 mod open_listener;
 
 fn main() {
     menu::init();
+    zed_actions::init();
+
     let http = http::client();
     init_paths();
     init_logger();
@@ -96,7 +98,7 @@ fn main() {
     let (listener, mut open_rx) = OpenListener::new();
     let listener = Arc::new(listener);
     let open_listener = listener.clone();
-    app.on_open_urls(move |urls, _| open_listener.open_urls(urls));
+    app.on_open_urls(move |urls, _| open_listener.open_urls(&urls));
     app.on_reopen(move |_cx| {
         // todo!("workspace")
         // if cx.has_global::<Weak<AppState>>() {
@@ -111,6 +113,8 @@ fn main() {
 
     app.run(move |cx| {
         cx.set_global(*RELEASE_CHANNEL);
+        cx.set_global(listener.clone());
+
         load_embedded_fonts(cx);
 
         let mut store = SettingsStore::default();
@@ -209,12 +213,13 @@ fn main() {
         // zed::init(&app_state, cx);
 
         // cx.set_menus(menus::menus());
+        init_zed_actions(app_state.clone(), cx);
 
         if stdout_is_a_pty() {
             cx.activate(true);
             let urls = collect_url_args();
             if !urls.is_empty() {
-                listener.open_urls(urls)
+                listener.open_urls(&urls)
             }
         } else {
             upload_previous_panics(http.clone(), cx);
@@ -224,7 +229,7 @@ fn main() {
             if std::env::var(FORCE_CLI_MODE_ENV_VAR_NAME).ok().is_some()
                 && !listener.triggered.load(Ordering::Acquire)
             {
-                listener.open_urls(collect_url_args())
+                listener.open_urls(&collect_url_args())
             }
         }
 

crates/zed2/src/open_listener.rs

@@ -54,7 +54,7 @@ impl OpenListener {
         )
     }
 
-    pub fn open_urls(&self, urls: Vec<String>) {
+    pub fn open_urls(&self, urls: &[String]) {
         self.triggered.store(true, Ordering::Release);
         let request = if let Some(server_name) =
             urls.first().and_then(|url| url.strip_prefix("zed-cli://"))
@@ -101,7 +101,7 @@ impl OpenListener {
         None
     }
 
-    fn handle_file_urls(&self, urls: Vec<String>) -> Option<OpenRequest> {
+    fn handle_file_urls(&self, urls: &[String]) -> Option<OpenRequest> {
         let paths: Vec<_> = urls
             .iter()
             .flat_map(|url| url.strip_prefix("file://"))

crates/zed2/src/zed2.rs

@@ -1,5 +1,5 @@
-#![allow(unused_variables, dead_code, unused_mut)]
+#![allow(unused_variables, unused_mut)]
-// todo!() this is to make transition easier.
+//todo!()
 
 mod assets;
 pub mod languages;
@@ -7,18 +7,56 @@ mod only_instance;
 mod open_listener;
 
 pub use assets::*;
+use collections::VecDeque;
+use editor::{Editor, MultiBuffer};
 use gpui::{
-    point, px, AppContext, AsyncWindowContext, Task, TitlebarOptions, WeakView, WindowBounds,
+    actions, point, px, AppContext, AsyncWindowContext, Context, PromptLevel, Task,
-    WindowKind, WindowOptions,
+    TitlebarOptions, ViewContext, VisualContext, WeakView, WindowBounds, WindowKind, WindowOptions,
 };
 pub use only_instance::*;
 pub use open_listener::*;
 
-use anyhow::Result;
+use anyhow::{anyhow, Context as _, Result};
 use project_panel::ProjectPanel;
-use std::sync::Arc;
+use settings::{initial_local_settings_content, Settings};
+use std::{borrow::Cow, ops::Deref, sync::Arc};
+use util::{
+    asset_str,
+    channel::ReleaseChannel,
+    paths::{self, LOCAL_SETTINGS_RELATIVE_PATH},
+    ResultExt,
+};
 use uuid::Uuid;
-use workspace::{dock::PanelHandle as _, AppState, Workspace};
+use workspace::{
+    create_and_open_local_file, dock::PanelHandle,
+    notifications::simple_message_notification::MessageNotification, open_new, AppState, NewFile,
+    NewWindow, Workspace, WorkspaceSettings,
+};
+use zed_actions::{OpenBrowser, OpenZedURL};
+
+actions!(
+    About,
+    DebugElements,
+    DecreaseBufferFontSize,
+    Hide,
+    HideOthers,
+    IncreaseBufferFontSize,
+    Minimize,
+    OpenDefaultKeymap,
+    OpenDefaultSettings,
+    OpenKeymap,
+    OpenLicenses,
+    OpenLocalSettings,
+    OpenLog,
+    OpenSettings,
+    OpenTelemetryLog,
+    Quit,
+    ResetBufferFontSize,
+    ResetDatabase,
+    ShowAll,
+    ToggleFullScreen,
+    Zoom,
+);
 
 pub fn build_window_options(
     bounds: Option<WindowBounds>,
@@ -48,6 +86,211 @@ pub fn build_window_options(
     }
 }
 
+pub fn init_zed_actions(app_state: Arc<AppState>, cx: &mut AppContext) {
+    cx.observe_new_views(move |workspace: &mut Workspace, _cx| {
+        workspace
+            .register_action(about)
+            .register_action(|_, _: &Hide, cx| {
+                cx.hide();
+            })
+            .register_action(|_, _: &HideOthers, cx| {
+                cx.hide_other_apps();
+            })
+            .register_action(|_, _: &ShowAll, cx| {
+                cx.unhide_other_apps();
+            })
+            .register_action(|_, _: &Minimize, cx| {
+                cx.minimize_window();
+            })
+            .register_action(|_, _: &Zoom, cx| {
+                cx.zoom_window();
+            })
+            .register_action(|_, _: &ToggleFullScreen, cx| {
+                cx.toggle_full_screen();
+            })
+            .register_action(quit)
+            .register_action(|_, action: &OpenZedURL, cx| {
+                cx.global::<Arc<OpenListener>>()
+                    .open_urls(&[action.url.clone()])
+            })
+            .register_action(|_, action: &OpenBrowser, cx| cx.open_url(&action.url))
+            //todo!(buffer font size)
+            // cx.add_global_action(move |_: &IncreaseBufferFontSize, cx| {
+            //     theme::adjust_font_size(cx, |size| *size += 1.0)
+            // });
+            // cx.add_global_action(move |_: &DecreaseBufferFontSize, cx| {
+            //     theme::adjust_font_size(cx, |size| *size -= 1.0)
+            // });
+            // cx.add_global_action(move |_: &ResetBufferFontSize, cx| theme::reset_font_size(cx));
+            .register_action(|_, _: &install_cli::Install, cx| {
+                cx.spawn(|_, cx| async move {
+                    install_cli::install_cli(cx.deref())
+                        .await
+                        .context("error creating CLI symlink")
+                })
+                .detach_and_log_err(cx);
+            })
+            .register_action(|workspace, _: &OpenLog, cx| {
+                open_log_file(workspace, cx);
+            })
+            .register_action(|workspace, _: &OpenLicenses, cx| {
+                open_bundled_file(
+                    workspace,
+                    asset_str::<Assets>("licenses.md"),
+                    "Open Source License Attribution",
+                    "Markdown",
+                    cx,
+                );
+            })
+            .register_action(
+                move |workspace: &mut Workspace,
+                      _: &OpenTelemetryLog,
+                      cx: &mut ViewContext<Workspace>| {
+                    open_telemetry_log_file(workspace, cx);
+                },
+            )
+            .register_action(
+                move |_: &mut Workspace, _: &OpenKeymap, cx: &mut ViewContext<Workspace>| {
+                    create_and_open_local_file(&paths::KEYMAP, cx, Default::default)
+                        .detach_and_log_err(cx);
+                },
+            )
+            .register_action(
+                move |_: &mut Workspace, _: &OpenSettings, cx: &mut ViewContext<Workspace>| {
+                    create_and_open_local_file(&paths::SETTINGS, cx, || {
+                        settings::initial_user_settings_content().as_ref().into()
+                    })
+                    .detach_and_log_err(cx);
+                },
+            )
+            .register_action(open_local_settings_file)
+            .register_action(
+                move |workspace: &mut Workspace,
+                      _: &OpenDefaultKeymap,
+                      cx: &mut ViewContext<Workspace>| {
+                    open_bundled_file(
+                        workspace,
+                        settings::default_keymap(),
+                        "Default Key Bindings",
+                        "JSON",
+                        cx,
+                    );
+                },
+            )
+            .register_action(
+                move |workspace: &mut Workspace,
+                      _: &OpenDefaultSettings,
+                      cx: &mut ViewContext<Workspace>| {
+                    open_bundled_file(
+                        workspace,
+                        settings::default_settings(),
+                        "Default Settings",
+                        "JSON",
+                        cx,
+                    );
+                },
+            )
+            //todo!()
+            // cx.add_action({
+            //     move |workspace: &mut Workspace, _: &DebugElements, cx: &mut ViewContext<Workspace>| {
+            //         let app_state = workspace.app_state().clone();
+            //         let markdown = app_state.languages.language_for_name("JSON");
+            //         let window = cx.window();
+            //         cx.spawn(|workspace, mut cx| async move {
+            //             let markdown = markdown.await.log_err();
+            //             let content = to_string_pretty(&window.debug_elements(&cx).ok_or_else(|| {
+            //                 anyhow!("could not debug elements for window {}", window.id())
+            //             })?)
+            //             .unwrap();
+            //             workspace
+            //                 .update(&mut cx, |workspace, cx| {
+            //                     workspace.with_local_workspace(cx, move |workspace, cx| {
+            //                         let project = workspace.project().clone();
+            //                         let buffer = project
+            //                             .update(cx, |project, cx| {
+            //                                 project.create_buffer(&content, markdown, cx)
+            //                             })
+            //                             .expect("creating buffers on a local workspace always succeeds");
+            //                         let buffer = cx.add_model(|cx| {
+            //                             MultiBuffer::singleton(buffer, cx)
+            //                                 .with_title("Debug Elements".into())
+            //                         });
+            //                         workspace.add_item(
+            //                             Box::new(cx.add_view(|cx| {
+            //                                 Editor::for_multibuffer(buffer, Some(project.clone()), cx)
+            //                             })),
+            //                             cx,
+            //                         );
+            //                     })
+            //                 })?
+            //                 .await
+            //         })
+            //         .detach_and_log_err(cx);
+            //     }
+            // });
+            // .register_action(
+            //     |workspace: &mut Workspace,
+            //      _: &project_panel::ToggleFocus,
+            //      cx: &mut ViewContext<Workspace>| {
+            //         workspace.toggle_panel_focus::<ProjectPanel>(cx);
+            //     },
+            // );
+            // cx.add_action(
+            //     |workspace: &mut Workspace,
+            //      _: &collab_ui::collab_panel::ToggleFocus,
+            //      cx: &mut ViewContext<Workspace>| {
+            //         workspace.toggle_panel_focus::<collab_ui::collab_panel::CollabPanel>(cx);
+            //     },
+            // );
+            // cx.add_action(
+            //     |workspace: &mut Workspace,
+            //      _: &collab_ui::chat_panel::ToggleFocus,
+            //      cx: &mut ViewContext<Workspace>| {
+            //         workspace.toggle_panel_focus::<collab_ui::chat_panel::ChatPanel>(cx);
+            //     },
+            // );
+            // cx.add_action(
+            //     |workspace: &mut Workspace,
+            //      _: &collab_ui::notification_panel::ToggleFocus,
+            //      cx: &mut ViewContext<Workspace>| {
+            //         workspace.toggle_panel_focus::<collab_ui::notification_panel::NotificationPanel>(cx);
+            //     },
+            // );
+            // cx.add_action(
+            //     |workspace: &mut Workspace,
+            //      _: &terminal_panel::ToggleFocus,
+            //      cx: &mut ViewContext<Workspace>| {
+            //         workspace.toggle_panel_focus::<TerminalPanel>(cx);
+            //     },
+            // );
+            .register_action({
+                let app_state = Arc::downgrade(&app_state);
+                move |_, _: &NewWindow, cx| {
+                    if let Some(app_state) = app_state.upgrade() {
+                        open_new(&app_state, cx, |workspace, cx| {
+                            Editor::new_file(workspace, &Default::default(), cx)
+                        })
+                        .detach();
+                    }
+                }
+            })
+            .register_action({
+                let app_state = Arc::downgrade(&app_state);
+                move |_, _: &NewFile, cx| {
+                    if let Some(app_state) = app_state.upgrade() {
+                        open_new(&app_state, cx, |workspace, cx| {
+                            Editor::new_file(workspace, &Default::default(), cx)
+                        })
+                        .detach();
+                    }
+                }
+            });
+        //todo!()
+        // load_default_keymap(cx);
+    })
+    .detach();
+}
+
 pub fn initialize_workspace(
     workspace_handle: WeakView<Workspace>,
     was_deserialized: bool,
@@ -195,3 +438,280 @@ pub fn initialize_workspace(
         Ok(())
     })
 }
+
+fn about(_: &mut Workspace, _: &About, cx: &mut gpui::ViewContext<Workspace>) {
+    let app_name = cx.global::<ReleaseChannel>().display_name();
+    let version = env!("CARGO_PKG_VERSION");
+    let prompt = cx.prompt(PromptLevel::Info, &format!("{app_name} {version}"), &["OK"]);
+    cx.foreground_executor()
+        .spawn(async {
+            prompt.await.ok();
+        })
+        .detach();
+}
+
+fn quit(_: &mut Workspace, _: &Quit, cx: &mut gpui::ViewContext<Workspace>) {
+    let should_confirm = WorkspaceSettings::get_global(cx).confirm_quit;
+    cx.spawn(|_, mut cx| async move {
+        let mut workspace_windows = cx.update(|_, cx| {
+            cx.windows()
+                .into_iter()
+                .filter_map(|window| window.downcast::<Workspace>())
+                .collect::<Vec<_>>()
+        })?;
+
+        // If multiple windows have unsaved changes, and need a save prompt,
+        // prompt in the active window before switching to a different window.
+        cx.update(|_, cx| {
+            workspace_windows.sort_by_key(|window| window.is_active(&cx) == Some(false));
+        })
+        .log_err();
+
+        if let (true, Some(window)) = (should_confirm, workspace_windows.first().copied()) {
+            let answer = cx
+                .update(|_, cx| {
+                    cx.prompt(
+                        PromptLevel::Info,
+                        "Are you sure you want to quit?",
+                        &["Quit", "Cancel"],
+                    )
+                })
+                .log_err();
+
+            if let Some(mut answer) = answer {
+                let answer = answer.await.ok();
+                if answer != Some(0) {
+                    return Ok(());
+                }
+            }
+        }
+
+        // If the user cancels any save prompt, then keep the app open.
+        for window in workspace_windows {
+            if let Some(should_close) = window
+                .update(&mut cx, |workspace, cx| {
+                    workspace.prepare_to_close(true, cx)
+                })
+                .log_err()
+            {
+                if !should_close.await? {
+                    return Ok(());
+                }
+            }
+        }
+        cx.update(|_, cx| {
+            cx.quit();
+        })?;
+
+        anyhow::Ok(())
+    })
+    .detach_and_log_err(cx);
+}
+
+fn open_log_file(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
+    const MAX_LINES: usize = 1000;
+    workspace
+        .with_local_workspace(cx, move |workspace, cx| {
+            let fs = workspace.app_state().fs.clone();
+            cx.spawn(|workspace, mut cx| async move {
+                let (old_log, new_log) =
+                    futures::join!(fs.load(&paths::OLD_LOG), fs.load(&paths::LOG));
+
+                let mut lines = VecDeque::with_capacity(MAX_LINES);
+                for line in old_log
+                    .iter()
+                    .flat_map(|log| log.lines())
+                    .chain(new_log.iter().flat_map(|log| log.lines()))
+                {
+                    if lines.len() == MAX_LINES {
+                        lines.pop_front();
+                    }
+                    lines.push_back(line);
+                }
+                let log = lines
+                    .into_iter()
+                    .flat_map(|line| [line, "\n"])
+                    .collect::<String>();
+
+                workspace
+                    .update(&mut cx, |workspace, cx| {
+                        let project = workspace.project().clone();
+                        let buffer = project
+                            .update(cx, |project, cx| project.create_buffer("", None, cx))
+                            .expect("creating buffers on a local workspace always succeeds");
+                        buffer.update(cx, |buffer, cx| buffer.edit([(0..0, log)], None, cx));
+
+                        let buffer = cx.build_model(|cx| {
+                            MultiBuffer::singleton(buffer, cx).with_title("Log".into())
+                        });
+                        workspace.add_item(
+                            Box::new(cx.build_view(|cx| {
+                                Editor::for_multibuffer(buffer, Some(project), cx)
+                            })),
+                            cx,
+                        );
+                    })
+                    .log_err();
+            })
+            .detach();
+        })
+        .detach();
+}
+
+fn open_local_settings_file(
+    workspace: &mut Workspace,
+    _: &OpenLocalSettings,
+    cx: &mut ViewContext<Workspace>,
+) {
+    let project = workspace.project().clone();
+    let worktree = project
+        .read(cx)
+        .visible_worktrees(cx)
+        .find_map(|tree| tree.read(cx).root_entry()?.is_dir().then_some(tree));
+    if let Some(worktree) = worktree {
+        let tree_id = worktree.read(cx).id();
+        cx.spawn(|workspace, mut cx| async move {
+            let file_path = &*LOCAL_SETTINGS_RELATIVE_PATH;
+
+            if let Some(dir_path) = file_path.parent() {
+                if worktree.update(&mut cx, |tree, _| tree.entry_for_path(dir_path).is_none())? {
+                    project
+                        .update(&mut cx, |project, cx| {
+                            project.create_entry((tree_id, dir_path), true, cx)
+                        })?
+                        .ok_or_else(|| anyhow!("worktree was removed"))?
+                        .await?;
+                }
+            }
+
+            if worktree.update(&mut cx, |tree, _| tree.entry_for_path(file_path).is_none())? {
+                project
+                    .update(&mut cx, |project, cx| {
+                        project.create_entry((tree_id, file_path), false, cx)
+                    })?
+                    .ok_or_else(|| anyhow!("worktree was removed"))?
+                    .await?;
+            }
+
+            let editor = workspace
+                .update(&mut cx, |workspace, cx| {
+                    workspace.open_path((tree_id, file_path), None, true, cx)
+                })?
+                .await?
+                .downcast::<Editor>()
+                .ok_or_else(|| anyhow!("unexpected item type"))?;
+
+            editor
+                .downgrade()
+                .update(&mut cx, |editor, cx| {
+                    if let Some(buffer) = editor.buffer().read(cx).as_singleton() {
+                        if buffer.read(cx).is_empty() {
+                            buffer.update(cx, |buffer, cx| {
+                                buffer.edit([(0..0, initial_local_settings_content())], None, cx)
+                            });
+                        }
+                    }
+                })
+                .ok();
+
+            anyhow::Ok(())
+        })
+        .detach();
+    } else {
+        workspace.show_notification(0, cx, |cx| {
+            cx.build_view(|_| MessageNotification::new("This project has no folders open."))
+        })
+    }
+}
+
+fn open_telemetry_log_file(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
+    workspace.with_local_workspace(cx, move |workspace, cx| {
+        let app_state = workspace.app_state().clone();
+        cx.spawn(|workspace, mut cx| async move {
+            async fn fetch_log_string(app_state: &Arc<AppState>) -> Option<String> {
+                let path = app_state.client.telemetry().log_file_path()?;
+                app_state.fs.load(&path).await.log_err()
+            }
+
+            let log = fetch_log_string(&app_state).await.unwrap_or_else(|| "// No data has been collected yet".to_string());
+
+            const MAX_TELEMETRY_LOG_LEN: usize = 5 * 1024 * 1024;
+            let mut start_offset = log.len().saturating_sub(MAX_TELEMETRY_LOG_LEN);
+            if let Some(newline_offset) = log[start_offset..].find('\n') {
+                start_offset += newline_offset + 1;
+            }
+            let log_suffix = &log[start_offset..];
+            let json = app_state.languages.language_for_name("JSON").await.log_err();
+
+            workspace.update(&mut cx, |workspace, cx| {
+                let project = workspace.project().clone();
+                let buffer = project
+                    .update(cx, |project, cx| project.create_buffer("", None, cx))
+                    .expect("creating buffers on a local workspace always succeeds");
+                buffer.update(cx, |buffer, cx| {
+                    buffer.set_language(json, cx);
+                    buffer.edit(
+                        [(
+                            0..0,
+                            concat!(
+                                "// Zed collects anonymous usage data to help us understand how people are using the app.\n",
+                                "// Telemetry can be disabled via the `settings.json` file.\n",
+                                "// Here is the data that has been reported for the current session:\n",
+                                "\n"
+                            ),
+                        )],
+                        None,
+                        cx,
+                    );
+                    buffer.edit([(buffer.len()..buffer.len(), log_suffix)], None, cx);
+                });
+
+                let buffer = cx.build_model(|cx| {
+                    MultiBuffer::singleton(buffer, cx).with_title("Telemetry Log".into())
+                });
+                workspace.add_item(
+                    Box::new(cx.build_view(|cx| Editor::for_multibuffer(buffer, Some(project), cx))),
+                    cx,
+                );
+            }).log_err()?;
+
+            Some(())
+        })
+        .detach();
+    }).detach();
+}
+
+fn open_bundled_file(
+    workspace: &mut Workspace,
+    text: Cow<'static, str>,
+    title: &'static str,
+    language: &'static str,
+    cx: &mut ViewContext<Workspace>,
+) {
+    let language = workspace.app_state().languages.language_for_name(language);
+    cx.spawn(|workspace, mut cx| async move {
+        let language = language.await.log_err();
+        workspace
+            .update(&mut cx, |workspace, cx| {
+                workspace.with_local_workspace(cx, |workspace, cx| {
+                    let project = workspace.project();
+                    let buffer = project.update(cx, move |project, cx| {
+                        project
+                            .create_buffer(text.as_ref(), language, cx)
+                            .expect("creating buffers on a local workspace always succeeds")
+                    });
+                    let buffer = cx.build_model(|cx| {
+                        MultiBuffer::singleton(buffer, cx).with_title(title.into())
+                    });
+                    workspace.add_item(
+                        Box::new(cx.build_view(|cx| {
+                            Editor::for_multibuffer(buffer, Some(project.clone()), cx)
+                        })),
+                        cx,
+                    );
+                })
+            })?
+            .await
+    })
+    .detach_and_log_err(cx);
+}

crates/zed_actions2/src/lib.rs

@@ -1,33 +1,19 @@
-use gpui::{action, actions};
+use gpui::action;
 
-actions!(
+// If the zed binary doesn't use anything in this crate, it will be optimized away
-    About,
+// and the actions won't initialize. So we just provide an empty initialization function
-    DebugElements,
+// to be called from main.
-    DecreaseBufferFontSize,
+//
-    Hide,
+// These may provide relevant context:
-    HideOthers,
+// https://github.com/rust-lang/rust/issues/47384
-    IncreaseBufferFontSize,
+// https://github.com/mmastrac/rust-ctor/issues/280
-    Minimize,
+pub fn init() {}
-    OpenDefaultKeymap,
-    OpenDefaultSettings,
-    OpenKeymap,
-    OpenLicenses,
-    OpenLocalSettings,
-    OpenLog,
-    OpenSettings,
-    OpenTelemetryLog,
-    Quit,
-    ResetBufferFontSize,
-    ResetDatabase,
-    ShowAll,
-    ToggleFullScreen,
-    Zoom,
-);
 
 #[action]
 pub struct OpenBrowser {
     pub url: String,
 }
+
 #[action]
 pub struct OpenZedURL {
     pub url: String,