1mod update_notification;
  2
  3use anyhow::{anyhow, Context, Result};
  4use client::{Client, TelemetrySettings};
  5use db::kvp::KEY_VALUE_STORE;
  6use db::RELEASE_CHANNEL;
  7use editor::{Editor, MultiBuffer};
  8use gpui::{
  9    actions, AppContext, AsyncAppContext, Context as _, Global, Model, ModelContext,
 10    SemanticVersion, SharedString, Task, View, ViewContext, VisualContext, WindowContext,
 11};
 12use isahc::AsyncBody;
 13
 14use markdown_preview::markdown_preview_view::{MarkdownPreviewMode, MarkdownPreviewView};
 15use schemars::JsonSchema;
 16use serde::Deserialize;
 17use serde_derive::Serialize;
 18use smol::{fs, io::AsyncReadExt};
 19
 20use settings::{Settings, SettingsSources, SettingsStore};
 21use smol::{fs::File, process::Command};
 22
 23use http::{HttpClient, HttpClientWithUrl};
 24use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
 25use std::{
 26    env::{
 27        self,
 28        consts::{ARCH, OS},
 29    },
 30    ffi::OsString,
 31    path::PathBuf,
 32    sync::Arc,
 33    time::Duration,
 34};
 35use update_notification::UpdateNotification;
 36use util::ResultExt;
 37use workspace::notifications::NotificationId;
 38use workspace::Workspace;
 39
 40const SHOULD_SHOW_UPDATE_NOTIFICATION_KEY: &str = "auto-updater-should-show-updated-notification";
 41const POLL_INTERVAL: Duration = Duration::from_secs(60 * 60);
 42
 43actions!(
 44    auto_update,
 45    [
 46        Check,
 47        DismissErrorMessage,
 48        ViewReleaseNotes,
 49        ViewReleaseNotesLocally
 50    ]
 51);
 52
 53#[derive(Serialize)]
 54struct UpdateRequestBody {
 55    installation_id: Option<Arc<str>>,
 56    release_channel: Option<&'static str>,
 57    telemetry: bool,
 58}
 59
 60#[derive(Clone, PartialEq, Eq)]
 61pub enum AutoUpdateStatus {
 62    Idle,
 63    Checking,
 64    Downloading,
 65    Installing,
 66    Updated { binary_path: PathBuf },
 67    Errored,
 68}
 69
 70impl AutoUpdateStatus {
 71    pub fn is_updated(&self) -> bool {
 72        matches!(self, Self::Updated { .. })
 73    }
 74}
 75
 76pub struct AutoUpdater {
 77    status: AutoUpdateStatus,
 78    current_version: SemanticVersion,
 79    http_client: Arc<HttpClientWithUrl>,
 80    pending_poll: Option<Task<Option<()>>>,
 81}
 82
 83#[derive(Deserialize)]
 84struct JsonRelease {
 85    version: String,
 86    url: String,
 87}
 88
 89struct AutoUpdateSetting(bool);
 90
 91/// Whether or not to automatically check for updates.
 92///
 93/// Default: true
 94#[derive(Clone, Copy, Default, JsonSchema, Deserialize, Serialize)]
 95#[serde(transparent)]
 96struct AutoUpdateSettingContent(bool);
 97
 98impl Settings for AutoUpdateSetting {
 99    const KEY: Option<&'static str> = Some("auto_update");
100
101    type FileContent = Option<AutoUpdateSettingContent>;
102
103    fn load(sources: SettingsSources<Self::FileContent>, _: &mut AppContext) -> Result<Self> {
104        let auto_update = [sources.release_channel, sources.user]
105            .into_iter()
106            .find_map(|value| value.copied().flatten())
107            .unwrap_or(sources.default.ok_or_else(Self::missing_default)?);
108
109        Ok(Self(auto_update.0))
110    }
111}
112
113#[derive(Default)]
114struct GlobalAutoUpdate(Option<Model<AutoUpdater>>);
115
116impl Global for GlobalAutoUpdate {}
117
118#[derive(Deserialize)]
119struct ReleaseNotesBody {
120    title: String,
121    release_notes: String,
122}
123
124pub fn init(http_client: Arc<HttpClientWithUrl>, cx: &mut AppContext) {
125    AutoUpdateSetting::register(cx);
126
127    cx.observe_new_views(|workspace: &mut Workspace, _cx| {
128        workspace.register_action(|_, action: &Check, cx| check(action, cx));
129
130        workspace.register_action(|_, action, cx| {
131            view_release_notes(action, cx);
132        });
133
134        workspace.register_action(|workspace, _: &ViewReleaseNotesLocally, cx| {
135            view_release_notes_locally(workspace, cx);
136        });
137    })
138    .detach();
139
140    let version = release_channel::AppVersion::global(cx);
141    let auto_updater = cx.new_model(|cx| {
142        let updater = AutoUpdater::new(version, http_client);
143
144        let poll_for_updates = ReleaseChannel::try_global(cx)
145            .map(|channel| channel.poll_for_updates())
146            .unwrap_or(false);
147
148        if option_env!("ZED_UPDATE_EXPLANATION").is_none()
149            && env::var("ZED_UPDATE_EXPLANATION").is_err()
150            && poll_for_updates
151        {
152            let mut update_subscription = AutoUpdateSetting::get_global(cx)
153                .0
154                .then(|| updater.start_polling(cx));
155
156            cx.observe_global::<SettingsStore>(move |updater, cx| {
157                if AutoUpdateSetting::get_global(cx).0 {
158                    if update_subscription.is_none() {
159                        update_subscription = Some(updater.start_polling(cx))
160                    }
161                } else {
162                    update_subscription.take();
163                }
164            })
165            .detach();
166        }
167
168        updater
169    });
170    cx.set_global(GlobalAutoUpdate(Some(auto_updater)));
171}
172
173pub fn check(_: &Check, cx: &mut WindowContext) {
174    if let Some(message) = option_env!("ZED_UPDATE_EXPLANATION") {
175        drop(cx.prompt(
176            gpui::PromptLevel::Info,
177            "Zed was installed via a package manager.",
178            Some(message),
179            &["Ok"],
180        ));
181        return;
182    }
183
184    if let Some(message) = env::var("ZED_UPDATE_EXPLANATION").ok() {
185        drop(cx.prompt(
186            gpui::PromptLevel::Info,
187            "Zed was installed via a package manager.",
188            Some(&message),
189            &["Ok"],
190        ));
191        return;
192    }
193
194    if !ReleaseChannel::try_global(cx)
195        .map(|channel| channel.poll_for_updates())
196        .unwrap_or(false)
197    {
198        return;
199    }
200
201    if let Some(updater) = AutoUpdater::get(cx) {
202        updater.update(cx, |updater, cx| updater.poll(cx));
203    } else {
204        drop(cx.prompt(
205            gpui::PromptLevel::Info,
206            "Could not check for updates",
207            Some("Auto-updates disabled for non-bundled app."),
208            &["Ok"],
209        ));
210    }
211}
212
213pub fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) -> Option<()> {
214    let auto_updater = AutoUpdater::get(cx)?;
215    let release_channel = ReleaseChannel::try_global(cx)?;
216
217    if matches!(
218        release_channel,
219        ReleaseChannel::Stable | ReleaseChannel::Preview
220    ) {
221        let auto_updater = auto_updater.read(cx);
222        let release_channel = release_channel.dev_name();
223        let current_version = auto_updater.current_version;
224        let url = &auto_updater
225            .http_client
226            .build_url(&format!("/releases/{release_channel}/{current_version}"));
227        cx.open_url(&url);
228    }
229
230    None
231}
232
233fn view_release_notes_locally(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
234    let release_channel = ReleaseChannel::global(cx);
235    let version = AppVersion::global(cx).to_string();
236
237    let client = client::Client::global(cx).http_client();
238    let url = client.build_url(&format!(
239        "/api/release_notes/{}/{}",
240        release_channel.dev_name(),
241        version
242    ));
243
244    let markdown = workspace
245        .app_state()
246        .languages
247        .language_for_name("Markdown");
248
249    workspace
250        .with_local_workspace(cx, move |_, cx| {
251            cx.spawn(|workspace, mut cx| async move {
252                let markdown = markdown.await.log_err();
253                let response = client.get(&url, Default::default(), true).await;
254                let Some(mut response) = response.log_err() else {
255                    return;
256                };
257
258                let mut body = Vec::new();
259                response.body_mut().read_to_end(&mut body).await.ok();
260
261                let body: serde_json::Result<ReleaseNotesBody> =
262                    serde_json::from_slice(body.as_slice());
263
264                if let Ok(body) = body {
265                    workspace
266                        .update(&mut cx, |workspace, cx| {
267                            let project = workspace.project().clone();
268                            let buffer = project.update(cx, |project, cx| {
269                                project.create_local_buffer("", markdown, cx)
270                            });
271                            buffer.update(cx, |buffer, cx| {
272                                buffer.edit([(0..0, body.release_notes)], None, cx)
273                            });
274                            let language_registry = project.read(cx).languages().clone();
275
276                            let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
277
278                            let tab_description = SharedString::from(body.title.to_string());
279                            let editor = cx.new_view(|cx| {
280                                Editor::for_multibuffer(buffer, Some(project), true, cx)
281                            });
282                            let workspace_handle = workspace.weak_handle();
283                            let view: View<MarkdownPreviewView> = MarkdownPreviewView::new(
284                                MarkdownPreviewMode::Default,
285                                editor,
286                                workspace_handle,
287                                language_registry,
288                                Some(tab_description),
289                                cx,
290                            );
291                            workspace.add_item_to_active_pane(
292                                Box::new(view.clone()),
293                                None,
294                                true,
295                                cx,
296                            );
297                            cx.notify();
298                        })
299                        .log_err();
300                }
301            })
302            .detach();
303        })
304        .detach();
305}
306
307pub fn notify_of_any_new_update(cx: &mut ViewContext<Workspace>) -> Option<()> {
308    let updater = AutoUpdater::get(cx)?;
309    let version = updater.read(cx).current_version;
310    let should_show_notification = updater.read(cx).should_show_update_notification(cx);
311
312    cx.spawn(|workspace, mut cx| async move {
313        let should_show_notification = should_show_notification.await?;
314        if should_show_notification {
315            workspace.update(&mut cx, |workspace, cx| {
316                workspace.show_notification(
317                    NotificationId::unique::<UpdateNotification>(),
318                    cx,
319                    |cx| cx.new_view(|_| UpdateNotification::new(version)),
320                );
321                updater
322                    .read(cx)
323                    .set_should_show_update_notification(false, cx)
324                    .detach_and_log_err(cx);
325            })?;
326        }
327        anyhow::Ok(())
328    })
329    .detach();
330
331    None
332}
333
334impl AutoUpdater {
335    pub fn get(cx: &mut AppContext) -> Option<Model<Self>> {
336        cx.default_global::<GlobalAutoUpdate>().0.clone()
337    }
338
339    fn new(current_version: SemanticVersion, http_client: Arc<HttpClientWithUrl>) -> Self {
340        Self {
341            status: AutoUpdateStatus::Idle,
342            current_version,
343            http_client,
344            pending_poll: None,
345        }
346    }
347
348    pub fn start_polling(&self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
349        cx.spawn(|this, mut cx| async move {
350            loop {
351                this.update(&mut cx, |this, cx| this.poll(cx))?;
352                cx.background_executor().timer(POLL_INTERVAL).await;
353            }
354        })
355    }
356
357    pub fn poll(&mut self, cx: &mut ModelContext<Self>) {
358        if self.pending_poll.is_some() || self.status.is_updated() {
359            return;
360        }
361
362        self.status = AutoUpdateStatus::Checking;
363        cx.notify();
364
365        self.pending_poll = Some(cx.spawn(|this, mut cx| async move {
366            let result = Self::update(this.upgrade()?, cx.clone()).await;
367            this.update(&mut cx, |this, cx| {
368                this.pending_poll = None;
369                if let Err(error) = result {
370                    log::error!("auto-update failed: error:{:?}", error);
371                    this.status = AutoUpdateStatus::Errored;
372                    cx.notify();
373                }
374            })
375            .ok()
376        }));
377    }
378
379    pub fn status(&self) -> AutoUpdateStatus {
380        self.status.clone()
381    }
382
383    pub fn dismiss_error(&mut self, cx: &mut ModelContext<Self>) {
384        self.status = AutoUpdateStatus::Idle;
385        cx.notify();
386    }
387
388    async fn update(this: Model<Self>, mut cx: AsyncAppContext) -> Result<()> {
389        let (client, current_version) = this.read_with(&cx, |this, _| {
390            (this.http_client.clone(), this.current_version)
391        })?;
392
393        let asset = match OS {
394            "linux" => format!("zed-linux-{}.tar.gz", ARCH),
395            "macos" => "Zed.dmg".into(),
396            _ => return Err(anyhow!("auto-update not supported for OS {:?}", OS)),
397        };
398
399        let mut url_string = client.build_url(&format!(
400            "/api/releases/latest?asset={}&os={}&arch={}",
401            asset, OS, ARCH
402        ));
403        cx.update(|cx| {
404            if let Some(param) = ReleaseChannel::try_global(cx)
405                .and_then(|release_channel| release_channel.release_query_param())
406            {
407                url_string += "&";
408                url_string += param;
409            }
410        })?;
411
412        let mut response = client.get(&url_string, Default::default(), true).await?;
413
414        let mut body = Vec::new();
415        response
416            .body_mut()
417            .read_to_end(&mut body)
418            .await
419            .context("error reading release")?;
420
421        let release: JsonRelease =
422            serde_json::from_slice(body.as_slice()).context("error deserializing release")?;
423
424        let should_download = match *RELEASE_CHANNEL {
425            ReleaseChannel::Nightly => cx
426                .update(|cx| AppCommitSha::try_global(cx).map(|sha| release.version != sha.0))
427                .ok()
428                .flatten()
429                .unwrap_or(true),
430            _ => release.version.parse::<SemanticVersion>()? > current_version,
431        };
432
433        if !should_download {
434            this.update(&mut cx, |this, cx| {
435                this.status = AutoUpdateStatus::Idle;
436                cx.notify();
437            })?;
438            return Ok(());
439        }
440
441        this.update(&mut cx, |this, cx| {
442            this.status = AutoUpdateStatus::Downloading;
443            cx.notify();
444        })?;
445
446        let temp_dir = tempfile::Builder::new()
447            .prefix("zed-auto-update")
448            .tempdir()?;
449        let downloaded_asset = download_release(&temp_dir, release, &asset, client, &cx).await?;
450
451        this.update(&mut cx, |this, cx| {
452            this.status = AutoUpdateStatus::Installing;
453            cx.notify();
454        })?;
455
456        let binary_path = match OS {
457            "macos" => install_release_macos(&temp_dir, downloaded_asset, &cx).await,
458            "linux" => install_release_linux(&temp_dir, downloaded_asset, &cx).await,
459            _ => Err(anyhow!("not supported: {:?}", OS)),
460        }?;
461
462        this.update(&mut cx, |this, cx| {
463            this.set_should_show_update_notification(true, cx)
464                .detach_and_log_err(cx);
465            this.status = AutoUpdateStatus::Updated { binary_path };
466            cx.notify();
467        })?;
468
469        Ok(())
470    }
471
472    fn set_should_show_update_notification(
473        &self,
474        should_show: bool,
475        cx: &AppContext,
476    ) -> Task<Result<()>> {
477        cx.background_executor().spawn(async move {
478            if should_show {
479                KEY_VALUE_STORE
480                    .write_kvp(
481                        SHOULD_SHOW_UPDATE_NOTIFICATION_KEY.to_string(),
482                        "".to_string(),
483                    )
484                    .await?;
485            } else {
486                KEY_VALUE_STORE
487                    .delete_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY.to_string())
488                    .await?;
489            }
490            Ok(())
491        })
492    }
493
494    fn should_show_update_notification(&self, cx: &AppContext) -> Task<Result<bool>> {
495        cx.background_executor().spawn(async move {
496            Ok(KEY_VALUE_STORE
497                .read_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?
498                .is_some())
499        })
500    }
501}
502
503async fn download_release(
504    temp_dir: &tempfile::TempDir,
505    release: JsonRelease,
506    target_filename: &str,
507    client: Arc<HttpClientWithUrl>,
508    cx: &AsyncAppContext,
509) -> Result<PathBuf> {
510    let target_path = temp_dir.path().join(target_filename);
511    let mut target_file = File::create(&target_path).await?;
512
513    let (installation_id, release_channel, telemetry) = cx.update(|cx| {
514        let installation_id = Client::global(cx).telemetry().installation_id();
515        let release_channel =
516            ReleaseChannel::try_global(cx).map(|release_channel| release_channel.display_name());
517        let telemetry = TelemetrySettings::get_global(cx).metrics;
518
519        (installation_id, release_channel, telemetry)
520    })?;
521
522    let request_body = AsyncBody::from(serde_json::to_string(&UpdateRequestBody {
523        installation_id,
524        release_channel,
525        telemetry,
526    })?);
527
528    let mut response = client.get(&release.url, request_body, true).await?;
529    smol::io::copy(response.body_mut(), &mut target_file).await?;
530    log::info!("downloaded update. path:{:?}", target_path);
531
532    Ok(target_path)
533}
534
535async fn install_release_linux(
536    temp_dir: &tempfile::TempDir,
537    downloaded_tar_gz: PathBuf,
538    cx: &AsyncAppContext,
539) -> Result<PathBuf> {
540    let channel = cx.update(|cx| ReleaseChannel::global(cx).dev_name())?;
541    let home_dir = PathBuf::from(env::var("HOME").context("no HOME env var set")?);
542    let running_app_path = cx.update(|cx| cx.app_path())??;
543
544    let extracted = temp_dir.path().join("zed");
545    fs::create_dir_all(&extracted)
546        .await
547        .context("failed to create directory into which to extract update")?;
548
549    let output = Command::new("tar")
550        .arg("-xzf")
551        .arg(&downloaded_tar_gz)
552        .arg("-C")
553        .arg(&extracted)
554        .output()
555        .await?;
556
557    anyhow::ensure!(
558        output.status.success(),
559        "failed to extract {:?} to {:?}: {:?}",
560        downloaded_tar_gz,
561        extracted,
562        String::from_utf8_lossy(&output.stderr)
563    );
564
565    let suffix = if channel != "stable" {
566        format!("-{}", channel)
567    } else {
568        String::default()
569    };
570    let app_folder_name = format!("zed{}.app", suffix);
571
572    let from = extracted.join(&app_folder_name);
573    let mut to = home_dir.join(".local");
574
575    let expected_suffix = format!("{}/libexec/zed-editor", app_folder_name);
576
577    if let Some(prefix) = running_app_path
578        .to_str()
579        .and_then(|str| str.strip_suffix(&expected_suffix))
580    {
581        to = PathBuf::from(prefix);
582    }
583
584    let output = Command::new("rsync")
585        .args(&["-av", "--delete"])
586        .arg(&from)
587        .arg(&to)
588        .output()
589        .await?;
590
591    anyhow::ensure!(
592        output.status.success(),
593        "failed to copy Zed update from {:?} to {:?}: {:?}",
594        from,
595        to,
596        String::from_utf8_lossy(&output.stderr)
597    );
598
599    Ok(to.join(expected_suffix))
600}
601
602async fn install_release_macos(
603    temp_dir: &tempfile::TempDir,
604    downloaded_dmg: PathBuf,
605    cx: &AsyncAppContext,
606) -> Result<PathBuf> {
607    let running_app_path = cx.update(|cx| cx.app_path())??;
608    let running_app_filename = running_app_path
609        .file_name()
610        .ok_or_else(|| anyhow!("invalid running app path"))?;
611
612    let mount_path = temp_dir.path().join("Zed");
613    let mut mounted_app_path: OsString = mount_path.join(running_app_filename).into();
614
615    mounted_app_path.push("/");
616    let output = Command::new("hdiutil")
617        .args(&["attach", "-nobrowse"])
618        .arg(&downloaded_dmg)
619        .arg("-mountroot")
620        .arg(&temp_dir.path())
621        .output()
622        .await?;
623
624    anyhow::ensure!(
625        output.status.success(),
626        "failed to mount: {:?}",
627        String::from_utf8_lossy(&output.stderr)
628    );
629
630    let output = Command::new("rsync")
631        .args(&["-av", "--delete"])
632        .arg(&mounted_app_path)
633        .arg(&running_app_path)
634        .output()
635        .await?;
636
637    anyhow::ensure!(
638        output.status.success(),
639        "failed to copy app: {:?}",
640        String::from_utf8_lossy(&output.stderr)
641    );
642
643    let output = Command::new("hdiutil")
644        .args(&["detach"])
645        .arg(&mount_path)
646        .output()
647        .await?;
648
649    anyhow::ensure!(
650        output.status.success(),
651        "failed to unount: {:?}",
652        String::from_utf8_lossy(&output.stderr)
653    );
654
655    Ok(running_app_path)
656}