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 };
432
433 let server = LanguageServer::new(
434 Arc::new(Mutex::new(None)),
435 new_server_id,
436 binary,
437 Path::new("/"),
438 None,
439 cx.clone(),
440 )?;
441
442 server
443 .on_notification::<StatusNotification, _>(
444 |_, _| { /* Silence the notification */ },
445 )
446 .detach();
447
448 let server = cx.update(|cx| server.initialize(None, cx))?.await?;
449
450 let status = server
451 .request::<request::CheckStatus>(request::CheckStatusParams {
452 local_checks_only: false,
453 })
454 .await?;
455
456 server
457 .request::<request::SetEditorInfo>(request::SetEditorInfoParams {
458 editor_info: request::EditorInfo {
459 name: "zed".into(),
460 version: env!("CARGO_PKG_VERSION").into(),
461 },
462 editor_plugin_info: request::EditorPluginInfo {
463 name: "zed-copilot".into(),
464 version: "0.0.1".into(),
465 },
466 })
467 .await?;
468
469 anyhow::Ok((server, status))
470 };
471
472 let server = start_language_server.await;
473 this.update(&mut cx, |this, cx| {
474 cx.notify();
475 match server {
476 Ok((server, status)) => {
477 this.server = CopilotServer::Running(RunningCopilotServer {
478 name: LanguageServerName(Arc::from("copilot")),
479 lsp: server,
480 sign_in_status: SignInStatus::SignedOut,
481 registered_buffers: Default::default(),
482 });
483 cx.emit(Event::CopilotLanguageServerStarted);
484 this.update_sign_in_status(status, cx);
485 }
486 Err(error) => {
487 this.server = CopilotServer::Error(error.to_string().into());
488 cx.notify()
489 }
490 }
491 })
492 .ok();
493 }
494 }
495
496 pub fn sign_in(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
497 if let CopilotServer::Running(server) = &mut self.server {
498 let task = match &server.sign_in_status {
499 SignInStatus::Authorized { .. } => Task::ready(Ok(())).shared(),
500 SignInStatus::SigningIn { task, .. } => {
501 cx.notify();
502 task.clone()
503 }
504 SignInStatus::SignedOut | SignInStatus::Unauthorized { .. } => {
505 let lsp = server.lsp.clone();
506 let task = cx
507 .spawn(|this, mut cx| async move {
508 let sign_in = async {
509 let sign_in = lsp
510 .request::<request::SignInInitiate>(
511 request::SignInInitiateParams {},
512 )
513 .await?;
514 match sign_in {
515 request::SignInInitiateResult::AlreadySignedIn { user } => {
516 Ok(request::SignInStatus::Ok { user })
517 }
518 request::SignInInitiateResult::PromptUserDeviceFlow(flow) => {
519 this.update(&mut cx, |this, cx| {
520 if let CopilotServer::Running(RunningCopilotServer {
521 sign_in_status: status,
522 ..
523 }) = &mut this.server
524 {
525 if let SignInStatus::SigningIn {
526 prompt: prompt_flow,
527 ..
528 } = status
529 {
530 *prompt_flow = Some(flow.clone());
531 cx.notify();
532 }
533 }
534 })?;
535 let response = lsp
536 .request::<request::SignInConfirm>(
537 request::SignInConfirmParams {
538 user_code: flow.user_code,
539 },
540 )
541 .await?;
542 Ok(response)
543 }
544 }
545 };
546
547 let sign_in = sign_in.await;
548 this.update(&mut cx, |this, cx| match sign_in {
549 Ok(status) => {
550 this.update_sign_in_status(status, cx);
551 Ok(())
552 }
553 Err(error) => {
554 this.update_sign_in_status(
555 request::SignInStatus::NotSignedIn,
556 cx,
557 );
558 Err(Arc::new(error))
559 }
560 })?
561 })
562 .shared();
563 server.sign_in_status = SignInStatus::SigningIn {
564 prompt: None,
565 task: task.clone(),
566 };
567 cx.notify();
568 task
569 }
570 };
571
572 cx.background_executor()
573 .spawn(task.map_err(|err| anyhow!("{:?}", err)))
574 } else {
575 // If we're downloading, wait until download is finished
576 // If we're in a stuck state, display to the user
577 Task::ready(Err(anyhow!("copilot hasn't started yet")))
578 }
579 }
580
581 fn sign_out(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
582 self.update_sign_in_status(request::SignInStatus::NotSignedIn, cx);
583 if let CopilotServer::Running(RunningCopilotServer { lsp: server, .. }) = &self.server {
584 let server = server.clone();
585 cx.background_executor().spawn(async move {
586 server
587 .request::<request::SignOut>(request::SignOutParams {})
588 .await?;
589 anyhow::Ok(())
590 })
591 } else {
592 Task::ready(Err(anyhow!("copilot hasn't started yet")))
593 }
594 }
595
596 pub fn reinstall(&mut self, cx: &mut ModelContext<Self>) -> Task<()> {
597 let start_task = cx
598 .spawn({
599 let http = self.http.clone();
600 let node_runtime = self.node_runtime.clone();
601 let server_id = self.server_id;
602 move |this, cx| async move {
603 clear_copilot_dir().await;
604 Self::start_language_server(server_id, http, node_runtime, this, cx).await
605 }
606 })
607 .shared();
608
609 self.server = CopilotServer::Starting {
610 task: start_task.clone(),
611 };
612
613 cx.notify();
614
615 cx.background_executor().spawn(start_task)
616 }
617
618 pub fn language_server(&self) -> Option<(&LanguageServerName, &Arc<LanguageServer>)> {
619 if let CopilotServer::Running(server) = &self.server {
620 Some((&server.name, &server.lsp))
621 } else {
622 None
623 }
624 }
625
626 pub fn register_buffer(&mut self, buffer: &Model<Buffer>, cx: &mut ModelContext<Self>) {
627 let weak_buffer = buffer.downgrade();
628 self.buffers.insert(weak_buffer.clone());
629
630 if let CopilotServer::Running(RunningCopilotServer {
631 lsp: server,
632 sign_in_status: status,
633 registered_buffers,
634 ..
635 }) = &mut self.server
636 {
637 if !matches!(status, SignInStatus::Authorized { .. }) {
638 return;
639 }
640
641 registered_buffers
642 .entry(buffer.entity_id())
643 .or_insert_with(|| {
644 let uri: lsp::Url = uri_for_buffer(buffer, cx);
645 let language_id = id_for_language(buffer.read(cx).language());
646 let snapshot = buffer.read(cx).snapshot();
647 server
648 .notify::<lsp::notification::DidOpenTextDocument>(
649 lsp::DidOpenTextDocumentParams {
650 text_document: lsp::TextDocumentItem {
651 uri: uri.clone(),
652 language_id: language_id.clone(),
653 version: 0,
654 text: snapshot.text(),
655 },
656 },
657 )
658 .log_err();
659
660 RegisteredBuffer {
661 uri,
662 language_id,
663 snapshot,
664 snapshot_version: 0,
665 pending_buffer_change: Task::ready(Some(())),
666 _subscriptions: [
667 cx.subscribe(buffer, |this, buffer, event, cx| {
668 this.handle_buffer_event(buffer, event, cx).log_err();
669 }),
670 cx.observe_release(buffer, move |this, _buffer, _cx| {
671 this.buffers.remove(&weak_buffer);
672 this.unregister_buffer(&weak_buffer);
673 }),
674 ],
675 }
676 });
677 }
678 }
679
680 fn handle_buffer_event(
681 &mut self,
682 buffer: Model<Buffer>,
683 event: &language::Event,
684 cx: &mut ModelContext<Self>,
685 ) -> Result<()> {
686 if let Ok(server) = self.server.as_running() {
687 if let Some(registered_buffer) = server.registered_buffers.get_mut(&buffer.entity_id())
688 {
689 match event {
690 language::Event::Edited => {
691 let _ = registered_buffer.report_changes(&buffer, cx);
692 }
693 language::Event::Saved => {
694 server
695 .lsp
696 .notify::<lsp::notification::DidSaveTextDocument>(
697 lsp::DidSaveTextDocumentParams {
698 text_document: lsp::TextDocumentIdentifier::new(
699 registered_buffer.uri.clone(),
700 ),
701 text: None,
702 },
703 )?;
704 }
705 language::Event::FileHandleChanged | language::Event::LanguageChanged => {
706 let new_language_id = id_for_language(buffer.read(cx).language());
707 let new_uri = uri_for_buffer(&buffer, cx);
708 if new_uri != registered_buffer.uri
709 || new_language_id != registered_buffer.language_id
710 {
711 let old_uri = mem::replace(&mut registered_buffer.uri, new_uri);
712 registered_buffer.language_id = new_language_id;
713 server
714 .lsp
715 .notify::<lsp::notification::DidCloseTextDocument>(
716 lsp::DidCloseTextDocumentParams {
717 text_document: lsp::TextDocumentIdentifier::new(old_uri),
718 },
719 )?;
720 server
721 .lsp
722 .notify::<lsp::notification::DidOpenTextDocument>(
723 lsp::DidOpenTextDocumentParams {
724 text_document: lsp::TextDocumentItem::new(
725 registered_buffer.uri.clone(),
726 registered_buffer.language_id.clone(),
727 registered_buffer.snapshot_version,
728 registered_buffer.snapshot.text(),
729 ),
730 },
731 )?;
732 }
733 }
734 _ => {}
735 }
736 }
737 }
738
739 Ok(())
740 }
741
742 fn unregister_buffer(&mut self, buffer: &WeakModel<Buffer>) {
743 if let Ok(server) = self.server.as_running() {
744 if let Some(buffer) = server.registered_buffers.remove(&buffer.entity_id()) {
745 server
746 .lsp
747 .notify::<lsp::notification::DidCloseTextDocument>(
748 lsp::DidCloseTextDocumentParams {
749 text_document: lsp::TextDocumentIdentifier::new(buffer.uri),
750 },
751 )
752 .log_err();
753 }
754 }
755 }
756
757 pub fn completions<T>(
758 &mut self,
759 buffer: &Model<Buffer>,
760 position: T,
761 cx: &mut ModelContext<Self>,
762 ) -> Task<Result<Vec<Completion>>>
763 where
764 T: ToPointUtf16,
765 {
766 self.request_completions::<request::GetCompletions, _>(buffer, position, cx)
767 }
768
769 pub fn completions_cycling<T>(
770 &mut self,
771 buffer: &Model<Buffer>,
772 position: T,
773 cx: &mut ModelContext<Self>,
774 ) -> Task<Result<Vec<Completion>>>
775 where
776 T: ToPointUtf16,
777 {
778 self.request_completions::<request::GetCompletionsCycling, _>(buffer, position, cx)
779 }
780
781 pub fn accept_completion(
782 &mut self,
783 completion: &Completion,
784 cx: &mut ModelContext<Self>,
785 ) -> Task<Result<()>> {
786 let server = match self.server.as_authenticated() {
787 Ok(server) => server,
788 Err(error) => return Task::ready(Err(error)),
789 };
790 let request =
791 server
792 .lsp
793 .request::<request::NotifyAccepted>(request::NotifyAcceptedParams {
794 uuid: completion.uuid.clone(),
795 });
796 cx.background_executor().spawn(async move {
797 request.await?;
798 Ok(())
799 })
800 }
801
802 pub fn discard_completions(
803 &mut self,
804 completions: &[Completion],
805 cx: &mut ModelContext<Self>,
806 ) -> Task<Result<()>> {
807 let server = match self.server.as_authenticated() {
808 Ok(server) => server,
809 Err(error) => return Task::ready(Err(error)),
810 };
811 let request =
812 server
813 .lsp
814 .request::<request::NotifyRejected>(request::NotifyRejectedParams {
815 uuids: completions
816 .iter()
817 .map(|completion| completion.uuid.clone())
818 .collect(),
819 });
820 cx.background_executor().spawn(async move {
821 request.await?;
822 Ok(())
823 })
824 }
825
826 fn request_completions<R, T>(
827 &mut self,
828 buffer: &Model<Buffer>,
829 position: T,
830 cx: &mut ModelContext<Self>,
831 ) -> Task<Result<Vec<Completion>>>
832 where
833 R: 'static
834 + lsp::request::Request<
835 Params = request::GetCompletionsParams,
836 Result = request::GetCompletionsResult,
837 >,
838 T: ToPointUtf16,
839 {
840 self.register_buffer(buffer, cx);
841
842 let server = match self.server.as_authenticated() {
843 Ok(server) => server,
844 Err(error) => return Task::ready(Err(error)),
845 };
846 let lsp = server.lsp.clone();
847 let registered_buffer = server
848 .registered_buffers
849 .get_mut(&buffer.entity_id())
850 .unwrap();
851 let snapshot = registered_buffer.report_changes(buffer, cx);
852 let buffer = buffer.read(cx);
853 let uri = registered_buffer.uri.clone();
854 let position = position.to_point_utf16(buffer);
855 let settings = language_settings(buffer.language_at(position).as_ref(), buffer.file(), cx);
856 let tab_size = settings.tab_size;
857 let hard_tabs = settings.hard_tabs;
858 let relative_path = buffer
859 .file()
860 .map(|file| file.path().to_path_buf())
861 .unwrap_or_default();
862
863 cx.background_executor().spawn(async move {
864 let (version, snapshot) = snapshot.await?;
865 let result = lsp
866 .request::<R>(request::GetCompletionsParams {
867 doc: request::GetCompletionsDocument {
868 uri,
869 tab_size: tab_size.into(),
870 indent_size: 1,
871 insert_spaces: !hard_tabs,
872 relative_path: relative_path.to_string_lossy().into(),
873 position: point_to_lsp(position),
874 version: version.try_into().unwrap(),
875 },
876 })
877 .await?;
878 let completions = result
879 .completions
880 .into_iter()
881 .map(|completion| {
882 let start = snapshot
883 .clip_point_utf16(point_from_lsp(completion.range.start), Bias::Left);
884 let end =
885 snapshot.clip_point_utf16(point_from_lsp(completion.range.end), Bias::Left);
886 Completion {
887 uuid: completion.uuid,
888 range: snapshot.anchor_before(start)..snapshot.anchor_after(end),
889 text: completion.text,
890 }
891 })
892 .collect();
893 anyhow::Ok(completions)
894 })
895 }
896
897 pub fn status(&self) -> Status {
898 match &self.server {
899 CopilotServer::Starting { task } => Status::Starting { task: task.clone() },
900 CopilotServer::Disabled => Status::Disabled,
901 CopilotServer::Error(error) => Status::Error(error.clone()),
902 CopilotServer::Running(RunningCopilotServer { sign_in_status, .. }) => {
903 match sign_in_status {
904 SignInStatus::Authorized { .. } => Status::Authorized,
905 SignInStatus::Unauthorized { .. } => Status::Unauthorized,
906 SignInStatus::SigningIn { prompt, .. } => Status::SigningIn {
907 prompt: prompt.clone(),
908 },
909 SignInStatus::SignedOut => Status::SignedOut,
910 }
911 }
912 }
913 }
914
915 fn update_sign_in_status(
916 &mut self,
917 lsp_status: request::SignInStatus,
918 cx: &mut ModelContext<Self>,
919 ) {
920 self.buffers.retain(|buffer| buffer.is_upgradable());
921
922 if let Ok(server) = self.server.as_running() {
923 match lsp_status {
924 request::SignInStatus::Ok { .. }
925 | request::SignInStatus::MaybeOk { .. }
926 | request::SignInStatus::AlreadySignedIn { .. } => {
927 server.sign_in_status = SignInStatus::Authorized;
928 for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
929 if let Some(buffer) = buffer.upgrade() {
930 self.register_buffer(&buffer, cx);
931 }
932 }
933 }
934 request::SignInStatus::NotAuthorized { .. } => {
935 server.sign_in_status = SignInStatus::Unauthorized;
936 for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
937 self.unregister_buffer(&buffer);
938 }
939 }
940 request::SignInStatus::NotSignedIn => {
941 server.sign_in_status = SignInStatus::SignedOut;
942 for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
943 self.unregister_buffer(&buffer);
944 }
945 }
946 }
947
948 cx.notify();
949 }
950 }
951}
952
953fn id_for_language(language: Option<&Arc<Language>>) -> String {
954 let language_name = language.map(|language| language.name());
955 match language_name.as_deref() {
956 Some("Plain Text") => "plaintext".to_string(),
957 Some(language_name) => language_name.to_lowercase(),
958 None => "plaintext".to_string(),
959 }
960}
961
962fn uri_for_buffer(buffer: &Model<Buffer>, cx: &AppContext) -> lsp::Url {
963 if let Some(file) = buffer.read(cx).file().and_then(|file| file.as_local()) {
964 lsp::Url::from_file_path(file.abs_path(cx)).unwrap()
965 } else {
966 format!("buffer://{}", buffer.entity_id()).parse().unwrap()
967 }
968}
969
970async fn clear_copilot_dir() {
971 remove_matching(&paths::COPILOT_DIR, |_| true).await
972}
973
974async fn get_copilot_lsp(http: Arc<dyn HttpClient>) -> anyhow::Result<PathBuf> {
975 const SERVER_PATH: &'static str = "dist/agent.js";
976
977 ///Check for the latest copilot language server and download it if we haven't already
978 async fn fetch_latest(http: Arc<dyn HttpClient>) -> anyhow::Result<PathBuf> {
979 let release =
980 latest_github_release("zed-industries/copilot", true, false, http.clone()).await?;
981
982 let version_dir = &*paths::COPILOT_DIR.join(format!("copilot-{}", release.name));
983
984 fs::create_dir_all(version_dir).await?;
985 let server_path = version_dir.join(SERVER_PATH);
986
987 if fs::metadata(&server_path).await.is_err() {
988 // Copilot LSP looks for this dist dir specifically, so lets add it in.
989 let dist_dir = version_dir.join("dist");
990 fs::create_dir_all(dist_dir.as_path()).await?;
991
992 let url = &release
993 .assets
994 .get(0)
995 .context("Github release for copilot contained no assets")?
996 .browser_download_url;
997
998 let mut response = http
999 .get(url, Default::default(), true)
1000 .await
1001 .context("error downloading copilot release")?;
1002 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
1003 let archive = Archive::new(decompressed_bytes);
1004 archive.unpack(dist_dir).await?;
1005
1006 remove_matching(&paths::COPILOT_DIR, |entry| entry != version_dir).await;
1007 }
1008
1009 Ok(server_path)
1010 }
1011
1012 match fetch_latest(http).await {
1013 ok @ Result::Ok(..) => ok,
1014 e @ Err(..) => {
1015 e.log_err();
1016 // Fetch a cached binary, if it exists
1017 async_maybe!({
1018 let mut last_version_dir = None;
1019 let mut entries = fs::read_dir(paths::COPILOT_DIR.as_path()).await?;
1020 while let Some(entry) = entries.next().await {
1021 let entry = entry?;
1022 if entry.file_type().await?.is_dir() {
1023 last_version_dir = Some(entry.path());
1024 }
1025 }
1026 let last_version_dir =
1027 last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
1028 let server_path = last_version_dir.join(SERVER_PATH);
1029 if server_path.exists() {
1030 Ok(server_path)
1031 } else {
1032 Err(anyhow!(
1033 "missing executable in directory {:?}",
1034 last_version_dir
1035 ))
1036 }
1037 })
1038 .await
1039 }
1040 }
1041}
1042
1043#[cfg(test)]
1044mod tests {
1045 use super::*;
1046 use gpui::TestAppContext;
1047 use language::BufferId;
1048
1049 #[gpui::test(iterations = 10)]
1050 async fn test_buffer_management(cx: &mut TestAppContext) {
1051 let (copilot, mut lsp) = Copilot::fake(cx);
1052
1053 let buffer_1 = cx.new_model(|cx| {
1054 Buffer::new(0, BufferId::new(cx.entity_id().as_u64()).unwrap(), "Hello")
1055 });
1056 let buffer_1_uri: lsp::Url = format!("buffer://{}", buffer_1.entity_id().as_u64())
1057 .parse()
1058 .unwrap();
1059 copilot.update(cx, |copilot, cx| copilot.register_buffer(&buffer_1, cx));
1060 assert_eq!(
1061 lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1062 .await,
1063 lsp::DidOpenTextDocumentParams {
1064 text_document: lsp::TextDocumentItem::new(
1065 buffer_1_uri.clone(),
1066 "plaintext".into(),
1067 0,
1068 "Hello".into()
1069 ),
1070 }
1071 );
1072
1073 let buffer_2 = cx.new_model(|cx| {
1074 Buffer::new(
1075 0,
1076 BufferId::new(cx.entity_id().as_u64()).unwrap(),
1077 "Goodbye",
1078 )
1079 });
1080 let buffer_2_uri: lsp::Url = format!("buffer://{}", buffer_2.entity_id().as_u64())
1081 .parse()
1082 .unwrap();
1083 copilot.update(cx, |copilot, cx| copilot.register_buffer(&buffer_2, cx));
1084 assert_eq!(
1085 lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1086 .await,
1087 lsp::DidOpenTextDocumentParams {
1088 text_document: lsp::TextDocumentItem::new(
1089 buffer_2_uri.clone(),
1090 "plaintext".into(),
1091 0,
1092 "Goodbye".into()
1093 ),
1094 }
1095 );
1096
1097 buffer_1.update(cx, |buffer, cx| buffer.edit([(5..5, " world")], None, cx));
1098 assert_eq!(
1099 lsp.receive_notification::<lsp::notification::DidChangeTextDocument>()
1100 .await,
1101 lsp::DidChangeTextDocumentParams {
1102 text_document: lsp::VersionedTextDocumentIdentifier::new(buffer_1_uri.clone(), 1),
1103 content_changes: vec![lsp::TextDocumentContentChangeEvent {
1104 range: Some(lsp::Range::new(
1105 lsp::Position::new(0, 5),
1106 lsp::Position::new(0, 5)
1107 )),
1108 range_length: None,
1109 text: " world".into(),
1110 }],
1111 }
1112 );
1113
1114 // Ensure updates to the file are reflected in the LSP.
1115 buffer_1.update(cx, |buffer, cx| {
1116 buffer.file_updated(
1117 Arc::new(File {
1118 abs_path: "/root/child/buffer-1".into(),
1119 path: Path::new("child/buffer-1").into(),
1120 }),
1121 cx,
1122 )
1123 });
1124 assert_eq!(
1125 lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1126 .await,
1127 lsp::DidCloseTextDocumentParams {
1128 text_document: lsp::TextDocumentIdentifier::new(buffer_1_uri),
1129 }
1130 );
1131 let buffer_1_uri = lsp::Url::from_file_path("/root/child/buffer-1").unwrap();
1132 assert_eq!(
1133 lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1134 .await,
1135 lsp::DidOpenTextDocumentParams {
1136 text_document: lsp::TextDocumentItem::new(
1137 buffer_1_uri.clone(),
1138 "plaintext".into(),
1139 1,
1140 "Hello world".into()
1141 ),
1142 }
1143 );
1144
1145 // Ensure all previously-registered buffers are closed when signing out.
1146 lsp.handle_request::<request::SignOut, _, _>(|_, _| async {
1147 Ok(request::SignOutResult {})
1148 });
1149 copilot
1150 .update(cx, |copilot, cx| copilot.sign_out(cx))
1151 .await
1152 .unwrap();
1153 assert_eq!(
1154 lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1155 .await,
1156 lsp::DidCloseTextDocumentParams {
1157 text_document: lsp::TextDocumentIdentifier::new(buffer_1_uri.clone()),
1158 }
1159 );
1160 assert_eq!(
1161 lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1162 .await,
1163 lsp::DidCloseTextDocumentParams {
1164 text_document: lsp::TextDocumentIdentifier::new(buffer_2_uri.clone()),
1165 }
1166 );
1167
1168 // Ensure all previously-registered buffers are re-opened when signing in.
1169 lsp.handle_request::<request::SignInInitiate, _, _>(|_, _| async {
1170 Ok(request::SignInInitiateResult::AlreadySignedIn {
1171 user: "user-1".into(),
1172 })
1173 });
1174 copilot
1175 .update(cx, |copilot, cx| copilot.sign_in(cx))
1176 .await
1177 .unwrap();
1178
1179 assert_eq!(
1180 lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1181 .await,
1182 lsp::DidOpenTextDocumentParams {
1183 text_document: lsp::TextDocumentItem::new(
1184 buffer_1_uri.clone(),
1185 "plaintext".into(),
1186 0,
1187 "Hello world".into()
1188 ),
1189 }
1190 );
1191 assert_eq!(
1192 lsp.receive_notification::<lsp::notification::DidOpenTextDocument>()
1193 .await,
1194 lsp::DidOpenTextDocumentParams {
1195 text_document: lsp::TextDocumentItem::new(
1196 buffer_2_uri.clone(),
1197 "plaintext".into(),
1198 0,
1199 "Goodbye".into()
1200 ),
1201 }
1202 );
1203 // Dropping a buffer causes it to be closed on the LSP side as well.
1204 cx.update(|_| drop(buffer_2));
1205 assert_eq!(
1206 lsp.receive_notification::<lsp::notification::DidCloseTextDocument>()
1207 .await,
1208 lsp::DidCloseTextDocumentParams {
1209 text_document: lsp::TextDocumentIdentifier::new(buffer_2_uri),
1210 }
1211 );
1212 }
1213
1214 struct File {
1215 abs_path: PathBuf,
1216 path: Arc<Path>,
1217 }
1218
1219 impl language::File for File {
1220 fn as_local(&self) -> Option<&dyn language::LocalFile> {
1221 Some(self)
1222 }
1223
1224 fn mtime(&self) -> std::time::SystemTime {
1225 unimplemented!()
1226 }
1227
1228 fn path(&self) -> &Arc<Path> {
1229 &self.path
1230 }
1231
1232 fn full_path(&self, _: &AppContext) -> PathBuf {
1233 unimplemented!()
1234 }
1235
1236 fn file_name<'a>(&'a self, _: &'a AppContext) -> &'a std::ffi::OsStr {
1237 unimplemented!()
1238 }
1239
1240 fn is_deleted(&self) -> bool {
1241 unimplemented!()
1242 }
1243
1244 fn as_any(&self) -> &dyn std::any::Any {
1245 unimplemented!()
1246 }
1247
1248 fn to_proto(&self) -> rpc::proto::File {
1249 unimplemented!()
1250 }
1251
1252 fn worktree_id(&self) -> usize {
1253 0
1254 }
1255
1256 fn is_private(&self) -> bool {
1257 false
1258 }
1259 }
1260
1261 impl language::LocalFile for File {
1262 fn abs_path(&self, _: &AppContext) -> PathBuf {
1263 self.abs_path.clone()
1264 }
1265
1266 fn load(&self, _: &AppContext) -> Task<Result<String>> {
1267 unimplemented!()
1268 }
1269
1270 fn buffer_reloaded(
1271 &self,
1272 _: BufferId,
1273 _: &clock::Global,
1274 _: language::RopeFingerprint,
1275 _: language::LineEnding,
1276 _: std::time::SystemTime,
1277 _: &mut AppContext,
1278 ) {
1279 unimplemented!()
1280 }
1281 }
1282}