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