1pub mod copilot_chat;
   2mod copilot_completion_provider;
   3pub mod request;
   4mod sign_in;
   5
   6use ::fs::Fs;
   7use anyhow::{anyhow, Context as _, Result};
   8use async_compression::futures::bufread::GzipDecoder;
   9use async_tar::Archive;
  10use collections::{HashMap, HashSet};
  11use command_palette_hooks::CommandPaletteFilter;
  12use futures::{channel::oneshot, future::Shared, Future, FutureExt, TryFutureExt};
  13use gpui::{
  14    actions, App, AppContext as _, AsyncApp, Context, Entity, EntityId, EventEmitter, Global, Task,
  15    WeakEntity,
  16};
  17use http_client::github::get_release_by_tag_name;
  18use http_client::HttpClient;
  19use language::language_settings::CopilotSettings;
  20use language::{
  21    language_settings::{all_language_settings, language_settings, EditPredictionProvider},
  22    point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language, PointUtf16,
  23    ToPointUtf16,
  24};
  25use lsp::{LanguageServer, LanguageServerBinary, LanguageServerId, LanguageServerName};
  26use node_runtime::NodeRuntime;
  27use parking_lot::Mutex;
  28use request::StatusNotification;
  29use settings::SettingsStore;
  30use smol::{fs, io::BufReader, stream::StreamExt};
  31use std::{
  32    any::TypeId,
  33    env,
  34    ffi::OsString,
  35    mem,
  36    ops::Range,
  37    path::{Path, PathBuf},
  38    sync::Arc,
  39};
  40use util::{fs::remove_matching, maybe, ResultExt};
  41
  42pub use crate::copilot_completion_provider::CopilotCompletionProvider;
  43pub use crate::sign_in::{initiate_sign_in, CopilotCodeVerification};
  44
  45actions!(
  46    copilot,
  47    [
  48        Suggest,
  49        NextSuggestion,
  50        PreviousSuggestion,
  51        Reinstall,
  52        SignIn,
  53        SignOut
  54    ]
  55);
  56
  57pub fn init(
  58    new_server_id: LanguageServerId,
  59    fs: Arc<dyn Fs>,
  60    http: Arc<dyn HttpClient>,
  61    node_runtime: NodeRuntime,
  62    cx: &mut App,
  63) {
  64    copilot_chat::init(fs, http.clone(), cx);
  65
  66    let copilot = cx.new({
  67        let node_runtime = node_runtime.clone();
  68        move |cx| Copilot::start(new_server_id, http, node_runtime, cx)
  69    });
  70    Copilot::set_global(copilot.clone(), cx);
  71    cx.observe(&copilot, |handle, cx| {
  72        let copilot_action_types = [
  73            TypeId::of::<Suggest>(),
  74            TypeId::of::<NextSuggestion>(),
  75            TypeId::of::<PreviousSuggestion>(),
  76            TypeId::of::<Reinstall>(),
  77        ];
  78        let copilot_auth_action_types = [TypeId::of::<SignOut>()];
  79        let copilot_no_auth_action_types = [TypeId::of::<SignIn>()];
  80        let status = handle.read(cx).status();
  81        let filter = CommandPaletteFilter::global_mut(cx);
  82
  83        match status {
  84            Status::Disabled => {
  85                filter.hide_action_types(&copilot_action_types);
  86                filter.hide_action_types(&copilot_auth_action_types);
  87                filter.hide_action_types(&copilot_no_auth_action_types);
  88            }
  89            Status::Authorized => {
  90                filter.hide_action_types(&copilot_no_auth_action_types);
  91                filter.show_action_types(
  92                    copilot_action_types
  93                        .iter()
  94                        .chain(&copilot_auth_action_types),
  95                );
  96            }
  97            _ => {
  98                filter.hide_action_types(&copilot_action_types);
  99                filter.hide_action_types(&copilot_auth_action_types);
 100                filter.show_action_types(copilot_no_auth_action_types.iter());
 101            }
 102        }
 103    })
 104    .detach();
 105
 106    cx.on_action(|_: &SignIn, cx| {
 107        if let Some(copilot) = Copilot::global(cx) {
 108            copilot
 109                .update(cx, |copilot, cx| copilot.sign_in(cx))
 110                .detach_and_log_err(cx);
 111        }
 112    });
 113    cx.on_action(|_: &SignOut, cx| {
 114        if let Some(copilot) = Copilot::global(cx) {
 115            copilot
 116                .update(cx, |copilot, cx| copilot.sign_out(cx))
 117                .detach_and_log_err(cx);
 118        }
 119    });
 120    cx.on_action(|_: &Reinstall, cx| {
 121        if let Some(copilot) = Copilot::global(cx) {
 122            copilot
 123                .update(cx, |copilot, cx| copilot.reinstall(cx))
 124                .detach();
 125        }
 126    });
 127}
 128
 129enum CopilotServer {
 130    Disabled,
 131    Starting { task: Shared<Task<()>> },
 132    Error(Arc<str>),
 133    Running(RunningCopilotServer),
 134}
 135
 136impl CopilotServer {
 137    fn as_authenticated(&mut self) -> Result<&mut RunningCopilotServer> {
 138        let server = self.as_running()?;
 139        if matches!(server.sign_in_status, SignInStatus::Authorized { .. }) {
 140            Ok(server)
 141        } else {
 142            Err(anyhow!("must sign in before using copilot"))
 143        }
 144    }
 145
 146    fn as_running(&mut self) -> Result<&mut RunningCopilotServer> {
 147        match self {
 148            CopilotServer::Starting { .. } => Err(anyhow!("copilot is still starting")),
 149            CopilotServer::Disabled => Err(anyhow!("copilot is disabled")),
 150            CopilotServer::Error(error) => Err(anyhow!(
 151                "copilot was not started because of an error: {}",
 152                error
 153            )),
 154            CopilotServer::Running(server) => Ok(server),
 155        }
 156    }
 157}
 158
 159struct RunningCopilotServer {
 160    lsp: Arc<LanguageServer>,
 161    sign_in_status: SignInStatus,
 162    registered_buffers: HashMap<EntityId, RegisteredBuffer>,
 163}
 164
 165#[derive(Clone, Debug)]
 166enum SignInStatus {
 167    Authorized,
 168    Unauthorized,
 169    SigningIn {
 170        prompt: Option<request::PromptUserDeviceFlow>,
 171        task: Shared<Task<Result<(), Arc<anyhow::Error>>>>,
 172    },
 173    SignedOut {
 174        awaiting_signing_in: bool,
 175    },
 176}
 177
 178#[derive(Debug, Clone)]
 179pub enum Status {
 180    Starting {
 181        task: Shared<Task<()>>,
 182    },
 183    Error(Arc<str>),
 184    Disabled,
 185    SignedOut {
 186        awaiting_signing_in: bool,
 187    },
 188    SigningIn {
 189        prompt: Option<request::PromptUserDeviceFlow>,
 190    },
 191    Unauthorized,
 192    Authorized,
 193}
 194
 195impl Status {
 196    pub fn is_authorized(&self) -> bool {
 197        matches!(self, Status::Authorized)
 198    }
 199
 200    pub fn is_disabled(&self) -> bool {
 201        matches!(self, Status::Disabled)
 202    }
 203}
 204
 205struct RegisteredBuffer {
 206    uri: lsp::Url,
 207    language_id: String,
 208    snapshot: BufferSnapshot,
 209    snapshot_version: i32,
 210    _subscriptions: [gpui::Subscription; 2],
 211    pending_buffer_change: Task<Option<()>>,
 212}
 213
 214impl RegisteredBuffer {
 215    fn report_changes(
 216        &mut self,
 217        buffer: &Entity<Buffer>,
 218        cx: &mut Context<Copilot>,
 219    ) -> oneshot::Receiver<(i32, BufferSnapshot)> {
 220        let (done_tx, done_rx) = oneshot::channel();
 221
 222        if buffer.read(cx).version() == self.snapshot.version {
 223            let _ = done_tx.send((self.snapshot_version, self.snapshot.clone()));
 224        } else {
 225            let buffer = buffer.downgrade();
 226            let id = buffer.entity_id();
 227            let prev_pending_change =
 228                mem::replace(&mut self.pending_buffer_change, Task::ready(None));
 229            self.pending_buffer_change = cx.spawn(move |copilot, mut cx| async move {
 230                prev_pending_change.await;
 231
 232                let old_version = copilot
 233                    .update(&mut cx, |copilot, _| {
 234                        let server = copilot.server.as_authenticated().log_err()?;
 235                        let buffer = server.registered_buffers.get_mut(&id)?;
 236                        Some(buffer.snapshot.version.clone())
 237                    })
 238                    .ok()??;
 239                let new_snapshot = buffer.update(&mut cx, |buffer, _| buffer.snapshot()).ok()?;
 240
 241                let content_changes = cx
 242                    .background_spawn({
 243                        let new_snapshot = new_snapshot.clone();
 244                        async move {
 245                            new_snapshot
 246                                .edits_since::<(PointUtf16, usize)>(&old_version)
 247                                .map(|edit| {
 248                                    let edit_start = edit.new.start.0;
 249                                    let edit_end = edit_start + (edit.old.end.0 - edit.old.start.0);
 250                                    let new_text = new_snapshot
 251                                        .text_for_range(edit.new.start.1..edit.new.end.1)
 252                                        .collect();
 253                                    lsp::TextDocumentContentChangeEvent {
 254                                        range: Some(lsp::Range::new(
 255                                            point_to_lsp(edit_start),
 256                                            point_to_lsp(edit_end),
 257                                        )),
 258                                        range_length: None,
 259                                        text: new_text,
 260                                    }
 261                                })
 262                                .collect::<Vec<_>>()
 263                        }
 264                    })
 265                    .await;
 266
 267                copilot
 268                    .update(&mut cx, |copilot, _| {
 269                        let server = copilot.server.as_authenticated().log_err()?;
 270                        let buffer = server.registered_buffers.get_mut(&id)?;
 271                        if !content_changes.is_empty() {
 272                            buffer.snapshot_version += 1;
 273                            buffer.snapshot = new_snapshot;
 274                            server
 275                                .lsp
 276                                .notify::<lsp::notification::DidChangeTextDocument>(
 277                                    &lsp::DidChangeTextDocumentParams {
 278                                        text_document: lsp::VersionedTextDocumentIdentifier::new(
 279                                            buffer.uri.clone(),
 280                                            buffer.snapshot_version,
 281                                        ),
 282                                        content_changes,
 283                                    },
 284                                )
 285                                .log_err();
 286                        }
 287                        let _ = done_tx.send((buffer.snapshot_version, buffer.snapshot.clone()));
 288                        Some(())
 289                    })
 290                    .ok()?;
 291
 292                Some(())
 293            });
 294        }
 295
 296        done_rx
 297    }
 298}
 299
 300#[derive(Debug)]
 301pub struct Completion {
 302    pub uuid: String,
 303    pub range: Range<Anchor>,
 304    pub text: String,
 305}
 306
 307pub struct Copilot {
 308    http: Arc<dyn HttpClient>,
 309    node_runtime: NodeRuntime,
 310    server: CopilotServer,
 311    buffers: HashSet<WeakEntity<Buffer>>,
 312    server_id: LanguageServerId,
 313    _subscription: gpui::Subscription,
 314}
 315
 316pub enum Event {
 317    CopilotLanguageServerStarted,
 318    CopilotAuthSignedIn,
 319    CopilotAuthSignedOut,
 320}
 321
 322impl EventEmitter<Event> for Copilot {}
 323
 324struct GlobalCopilot(Entity<Copilot>);
 325
 326impl Global for GlobalCopilot {}
 327
 328impl Copilot {
 329    pub fn global(cx: &App) -> Option<Entity<Self>> {
 330        cx.try_global::<GlobalCopilot>()
 331            .map(|model| model.0.clone())
 332    }
 333
 334    pub fn set_global(copilot: Entity<Self>, cx: &mut App) {
 335        cx.set_global(GlobalCopilot(copilot));
 336    }
 337
 338    fn start(
 339        new_server_id: LanguageServerId,
 340        http: Arc<dyn HttpClient>,
 341        node_runtime: NodeRuntime,
 342        cx: &mut Context<Self>,
 343    ) -> Self {
 344        let mut this = Self {
 345            server_id: new_server_id,
 346            http,
 347            node_runtime,
 348            server: CopilotServer::Disabled,
 349            buffers: Default::default(),
 350            _subscription: cx.on_app_quit(Self::shutdown_language_server),
 351        };
 352        this.start_copilot(true, false, cx);
 353        cx.observe_global::<SettingsStore>(move |this, cx| this.start_copilot(true, false, cx))
 354            .detach();
 355        this
 356    }
 357
 358    fn shutdown_language_server(&mut self, _cx: &mut Context<Self>) -> impl Future<Output = ()> {
 359        let shutdown = match mem::replace(&mut self.server, CopilotServer::Disabled) {
 360            CopilotServer::Running(server) => Some(Box::pin(async move { server.lsp.shutdown() })),
 361            _ => None,
 362        };
 363
 364        async move {
 365            if let Some(shutdown) = shutdown {
 366                shutdown.await;
 367            }
 368        }
 369    }
 370
 371    fn start_copilot(
 372        &mut self,
 373        check_edit_prediction_provider: bool,
 374        awaiting_sign_in_after_start: bool,
 375        cx: &mut Context<Self>,
 376    ) {
 377        if !matches!(self.server, CopilotServer::Disabled) {
 378            return;
 379        }
 380        let language_settings = all_language_settings(None, cx);
 381        if check_edit_prediction_provider
 382            && language_settings.edit_predictions.provider != EditPredictionProvider::Copilot
 383        {
 384            return;
 385        }
 386        let server_id = self.server_id;
 387        let http = self.http.clone();
 388        let node_runtime = self.node_runtime.clone();
 389        let env = self.build_env(&language_settings.edit_predictions.copilot);
 390        let start_task = cx
 391            .spawn(move |this, cx| {
 392                Self::start_language_server(
 393                    server_id,
 394                    http,
 395                    node_runtime,
 396                    env,
 397                    this,
 398                    awaiting_sign_in_after_start,
 399                    cx,
 400                )
 401            })
 402            .shared();
 403        self.server = CopilotServer::Starting { task: start_task };
 404        cx.notify();
 405    }
 406
 407    fn build_env(&self, copilot_settings: &CopilotSettings) -> Option<HashMap<String, String>> {
 408        let proxy_url = copilot_settings.proxy.clone()?;
 409        let no_verify = copilot_settings.proxy_no_verify;
 410        let http_or_https_proxy = if proxy_url.starts_with("http:") {
 411            "HTTP_PROXY"
 412        } else if proxy_url.starts_with("https:") {
 413            "HTTPS_PROXY"
 414        } else {
 415            log::error!(
 416                "Unsupported protocol scheme for language server proxy (must be http or https)"
 417            );
 418            return None;
 419        };
 420
 421        let mut env = HashMap::default();
 422        env.insert(http_or_https_proxy.to_string(), proxy_url);
 423
 424        if let Some(true) = no_verify {
 425            env.insert("NODE_TLS_REJECT_UNAUTHORIZED".to_string(), "0".to_string());
 426        };
 427
 428        Some(env)
 429    }
 430
 431    #[cfg(any(test, feature = "test-support"))]
 432    pub fn fake(cx: &mut gpui::TestAppContext) -> (Entity<Self>, lsp::FakeLanguageServer) {
 433        use lsp::FakeLanguageServer;
 434        use node_runtime::NodeRuntime;
 435
 436        let (server, fake_server) = FakeLanguageServer::new(
 437            LanguageServerId(0),
 438            LanguageServerBinary {
 439                path: "path/to/copilot".into(),
 440                arguments: vec![],
 441                env: None,
 442            },
 443            "copilot".into(),
 444            Default::default(),
 445            cx.to_async(),
 446        );
 447        let http = http_client::FakeHttpClient::create(|_| async { unreachable!() });
 448        let node_runtime = NodeRuntime::unavailable();
 449        let this = cx.new(|cx| Self {
 450            server_id: LanguageServerId(0),
 451            http: http.clone(),
 452            node_runtime,
 453            server: CopilotServer::Running(RunningCopilotServer {
 454                lsp: Arc::new(server),
 455                sign_in_status: SignInStatus::Authorized,
 456                registered_buffers: Default::default(),
 457            }),
 458            _subscription: cx.on_app_quit(Self::shutdown_language_server),
 459            buffers: Default::default(),
 460        });
 461        (this, fake_server)
 462    }
 463
 464    async fn start_language_server(
 465        new_server_id: LanguageServerId,
 466        http: Arc<dyn HttpClient>,
 467        node_runtime: NodeRuntime,
 468        env: Option<HashMap<String, String>>,
 469        this: WeakEntity<Self>,
 470        awaiting_sign_in_after_start: bool,
 471        mut cx: AsyncApp,
 472    ) {
 473        let start_language_server = async {
 474            let server_path = get_copilot_lsp(http).await?;
 475            let node_path = node_runtime.binary_path().await?;
 476            let arguments: Vec<OsString> = vec![server_path.into(), "--stdio".into()];
 477            let binary = LanguageServerBinary {
 478                path: node_path,
 479                arguments,
 480                env,
 481            };
 482
 483            let root_path = if cfg!(target_os = "windows") {
 484                Path::new("C:/")
 485            } else {
 486                Path::new("/")
 487            };
 488
 489            let server_name = LanguageServerName("copilot".into());
 490            let server = LanguageServer::new(
 491                Arc::new(Mutex::new(None)),
 492                new_server_id,
 493                server_name,
 494                binary,
 495                root_path,
 496                None,
 497                Default::default(),
 498                cx.clone(),
 499            )?;
 500
 501            server
 502                .on_notification::<StatusNotification, _>(|_, _| { /* Silence the notification */ })
 503                .detach();
 504
 505            let configuration = lsp::DidChangeConfigurationParams {
 506                settings: Default::default(),
 507            };
 508            let server = cx
 509                .update(|cx| {
 510                    let params = server.default_initialize_params(cx);
 511                    server.initialize(params, configuration.into(), cx)
 512                })?
 513                .await?;
 514
 515            let status = server
 516                .request::<request::CheckStatus>(request::CheckStatusParams {
 517                    local_checks_only: false,
 518                })
 519                .await?;
 520
 521            server
 522                .request::<request::SetEditorInfo>(request::SetEditorInfoParams {
 523                    editor_info: request::EditorInfo {
 524                        name: "zed".into(),
 525                        version: env!("CARGO_PKG_VERSION").into(),
 526                    },
 527                    editor_plugin_info: request::EditorPluginInfo {
 528                        name: "zed-copilot".into(),
 529                        version: "0.0.1".into(),
 530                    },
 531                })
 532                .await?;
 533
 534            anyhow::Ok((server, status))
 535        };
 536
 537        let server = start_language_server.await;
 538        this.update(&mut cx, |this, cx| {
 539            cx.notify();
 540            match server {
 541                Ok((server, status)) => {
 542                    this.server = CopilotServer::Running(RunningCopilotServer {
 543                        lsp: server,
 544                        sign_in_status: SignInStatus::SignedOut {
 545                            awaiting_signing_in: awaiting_sign_in_after_start,
 546                        },
 547                        registered_buffers: Default::default(),
 548                    });
 549                    cx.emit(Event::CopilotLanguageServerStarted);
 550                    this.update_sign_in_status(status, cx);
 551                }
 552                Err(error) => {
 553                    this.server = CopilotServer::Error(error.to_string().into());
 554                    cx.notify()
 555                }
 556            }
 557        })
 558        .ok();
 559    }
 560
 561    pub fn sign_in(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
 562        if let CopilotServer::Running(server) = &mut self.server {
 563            let task = match &server.sign_in_status {
 564                SignInStatus::Authorized { .. } => Task::ready(Ok(())).shared(),
 565                SignInStatus::SigningIn { task, .. } => {
 566                    cx.notify();
 567                    task.clone()
 568                }
 569                SignInStatus::SignedOut { .. } | SignInStatus::Unauthorized { .. } => {
 570                    let lsp = server.lsp.clone();
 571                    let task = cx
 572                        .spawn(|this, mut cx| async move {
 573                            let sign_in = async {
 574                                let sign_in = lsp
 575                                    .request::<request::SignInInitiate>(
 576                                        request::SignInInitiateParams {},
 577                                    )
 578                                    .await?;
 579                                match sign_in {
 580                                    request::SignInInitiateResult::AlreadySignedIn { user } => {
 581                                        Ok(request::SignInStatus::Ok { user: Some(user) })
 582                                    }
 583                                    request::SignInInitiateResult::PromptUserDeviceFlow(flow) => {
 584                                        this.update(&mut cx, |this, cx| {
 585                                            if let CopilotServer::Running(RunningCopilotServer {
 586                                                sign_in_status: status,
 587                                                ..
 588                                            }) = &mut this.server
 589                                            {
 590                                                if let SignInStatus::SigningIn {
 591                                                    prompt: prompt_flow,
 592                                                    ..
 593                                                } = status
 594                                                {
 595                                                    *prompt_flow = Some(flow.clone());
 596                                                    cx.notify();
 597                                                }
 598                                            }
 599                                        })?;
 600                                        let response = lsp
 601                                            .request::<request::SignInConfirm>(
 602                                                request::SignInConfirmParams {
 603                                                    user_code: flow.user_code,
 604                                                },
 605                                            )
 606                                            .await?;
 607                                        Ok(response)
 608                                    }
 609                                }
 610                            };
 611
 612                            let sign_in = sign_in.await;
 613                            this.update(&mut cx, |this, cx| match sign_in {
 614                                Ok(status) => {
 615                                    this.update_sign_in_status(status, cx);
 616                                    Ok(())
 617                                }
 618                                Err(error) => {
 619                                    this.update_sign_in_status(
 620                                        request::SignInStatus::NotSignedIn,
 621                                        cx,
 622                                    );
 623                                    Err(Arc::new(error))
 624                                }
 625                            })?
 626                        })
 627                        .shared();
 628                    server.sign_in_status = SignInStatus::SigningIn {
 629                        prompt: None,
 630                        task: task.clone(),
 631                    };
 632                    cx.notify();
 633                    task
 634                }
 635            };
 636
 637            cx.background_spawn(task.map_err(|err| anyhow!("{:?}", err)))
 638        } else {
 639            // If we're downloading, wait until download is finished
 640            // If we're in a stuck state, display to the user
 641            Task::ready(Err(anyhow!("copilot hasn't started yet")))
 642        }
 643    }
 644
 645    pub fn sign_out(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
 646        self.update_sign_in_status(request::SignInStatus::NotSignedIn, cx);
 647        match &self.server {
 648            CopilotServer::Running(RunningCopilotServer { lsp: server, .. }) => {
 649                let server = server.clone();
 650                cx.background_spawn(async move {
 651                    server
 652                        .request::<request::SignOut>(request::SignOutParams {})
 653                        .await?;
 654                    anyhow::Ok(())
 655                })
 656            }
 657            _ => Task::ready(Err(anyhow!("copilot hasn't started yet"))),
 658        }
 659    }
 660
 661    pub fn reinstall(&mut self, cx: &mut Context<Self>) -> Task<()> {
 662        let language_settings = all_language_settings(None, cx);
 663        let env = self.build_env(&language_settings.edit_predictions.copilot);
 664        let start_task = cx
 665            .spawn({
 666                let http = self.http.clone();
 667                let node_runtime = self.node_runtime.clone();
 668                let server_id = self.server_id;
 669                move |this, cx| async move {
 670                    clear_copilot_dir().await;
 671                    Self::start_language_server(server_id, http, node_runtime, env, this, false, cx)
 672                        .await
 673                }
 674            })
 675            .shared();
 676
 677        self.server = CopilotServer::Starting {
 678            task: start_task.clone(),
 679        };
 680
 681        cx.notify();
 682
 683        cx.background_spawn(start_task)
 684    }
 685
 686    pub fn language_server(&self) -> Option<&Arc<LanguageServer>> {
 687        if let CopilotServer::Running(server) = &self.server {
 688            Some(&server.lsp)
 689        } else {
 690            None
 691        }
 692    }
 693
 694    pub fn register_buffer(&mut self, buffer: &Entity<Buffer>, cx: &mut Context<Self>) {
 695        let weak_buffer = buffer.downgrade();
 696        self.buffers.insert(weak_buffer.clone());
 697
 698        if let CopilotServer::Running(RunningCopilotServer {
 699            lsp: server,
 700            sign_in_status: status,
 701            registered_buffers,
 702            ..
 703        }) = &mut self.server
 704        {
 705            if !matches!(status, SignInStatus::Authorized { .. }) {
 706                return;
 707            }
 708
 709            registered_buffers
 710                .entry(buffer.entity_id())
 711                .or_insert_with(|| {
 712                    let uri: lsp::Url = uri_for_buffer(buffer, cx);
 713                    let language_id = id_for_language(buffer.read(cx).language());
 714                    let snapshot = buffer.read(cx).snapshot();
 715                    server
 716                        .notify::<lsp::notification::DidOpenTextDocument>(
 717                            &lsp::DidOpenTextDocumentParams {
 718                                text_document: lsp::TextDocumentItem {
 719                                    uri: uri.clone(),
 720                                    language_id: language_id.clone(),
 721                                    version: 0,
 722                                    text: snapshot.text(),
 723                                },
 724                            },
 725                        )
 726                        .log_err();
 727
 728                    RegisteredBuffer {
 729                        uri,
 730                        language_id,
 731                        snapshot,
 732                        snapshot_version: 0,
 733                        pending_buffer_change: Task::ready(Some(())),
 734                        _subscriptions: [
 735                            cx.subscribe(buffer, |this, buffer, event, cx| {
 736                                this.handle_buffer_event(buffer, event, cx).log_err();
 737                            }),
 738                            cx.observe_release(buffer, move |this, _buffer, _cx| {
 739                                this.buffers.remove(&weak_buffer);
 740                                this.unregister_buffer(&weak_buffer);
 741                            }),
 742                        ],
 743                    }
 744                });
 745        }
 746    }
 747
 748    fn handle_buffer_event(
 749        &mut self,
 750        buffer: Entity<Buffer>,
 751        event: &language::BufferEvent,
 752        cx: &mut Context<Self>,
 753    ) -> Result<()> {
 754        if let Ok(server) = self.server.as_running() {
 755            if let Some(registered_buffer) = server.registered_buffers.get_mut(&buffer.entity_id())
 756            {
 757                match event {
 758                    language::BufferEvent::Edited => {
 759                        drop(registered_buffer.report_changes(&buffer, cx));
 760                    }
 761                    language::BufferEvent::Saved => {
 762                        server
 763                            .lsp
 764                            .notify::<lsp::notification::DidSaveTextDocument>(
 765                                &lsp::DidSaveTextDocumentParams {
 766                                    text_document: lsp::TextDocumentIdentifier::new(
 767                                        registered_buffer.uri.clone(),
 768                                    ),
 769                                    text: None,
 770                                },
 771                            )?;
 772                    }
 773                    language::BufferEvent::FileHandleChanged
 774                    | language::BufferEvent::LanguageChanged => {
 775                        let new_language_id = id_for_language(buffer.read(cx).language());
 776                        let new_uri = uri_for_buffer(&buffer, cx);
 777                        if new_uri != registered_buffer.uri
 778                            || new_language_id != registered_buffer.language_id
 779                        {
 780                            let old_uri = mem::replace(&mut registered_buffer.uri, new_uri);
 781                            registered_buffer.language_id = new_language_id;
 782                            server
 783                                .lsp
 784                                .notify::<lsp::notification::DidCloseTextDocument>(
 785                                    &lsp::DidCloseTextDocumentParams {
 786                                        text_document: lsp::TextDocumentIdentifier::new(old_uri),
 787                                    },
 788                                )?;
 789                            server
 790                                .lsp
 791                                .notify::<lsp::notification::DidOpenTextDocument>(
 792                                    &lsp::DidOpenTextDocumentParams {
 793                                        text_document: lsp::TextDocumentItem::new(
 794                                            registered_buffer.uri.clone(),
 795                                            registered_buffer.language_id.clone(),
 796                                            registered_buffer.snapshot_version,
 797                                            registered_buffer.snapshot.text(),
 798                                        ),
 799                                    },
 800                                )?;
 801                        }
 802                    }
 803                    _ => {}
 804                }
 805            }
 806        }
 807
 808        Ok(())
 809    }
 810
 811    fn unregister_buffer(&mut self, buffer: &WeakEntity<Buffer>) {
 812        if let Ok(server) = self.server.as_running() {
 813            if let Some(buffer) = server.registered_buffers.remove(&buffer.entity_id()) {
 814                server
 815                    .lsp
 816                    .notify::<lsp::notification::DidCloseTextDocument>(
 817                        &lsp::DidCloseTextDocumentParams {
 818                            text_document: lsp::TextDocumentIdentifier::new(buffer.uri),
 819                        },
 820                    )
 821                    .log_err();
 822            }
 823        }
 824    }
 825
 826    pub fn completions<T>(
 827        &mut self,
 828        buffer: &Entity<Buffer>,
 829        position: T,
 830        cx: &mut Context<Self>,
 831    ) -> Task<Result<Vec<Completion>>>
 832    where
 833        T: ToPointUtf16,
 834    {
 835        self.request_completions::<request::GetCompletions, _>(buffer, position, cx)
 836    }
 837
 838    pub fn completions_cycling<T>(
 839        &mut self,
 840        buffer: &Entity<Buffer>,
 841        position: T,
 842        cx: &mut Context<Self>,
 843    ) -> Task<Result<Vec<Completion>>>
 844    where
 845        T: ToPointUtf16,
 846    {
 847        self.request_completions::<request::GetCompletionsCycling, _>(buffer, position, cx)
 848    }
 849
 850    pub fn accept_completion(
 851        &mut self,
 852        completion: &Completion,
 853        cx: &mut Context<Self>,
 854    ) -> Task<Result<()>> {
 855        let server = match self.server.as_authenticated() {
 856            Ok(server) => server,
 857            Err(error) => return Task::ready(Err(error)),
 858        };
 859        let request =
 860            server
 861                .lsp
 862                .request::<request::NotifyAccepted>(request::NotifyAcceptedParams {
 863                    uuid: completion.uuid.clone(),
 864                });
 865        cx.background_spawn(async move {
 866            request.await?;
 867            Ok(())
 868        })
 869    }
 870
 871    pub fn discard_completions(
 872        &mut self,
 873        completions: &[Completion],
 874        cx: &mut Context<Self>,
 875    ) -> Task<Result<()>> {
 876        let server = match self.server.as_authenticated() {
 877            Ok(server) => server,
 878            Err(_) => return Task::ready(Ok(())),
 879        };
 880        let request =
 881            server
 882                .lsp
 883                .request::<request::NotifyRejected>(request::NotifyRejectedParams {
 884                    uuids: completions
 885                        .iter()
 886                        .map(|completion| completion.uuid.clone())
 887                        .collect(),
 888                });
 889        cx.background_spawn(async move {
 890            request.await?;
 891            Ok(())
 892        })
 893    }
 894
 895    fn request_completions<R, T>(
 896        &mut self,
 897        buffer: &Entity<Buffer>,
 898        position: T,
 899        cx: &mut Context<Self>,
 900    ) -> Task<Result<Vec<Completion>>>
 901    where
 902        R: 'static
 903            + lsp::request::Request<
 904                Params = request::GetCompletionsParams,
 905                Result = request::GetCompletionsResult,
 906            >,
 907        T: ToPointUtf16,
 908    {
 909        self.register_buffer(buffer, cx);
 910
 911        let server = match self.server.as_authenticated() {
 912            Ok(server) => server,
 913            Err(error) => return Task::ready(Err(error)),
 914        };
 915        let lsp = server.lsp.clone();
 916        let registered_buffer = server
 917            .registered_buffers
 918            .get_mut(&buffer.entity_id())
 919            .unwrap();
 920        let snapshot = registered_buffer.report_changes(buffer, cx);
 921        let buffer = buffer.read(cx);
 922        let uri = registered_buffer.uri.clone();
 923        let position = position.to_point_utf16(buffer);
 924        let settings = language_settings(
 925            buffer.language_at(position).map(|l| l.name()),
 926            buffer.file(),
 927            cx,
 928        );
 929        let tab_size = settings.tab_size;
 930        let hard_tabs = settings.hard_tabs;
 931        let relative_path = buffer
 932            .file()
 933            .map(|file| file.path().to_path_buf())
 934            .unwrap_or_default();
 935
 936        cx.background_spawn(async move {
 937            let (version, snapshot) = snapshot.await?;
 938            let result = lsp
 939                .request::<R>(request::GetCompletionsParams {
 940                    doc: request::GetCompletionsDocument {
 941                        uri,
 942                        tab_size: tab_size.into(),
 943                        indent_size: 1,
 944                        insert_spaces: !hard_tabs,
 945                        relative_path: relative_path.to_string_lossy().into(),
 946                        position: point_to_lsp(position),
 947                        version: version.try_into().unwrap(),
 948                    },
 949                })
 950                .await?;
 951            let completions = result
 952                .completions
 953                .into_iter()
 954                .map(|completion| {
 955                    let start = snapshot
 956                        .clip_point_utf16(point_from_lsp(completion.range.start), Bias::Left);
 957                    let end =
 958                        snapshot.clip_point_utf16(point_from_lsp(completion.range.end), Bias::Left);
 959                    Completion {
 960                        uuid: completion.uuid,
 961                        range: snapshot.anchor_before(start)..snapshot.anchor_after(end),
 962                        text: completion.text,
 963                    }
 964                })
 965                .collect();
 966            anyhow::Ok(completions)
 967        })
 968    }
 969
 970    pub fn status(&self) -> Status {
 971        match &self.server {
 972            CopilotServer::Starting { task } => Status::Starting { task: task.clone() },
 973            CopilotServer::Disabled => Status::Disabled,
 974            CopilotServer::Error(error) => Status::Error(error.clone()),
 975            CopilotServer::Running(RunningCopilotServer { sign_in_status, .. }) => {
 976                match sign_in_status {
 977                    SignInStatus::Authorized { .. } => Status::Authorized,
 978                    SignInStatus::Unauthorized { .. } => Status::Unauthorized,
 979                    SignInStatus::SigningIn { prompt, .. } => Status::SigningIn {
 980                        prompt: prompt.clone(),
 981                    },
 982                    SignInStatus::SignedOut {
 983                        awaiting_signing_in,
 984                    } => Status::SignedOut {
 985                        awaiting_signing_in: *awaiting_signing_in,
 986                    },
 987                }
 988            }
 989        }
 990    }
 991
 992    fn update_sign_in_status(&mut self, lsp_status: request::SignInStatus, cx: &mut Context<Self>) {
 993        self.buffers.retain(|buffer| buffer.is_upgradable());
 994
 995        if let Ok(server) = self.server.as_running() {
 996            match lsp_status {
 997                request::SignInStatus::Ok { user: Some(_) }
 998                | request::SignInStatus::MaybeOk { .. }
 999                | request::SignInStatus::AlreadySignedIn { .. } => {
1000                    server.sign_in_status = SignInStatus::Authorized;
1001                    cx.emit(Event::CopilotAuthSignedIn);
1002                    for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
1003                        if let Some(buffer) = buffer.upgrade() {
1004                            self.register_buffer(&buffer, cx);
1005                        }
1006                    }
1007                }
1008                request::SignInStatus::NotAuthorized { .. } => {
1009                    server.sign_in_status = SignInStatus::Unauthorized;
1010                    for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
1011                        self.unregister_buffer(&buffer);
1012                    }
1013                }
1014                request::SignInStatus::Ok { user: None } | request::SignInStatus::NotSignedIn => {
1015                    if !matches!(server.sign_in_status, SignInStatus::SignedOut { .. }) {
1016                        server.sign_in_status = SignInStatus::SignedOut {
1017                            awaiting_signing_in: false,
1018                        };
1019                    }
1020                    cx.emit(Event::CopilotAuthSignedOut);
1021                    for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
1022                        self.unregister_buffer(&buffer);
1023                    }
1024                }
1025            }
1026
1027            cx.notify();
1028        }
1029    }
1030}
1031
1032fn id_for_language(language: Option<&Arc<Language>>) -> String {
1033    language
1034        .map(|language| language.lsp_id())
1035        .unwrap_or_else(|| "plaintext".to_string())
1036}
1037
1038fn uri_for_buffer(buffer: &Entity<Buffer>, cx: &App) -> lsp::Url {
1039    if let Some(file) = buffer.read(cx).file().and_then(|file| file.as_local()) {
1040        lsp::Url::from_file_path(file.abs_path(cx)).unwrap()
1041    } else {
1042        format!("buffer://{}", buffer.entity_id()).parse().unwrap()
1043    }
1044}
1045
1046async fn clear_copilot_dir() {
1047    remove_matching(paths::copilot_dir(), |_| true).await
1048}
1049
1050async fn get_copilot_lsp(http: Arc<dyn HttpClient>) -> anyhow::Result<PathBuf> {
1051    const SERVER_PATH: &str = "dist/language-server.js";
1052
1053    ///Check for the latest copilot language server and download it if we haven't already
1054    async fn fetch_latest(http: Arc<dyn HttpClient>) -> anyhow::Result<PathBuf> {
1055        let release =
1056            get_release_by_tag_name("zed-industries/copilot", "v0.7.0", http.clone()).await?;
1057
1058        let version_dir = &paths::copilot_dir().join(format!("copilot-{}", release.tag_name));
1059
1060        fs::create_dir_all(version_dir).await?;
1061        let server_path = version_dir.join(SERVER_PATH);
1062
1063        if fs::metadata(&server_path).await.is_err() {
1064            // Copilot LSP looks for this dist dir specifically, so lets add it in.
1065            let dist_dir = version_dir.join("dist");
1066            fs::create_dir_all(dist_dir.as_path()).await?;
1067
1068            let url = &release
1069                .assets
1070                .first()
1071                .context("Github release for copilot contained no assets")?
1072                .browser_download_url;
1073
1074            let mut response = http
1075                .get(url, Default::default(), true)
1076                .await
1077                .context("error downloading copilot release")?;
1078            let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
1079            let archive = Archive::new(decompressed_bytes);
1080            archive.unpack(dist_dir).await?;
1081
1082            remove_matching(paths::copilot_dir(), |entry| entry != version_dir).await;
1083        }
1084
1085        Ok(server_path)
1086    }
1087
1088    match fetch_latest(http).await {
1089        ok @ Result::Ok(..) => ok,
1090        e @ Err(..) => {
1091            e.log_err();
1092            // Fetch a cached binary, if it exists
1093            maybe!(async {
1094                let mut last_version_dir = None;
1095                let mut entries = fs::read_dir(paths::copilot_dir()).await?;
1096                while let Some(entry) = entries.next().await {
1097                    let entry = entry?;
1098                    if entry.file_type().await?.is_dir() {
1099                        last_version_dir = Some(entry.path());
1100                    }
1101                }
1102                let last_version_dir =
1103                    last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
1104                let server_path = last_version_dir.join(SERVER_PATH);
1105                if server_path.exists() {
1106                    Ok(server_path)
1107                } else {
1108                    Err(anyhow!(
1109                        "missing executable in directory {:?}",
1110                        last_version_dir
1111                    ))
1112                }
1113            })
1114            .await
1115        }
1116    }
1117}
1118
1119#[cfg(test)]
1120mod tests {
1121    use super::*;
1122    use gpui::TestAppContext;
1123    use util::path;
1124
1125    #[gpui::test(iterations = 10)]
1126    async fn test_buffer_management(cx: &mut TestAppContext) {
1127        let (copilot, mut lsp) = Copilot::fake(cx);
1128
1129        let buffer_1 = cx.new(|cx| Buffer::local("Hello", cx));
1130        let buffer_1_uri: lsp::Url = format!("buffer://{}", buffer_1.entity_id().as_u64())
1131            .parse()
1132            .unwrap();
1133        copilot.update(cx, |copilot, cx| copilot.register_buffer(&buffer_1, cx));
1134        assert_eq!(
1135            lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1136                .await,
1137            lsp::DidOpenTextDocumentParams {
1138                text_document: lsp::TextDocumentItem::new(
1139                    buffer_1_uri.clone(),
1140                    "plaintext".into(),
1141                    0,
1142                    "Hello".into()
1143                ),
1144            }
1145        );
1146
1147        let buffer_2 = cx.new(|cx| Buffer::local("Goodbye", cx));
1148        let buffer_2_uri: lsp::Url = format!("buffer://{}", buffer_2.entity_id().as_u64())
1149            .parse()
1150            .unwrap();
1151        copilot.update(cx, |copilot, cx| copilot.register_buffer(&buffer_2, cx));
1152        assert_eq!(
1153            lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1154                .await,
1155            lsp::DidOpenTextDocumentParams {
1156                text_document: lsp::TextDocumentItem::new(
1157                    buffer_2_uri.clone(),
1158                    "plaintext".into(),
1159                    0,
1160                    "Goodbye".into()
1161                ),
1162            }
1163        );
1164
1165        buffer_1.update(cx, |buffer, cx| buffer.edit([(5..5, " world")], None, cx));
1166        assert_eq!(
1167            lsp.receive_notification::<lsp::notification::DidChangeTextDocument>()
1168                .await,
1169            lsp::DidChangeTextDocumentParams {
1170                text_document: lsp::VersionedTextDocumentIdentifier::new(buffer_1_uri.clone(), 1),
1171                content_changes: vec![lsp::TextDocumentContentChangeEvent {
1172                    range: Some(lsp::Range::new(
1173                        lsp::Position::new(0, 5),
1174                        lsp::Position::new(0, 5)
1175                    )),
1176                    range_length: None,
1177                    text: " world".into(),
1178                }],
1179            }
1180        );
1181
1182        // Ensure updates to the file are reflected in the LSP.
1183        buffer_1.update(cx, |buffer, cx| {
1184            buffer.file_updated(
1185                Arc::new(File {
1186                    abs_path: path!("/root/child/buffer-1").into(),
1187                    path: Path::new("child/buffer-1").into(),
1188                }),
1189                cx,
1190            )
1191        });
1192        assert_eq!(
1193            lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1194                .await,
1195            lsp::DidCloseTextDocumentParams {
1196                text_document: lsp::TextDocumentIdentifier::new(buffer_1_uri),
1197            }
1198        );
1199        let buffer_1_uri = lsp::Url::from_file_path(path!("/root/child/buffer-1")).unwrap();
1200        assert_eq!(
1201            lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1202                .await,
1203            lsp::DidOpenTextDocumentParams {
1204                text_document: lsp::TextDocumentItem::new(
1205                    buffer_1_uri.clone(),
1206                    "plaintext".into(),
1207                    1,
1208                    "Hello world".into()
1209                ),
1210            }
1211        );
1212
1213        // Ensure all previously-registered buffers are closed when signing out.
1214        lsp.handle_request::<request::SignOut, _, _>(|_, _| async {
1215            Ok(request::SignOutResult {})
1216        });
1217        copilot
1218            .update(cx, |copilot, cx| copilot.sign_out(cx))
1219            .await
1220            .unwrap();
1221        assert_eq!(
1222            lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1223                .await,
1224            lsp::DidCloseTextDocumentParams {
1225                text_document: lsp::TextDocumentIdentifier::new(buffer_1_uri.clone()),
1226            }
1227        );
1228        assert_eq!(
1229            lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1230                .await,
1231            lsp::DidCloseTextDocumentParams {
1232                text_document: lsp::TextDocumentIdentifier::new(buffer_2_uri.clone()),
1233            }
1234        );
1235
1236        // Ensure all previously-registered buffers are re-opened when signing in.
1237        lsp.handle_request::<request::SignInInitiate, _, _>(|_, _| async {
1238            Ok(request::SignInInitiateResult::AlreadySignedIn {
1239                user: "user-1".into(),
1240            })
1241        });
1242        copilot
1243            .update(cx, |copilot, cx| copilot.sign_in(cx))
1244            .await
1245            .unwrap();
1246
1247        assert_eq!(
1248            lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1249                .await,
1250            lsp::DidOpenTextDocumentParams {
1251                text_document: lsp::TextDocumentItem::new(
1252                    buffer_1_uri.clone(),
1253                    "plaintext".into(),
1254                    0,
1255                    "Hello world".into()
1256                ),
1257            }
1258        );
1259        assert_eq!(
1260            lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1261                .await,
1262            lsp::DidOpenTextDocumentParams {
1263                text_document: lsp::TextDocumentItem::new(
1264                    buffer_2_uri.clone(),
1265                    "plaintext".into(),
1266                    0,
1267                    "Goodbye".into()
1268                ),
1269            }
1270        );
1271        // Dropping a buffer causes it to be closed on the LSP side as well.
1272        cx.update(|_| drop(buffer_2));
1273        assert_eq!(
1274            lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1275                .await,
1276            lsp::DidCloseTextDocumentParams {
1277                text_document: lsp::TextDocumentIdentifier::new(buffer_2_uri),
1278            }
1279        );
1280    }
1281
1282    struct File {
1283        abs_path: PathBuf,
1284        path: Arc<Path>,
1285    }
1286
1287    impl language::File for File {
1288        fn as_local(&self) -> Option<&dyn language::LocalFile> {
1289            Some(self)
1290        }
1291
1292        fn disk_state(&self) -> language::DiskState {
1293            language::DiskState::Present {
1294                mtime: ::fs::MTime::from_seconds_and_nanos(100, 42),
1295            }
1296        }
1297
1298        fn path(&self) -> &Arc<Path> {
1299            &self.path
1300        }
1301
1302        fn full_path(&self, _: &App) -> PathBuf {
1303            unimplemented!()
1304        }
1305
1306        fn file_name<'a>(&'a self, _: &'a App) -> &'a std::ffi::OsStr {
1307            unimplemented!()
1308        }
1309
1310        fn as_any(&self) -> &dyn std::any::Any {
1311            unimplemented!()
1312        }
1313
1314        fn to_proto(&self, _: &App) -> rpc::proto::File {
1315            unimplemented!()
1316        }
1317
1318        fn worktree_id(&self, _: &App) -> settings::WorktreeId {
1319            settings::WorktreeId::from_usize(0)
1320        }
1321
1322        fn is_private(&self) -> bool {
1323            false
1324        }
1325    }
1326
1327    impl language::LocalFile for File {
1328        fn abs_path(&self, _: &App) -> PathBuf {
1329            self.abs_path.clone()
1330        }
1331
1332        fn load(&self, _: &App) -> Task<Result<String>> {
1333            unimplemented!()
1334        }
1335
1336        fn load_bytes(&self, _cx: &App) -> Task<Result<Vec<u8>>> {
1337            unimplemented!()
1338        }
1339    }
1340}
1341
1342#[cfg(test)]
1343#[ctor::ctor]
1344fn init_logger() {
1345    if std::env::var("RUST_LOG").is_ok() {
1346        env_logger::init();
1347    }
1348}