WIP: remoting (#10085)

Release Notes:

- Added private alpha support for remote development. Please reach out to hi@zed.dev if you'd like to be part of shaping this feature.

crates/collab/.env.toml

@@ -1,5 +1,5 @@
 DATABASE_URL = "postgres://postgres@localhost/zed"
-# DATABASE_URL = "sqlite:////home/zed/.config/zed/db.sqlite3?mode=rwc"
+# DATABASE_URL = "sqlite:////root/0/zed/db.sqlite3?mode=rwc"
 DATABASE_MAX_CONNECTIONS = 5
 HTTP_PORT = 8080
 API_TOKEN = "secret"

crates/collab/Cargo.toml

@@ -63,8 +63,8 @@ tokio.workspace = true
 toml.workspace = true
 tower = "0.4"
 tower-http = { workspace = true, features = ["trace"] }
-tracing = "0.1.34"
-tracing-subscriber = { version = "0.3.11", features = ["env-filter", "json", "registry", "tracing-log"] }
+tracing = "0.1.40"
+tracing-subscriber = { git = "https://github.com/tokio-rs/tracing", rev = "tracing-subscriber-0.3.18", features = ["env-filter", "json", "registry", "tracing-log"] } # workaround for https://github.com/tokio-rs/tracing/issues/2927
 util.workspace = true
 uuid.workspace = true
 
@@ -102,3 +102,4 @@ theme.workspace = true
 unindent.workspace = true
 util.workspace = true
 workspace = { workspace = true, features = ["test-support"] }
+headless.workspace = true

crates/collab/migrations.sqlite/20221109000000_test_schema.sql

@@ -45,12 +45,13 @@ CREATE UNIQUE INDEX "index_rooms_on_channel_id" ON "rooms" ("channel_id");
 
 CREATE TABLE "projects" (
     "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-    "room_id" INTEGER REFERENCES rooms (id) ON DELETE CASCADE NOT NULL,
+    "room_id" INTEGER REFERENCES rooms (id) ON DELETE CASCADE,
     "host_user_id" INTEGER REFERENCES users (id),
     "host_connection_id" INTEGER,
     "host_connection_server_id" INTEGER REFERENCES servers (id) ON DELETE CASCADE,
     "unregistered" BOOLEAN NOT NULL DEFAULT FALSE,
-    "hosted_project_id" INTEGER REFERENCES hosted_projects (id)
+    "hosted_project_id" INTEGER REFERENCES hosted_projects (id),
+    "remote_project_id" INTEGER REFERENCES remote_projects(id)
 );
 CREATE INDEX "index_projects_on_host_connection_server_id" ON "projects" ("host_connection_server_id");
 CREATE INDEX "index_projects_on_host_connection_id_and_host_connection_server_id" ON "projects" ("host_connection_id", "host_connection_server_id");
@@ -397,7 +398,9 @@ CREATE TABLE hosted_projects (
     channel_id INTEGER NOT NULL REFERENCES channels(id),
     name TEXT NOT NULL,
     visibility TEXT NOT NULL,
-    deleted_at TIMESTAMP NULL
+    deleted_at TIMESTAMP NULL,
+    dev_server_id INTEGER REFERENCES dev_servers(id),
+    dev_server_path TEXT
 );
 CREATE INDEX idx_hosted_projects_on_channel_id ON hosted_projects (channel_id);
 CREATE UNIQUE INDEX uix_hosted_projects_on_channel_id_and_name ON hosted_projects (channel_id, name) WHERE (deleted_at IS NULL);
@@ -409,3 +412,13 @@ CREATE TABLE dev_servers (
     hashed_token TEXT NOT NULL
 );
 CREATE INDEX idx_dev_servers_on_channel_id ON dev_servers (channel_id);
+
+CREATE TABLE remote_projects (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    channel_id INTEGER NOT NULL REFERENCES channels(id),
+    dev_server_id INTEGER NOT NULL REFERENCES dev_servers(id),
+    name TEXT NOT NULL,
+    path TEXT NOT NULL
+);
+
+ALTER TABLE hosted_projects ADD COLUMN remote_project_id INTEGER REFERENCES remote_projects(id);

crates/collab/migrations/20240402155003_add_dev_server_projects.sql

@@ -0,0 +1,9 @@
+CREATE TABLE remote_projects (
+    id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
+    channel_id INT NOT NULL REFERENCES channels(id),
+    dev_server_id INT NOT NULL REFERENCES dev_servers(id),
+    name TEXT NOT NULL,
+    path TEXT NOT NULL
+);
+
+ALTER TABLE projects ADD COLUMN remote_project_id INTEGER REFERENCES remote_projects(id);

crates/collab/src/auth.rs

@@ -10,6 +10,7 @@ use axum::{
     response::IntoResponse,
 };
 use prometheus::{exponential_buckets, register_histogram, Histogram};
+pub use rpc::auth::random_token;
 use scrypt::{
     password_hash::{PasswordHash, PasswordVerifier},
     Scrypt,
@@ -152,7 +153,7 @@ pub async fn create_access_token(
 /// Hashing prevents anyone with access to the database being able to login.
 /// As the token is randomly generated, we don't need to worry about scrypt-style
 /// protection.
-fn hash_access_token(token: &str) -> String {
+pub fn hash_access_token(token: &str) -> String {
     let digest = sha2::Sha256::digest(token);
     format!(
         "$sha256${}",
@@ -230,18 +231,15 @@ pub async fn verify_access_token(
     })
 }
 
-// a dev_server_token has the format <id>.<base64>. This is to make them
-// relatively easy to copy/paste around.
+pub fn generate_dev_server_token(id: usize, access_token: String) -> String {
+    format!("{}.{}", id, access_token)
+}
+
 pub async fn verify_dev_server_token(
     dev_server_token: &str,
     db: &Arc<Database>,
 ) -> anyhow::Result<dev_server::Model> {
-    let mut parts = dev_server_token.splitn(2, '.');
-    let id = DevServerId(parts.next().unwrap_or_default().parse()?);
-    let token = parts
-        .next()
-        .ok_or_else(|| anyhow!("invalid dev server token format"))?;
-
+    let (id, token) = split_dev_server_token(dev_server_token)?;
     let token_hash = hash_access_token(&token);
     let server = db.get_dev_server(id).await?;
 
@@ -257,6 +255,17 @@ pub async fn verify_dev_server_token(
     }
 }
 
+// a dev_server_token has the format <id>.<base64>. This is to make them
+// relatively easy to copy/paste around.
+pub fn split_dev_server_token(dev_server_token: &str) -> anyhow::Result<(DevServerId, &str)> {
+    let mut parts = dev_server_token.splitn(2, '.');
+    let id = DevServerId(parts.next().unwrap_or_default().parse()?);
+    let token = parts
+        .next()
+        .ok_or_else(|| anyhow!("invalid dev server token format"))?;
+    Ok((id, token))
+}
+
 #[cfg(test)]
 mod test {
     use rand::thread_rng;

crates/collab/src/db.rs

@@ -56,6 +56,7 @@ pub struct Database {
     options: ConnectOptions,
     pool: DatabaseConnection,
     rooms: DashMap<RoomId, Arc<Mutex<()>>>,
+    projects: DashMap<ProjectId, Arc<Mutex<()>>>,
     rng: Mutex<StdRng>,
     executor: Executor,
     notification_kinds_by_id: HashMap<NotificationKindId, &'static str>,
@@ -74,6 +75,7 @@ impl Database {
             options: options.clone(),
             pool: sea_orm::Database::connect(options).await?,
             rooms: DashMap::with_capacity(16384),
+            projects: DashMap::with_capacity(16384),
             rng: Mutex::new(StdRng::seed_from_u64(0)),
             notification_kinds_by_id: HashMap::default(),
             notification_kinds_by_name: HashMap::default(),
@@ -86,6 +88,7 @@ impl Database {
     #[cfg(test)]
     pub fn reset(&self) {
         self.rooms.clear();
+        self.projects.clear();
     }
 
     /// Runs the database migrations.
@@ -190,7 +193,10 @@ impl Database {
     }
 
     /// The same as room_transaction, but if you need to only optionally return a Room.
-    async fn optional_room_transaction<F, Fut, T>(&self, f: F) -> Result<Option<RoomGuard<T>>>
+    async fn optional_room_transaction<F, Fut, T>(
+        &self,
+        f: F,
+    ) -> Result<Option<TransactionGuard<T>>>
     where
         F: Send + Fn(TransactionHandle) -> Fut,
         Fut: Send + Future<Output = Result<Option<(RoomId, T)>>>,
@@ -205,7 +211,7 @@ impl Database {
                         let _guard = lock.lock_owned().await;
                         match tx.commit().await.map_err(Into::into) {
                             Ok(()) => {
-                                return Ok(Some(RoomGuard {
+                                return Ok(Some(TransactionGuard {
                                     data,
                                     _guard,
                                     _not_send: PhantomData,
@@ -240,10 +246,63 @@ impl Database {
         self.run(body).await
     }
 
+    async fn project_transaction<F, Fut, T>(
+        &self,
+        project_id: ProjectId,
+        f: F,
+    ) -> Result<TransactionGuard<T>>
+    where
+        F: Send + Fn(TransactionHandle) -> Fut,
+        Fut: Send + Future<Output = Result<T>>,
+    {
+        let room_id = Database::room_id_for_project(&self, project_id).await?;
+        let body = async {
+            let mut i = 0;
+            loop {
+                let lock = if let Some(room_id) = room_id {
+                    self.rooms.entry(room_id).or_default().clone()
+                } else {
+                    self.projects.entry(project_id).or_default().clone()
+                };
+                let _guard = lock.lock_owned().await;
+                let (tx, result) = self.with_transaction(&f).await?;
+                match result {
+                    Ok(data) => match tx.commit().await.map_err(Into::into) {
+                        Ok(()) => {
+                            return Ok(TransactionGuard {
+                                data,
+                                _guard,
+                                _not_send: PhantomData,
+                            });
+                        }
+                        Err(error) => {
+                            if !self.retry_on_serialization_error(&error, i).await {
+                                return Err(error);
+                            }
+                        }
+                    },
+                    Err(error) => {
+                        tx.rollback().await?;
+                        if !self.retry_on_serialization_error(&error, i).await {
+                            return Err(error);
+                        }
+                    }
+                }
+                i += 1;
+            }
+        };
+
+        self.run(body).await
+    }
+
     /// room_transaction runs the block in a transaction. It returns a RoomGuard, that keeps
     /// the database locked until it is dropped. This ensures that updates sent to clients are
     /// properly serialized with respect to database changes.
-    async fn room_transaction<F, Fut, T>(&self, room_id: RoomId, f: F) -> Result<RoomGuard<T>>
+    async fn room_transaction<F, Fut, T>(
+        &self,
+        room_id: RoomId,
+        f: F,
+    ) -> Result<TransactionGuard<T>>
     where
         F: Send + Fn(TransactionHandle) -> Fut,
         Fut: Send + Future<Output = Result<T>>,
@@ -257,7 +316,7 @@ impl Database {
                 match result {
                     Ok(data) => match tx.commit().await.map_err(Into::into) {
                         Ok(()) => {
-                            return Ok(RoomGuard {
+                            return Ok(TransactionGuard {
                                 data,
                                 _guard,
                                 _not_send: PhantomData,
@@ -399,15 +458,16 @@ impl Deref for TransactionHandle {
     }
 }
 
-/// [`RoomGuard`] keeps a database transaction alive until it is dropped.
-/// so that updates to rooms are serialized.
-pub struct RoomGuard<T> {
+/// [`TransactionGuard`] keeps a database transaction alive until it is dropped.
+/// It wraps data that depends on the state of the database and prevents an additional
+/// transaction from starting that would invalidate that data.
+pub struct TransactionGuard<T> {
     data: T,
     _guard: OwnedMutexGuard<()>,
     _not_send: PhantomData<Rc<()>>,
 }
 
-impl<T> Deref for RoomGuard<T> {
+impl<T> Deref for TransactionGuard<T> {
     type Target = T;
 
     fn deref(&self) -> &T {
@@ -415,13 +475,13 @@ impl<T> Deref for RoomGuard<T> {
     }
 }
 
-impl<T> DerefMut for RoomGuard<T> {
+impl<T> DerefMut for TransactionGuard<T> {
     fn deref_mut(&mut self) -> &mut T {
         &mut self.data
     }
 }
 
-impl<T> RoomGuard<T> {
+impl<T> TransactionGuard<T> {
     /// Returns the inner value of the guard.
     pub fn into_inner(self) -> T {
         self.data
@@ -518,6 +578,7 @@ pub struct MembershipUpdated {
 
 /// The result of setting a member's role.
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub enum SetMemberRoleResult {
     InviteUpdated(Channel),
     MembershipUpdated(MembershipUpdated),
@@ -594,6 +655,8 @@ pub struct ChannelsForUser {
     pub channel_memberships: Vec<channel_member::Model>,
     pub channel_participants: HashMap<ChannelId, Vec<UserId>>,
     pub hosted_projects: Vec<proto::HostedProject>,
+    pub dev_servers: Vec<dev_server::Model>,
+    pub remote_projects: Vec<proto::RemoteProject>,
 
     pub observed_buffer_versions: Vec<proto::ChannelBufferVersion>,
     pub observed_channel_messages: Vec<proto::ChannelMessageId>,
@@ -635,6 +698,30 @@ pub struct RejoinedProject {
     pub language_servers: Vec<proto::LanguageServer>,
 }
 
+impl RejoinedProject {
+    pub fn to_proto(&self) -> proto::RejoinedProject {
+        proto::RejoinedProject {
+            id: self.id.to_proto(),
+            worktrees: self
+                .worktrees
+                .iter()
+                .map(|worktree| proto::WorktreeMetadata {
+                    id: worktree.id,
+                    root_name: worktree.root_name.clone(),
+                    visible: worktree.visible,
+                    abs_path: worktree.abs_path.clone(),
+                })
+                .collect(),
+            collaborators: self
+                .collaborators
+                .iter()
+                .map(|collaborator| collaborator.to_proto())
+                .collect(),
+            language_servers: self.language_servers.clone(),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct RejoinedWorktree {
     pub id: u64,

crates/collab/src/db/ids.rs

@@ -84,6 +84,7 @@ id_type!(NotificationId);
 id_type!(NotificationKindId);
 id_type!(ProjectCollaboratorId);
 id_type!(ProjectId);
+id_type!(RemoteProjectId);
 id_type!(ReplicaId);
 id_type!(RoomId);
 id_type!(RoomParticipantId);
@@ -270,3 +271,18 @@ impl Into<i32> for ChannelVisibility {
         proto.into()
     }
 }
+
+#[derive(Copy, Clone, Debug, Serialize, PartialEq)]
+pub enum PrincipalId {
+    UserId(UserId),
+    DevServerId(DevServerId),
+}
+
+/// Indicate whether a [Buffer] has permissions to edit.
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum Capability {
+    /// The buffer is a mutable replica.
+    ReadWrite,
+    /// The buffer is a read-only replica.
+    ReadOnly,
+}

crates/collab/src/db/queries.rs

@@ -12,6 +12,7 @@ pub mod messages;
 pub mod notifications;
 pub mod projects;
 pub mod rate_buckets;
+pub mod remote_projects;
 pub mod rooms;
 pub mod servers;
 pub mod users;

crates/collab/src/db/queries/channels.rs

@@ -640,10 +640,15 @@ impl Database {
             .get_hosted_projects(&channel_ids, &roles_by_channel_id, tx)
             .await?;
 
+        let dev_servers = self.get_dev_servers(&channel_ids, tx).await?;
+        let remote_projects = self.get_remote_projects(&channel_ids, tx).await?;
+
         Ok(ChannelsForUser {
             channel_memberships,
             channels,
             hosted_projects,
+            dev_servers,
+            remote_projects,
             channel_participants,
             latest_buffer_versions,
             latest_channel_messages,

crates/collab/src/db/queries/dev_servers.rs

@@ -1,6 +1,6 @@
-use sea_orm::EntityTrait;
+use sea_orm::{ActiveValue, ColumnTrait, DatabaseTransaction, EntityTrait, QueryFilter};
 
-use super::{dev_server, Database, DevServerId};
+use super::{channel, dev_server, ChannelId, Database, DevServerId, UserId};
 
 impl Database {
     pub async fn get_dev_server(
@@ -15,4 +15,42 @@ impl Database {
         })
         .await
     }
+
+    pub async fn get_dev_servers(
+        &self,
+        channel_ids: &Vec<ChannelId>,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<Vec<dev_server::Model>> {
+        let servers = dev_server::Entity::find()
+            .filter(dev_server::Column::ChannelId.is_in(channel_ids.iter().map(|id| id.0)))
+            .all(tx)
+            .await?;
+        Ok(servers)
+    }
+
+    pub async fn create_dev_server(
+        &self,
+        channel_id: ChannelId,
+        name: &str,
+        hashed_access_token: &str,
+        user_id: UserId,
+    ) -> crate::Result<(channel::Model, dev_server::Model)> {
+        self.transaction(|tx| async move {
+            let channel = self.get_channel_internal(channel_id, &tx).await?;
+            self.check_user_is_channel_admin(&channel, user_id, &tx)
+                .await?;
+
+            let dev_server = dev_server::Entity::insert(dev_server::ActiveModel {
+                id: ActiveValue::NotSet,
+                hashed_token: ActiveValue::Set(hashed_access_token.to_string()),
+                channel_id: ActiveValue::Set(channel_id),
+                name: ActiveValue::Set(name.to_string()),
+            })
+            .exec_with_returning(&*tx)
+            .await?;
+
+            Ok((channel, dev_server))
+        })
+        .await
+    }
 }

crates/collab/src/db/queries/projects.rs

@@ -1,3 +1,5 @@
+use util::ResultExt;
+
 use super::*;
 
 impl Database {
@@ -28,7 +30,7 @@ impl Database {
         room_id: RoomId,
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
-    ) -> Result<RoomGuard<(ProjectId, proto::Room)>> {
+    ) -> Result<TransactionGuard<(ProjectId, proto::Room)>> {
         self.room_transaction(room_id, |tx| async move {
             let participant = room_participant::Entity::find()
                 .filter(
@@ -65,6 +67,7 @@ impl Database {
                 ))),
                 id: ActiveValue::NotSet,
                 hosted_project_id: ActiveValue::Set(None),
+                remote_project_id: ActiveValue::Set(None),
             }
             .insert(&*tx)
             .await?;
@@ -108,20 +111,22 @@ impl Database {
         &self,
         project_id: ProjectId,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+    ) -> Result<TransactionGuard<(Option<proto::Room>, Vec<ConnectionId>)>> {
+        self.project_transaction(project_id, |tx| async move {
             let guest_connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
-
             let project = project::Entity::find_by_id(project_id)
                 .one(&*tx)
                 .await?
                 .ok_or_else(|| anyhow!("project not found"))?;
             if project.host_connection()? == connection {
+                let room = if let Some(room_id) = project.room_id {
+                    Some(self.get_room(room_id, &tx).await?)
+                } else {
+                    None
+                };
                 project::Entity::delete(project.into_active_model())
                     .exec(&*tx)
                     .await?;
-                let room = self.get_room(room_id, &tx).await?;
                 Ok((room, guest_connection_ids))
             } else {
                 Err(anyhow!("cannot unshare a project hosted by another user"))?
@@ -136,9 +141,8 @@ impl Database {
         project_id: ProjectId,
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
-    ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+    ) -> Result<TransactionGuard<(Option<proto::Room>, Vec<ConnectionId>)>> {
+        self.project_transaction(project_id, |tx| async move {
             let project = project::Entity::find_by_id(project_id)
                 .filter(
                     Condition::all()
@@ -154,12 +158,14 @@ impl Database {
             self.update_project_worktrees(project.id, worktrees, &tx)
                 .await?;
 
-            let room_id = project
-                .room_id
-                .ok_or_else(|| anyhow!("project not in a room"))?;
-
             let guest_connection_ids = self.project_guest_connection_ids(project.id, &tx).await?;
-            let room = self.get_room(room_id, &tx).await?;
+
+            let room = if let Some(room_id) = project.room_id {
+                Some(self.get_room(room_id, &tx).await?)
+            } else {
+                None
+            };
+
             Ok((room, guest_connection_ids))
         })
         .await
@@ -204,11 +210,10 @@ impl Database {
         &self,
         update: &proto::UpdateWorktree,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
+    ) -> Result<TransactionGuard<Vec<ConnectionId>>> {
         let project_id = ProjectId::from_proto(update.project_id);
         let worktree_id = update.worktree_id as i64;
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.project_transaction(project_id, |tx| async move {
             // Ensure the update comes from the host.
             let _project = project::Entity::find_by_id(project_id)
                 .filter(
@@ -360,11 +365,10 @@ impl Database {
         &self,
         update: &proto::UpdateDiagnosticSummary,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
+    ) -> Result<TransactionGuard<Vec<ConnectionId>>> {
         let project_id = ProjectId::from_proto(update.project_id);
         let worktree_id = update.worktree_id as i64;
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.project_transaction(project_id, |tx| async move {
             let summary = update
                 .summary
                 .as_ref()
@@ -415,10 +419,9 @@ impl Database {
         &self,
         update: &proto::StartLanguageServer,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
+    ) -> Result<TransactionGuard<Vec<ConnectionId>>> {
         let project_id = ProjectId::from_proto(update.project_id);
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.project_transaction(project_id, |tx| async move {
             let server = update
                 .server
                 .as_ref()
@@ -461,10 +464,9 @@ impl Database {
         &self,
         update: &proto::UpdateWorktreeSettings,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<Vec<ConnectionId>>> {
+    ) -> Result<TransactionGuard<Vec<ConnectionId>>> {
         let project_id = ProjectId::from_proto(update.project_id);
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        self.project_transaction(project_id, |tx| async move {
             // Ensure the update comes from the host.
             let project = project::Entity::find_by_id(project_id)
                 .one(&*tx)
@@ -542,46 +544,36 @@ impl Database {
         .await
     }
 
+    pub async fn get_project(&self, id: ProjectId) -> Result<project::Model> {
+        self.transaction(|tx| async move {
+            Ok(project::Entity::find_by_id(id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?)
+        })
+        .await
+    }
+
     /// Adds the given connection to the specified project
     /// in the current room.
-    pub async fn join_project_in_room(
+    pub async fn join_project(
         &self,
         project_id: ProjectId,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<(Project, ReplicaId)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
-            let participant = room_participant::Entity::find()
-                .filter(
-                    Condition::all()
-                        .add(
-                            room_participant::Column::AnsweringConnectionId
-                                .eq(connection.id as i32),
-                        )
-                        .add(
-                            room_participant::Column::AnsweringConnectionServerId
-                                .eq(connection.owner_id as i32),
-                        ),
+        user_id: UserId,
+    ) -> Result<TransactionGuard<(Project, ReplicaId)>> {
+        self.project_transaction(project_id, |tx| async move {
+            let (project, role) = self
+                .access_project(
+                    project_id,
+                    connection,
+                    PrincipalId::UserId(user_id),
+                    Capability::ReadOnly,
+                    &tx,
                 )
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("must join a room first"))?;
-
-            let project = project::Entity::find_by_id(project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such project"))?;
-            if project.room_id != Some(participant.room_id) {
-                return Err(anyhow!("no such project"))?;
-            }
-            self.join_project_internal(
-                project,
-                participant.user_id,
-                connection,
-                participant.role.unwrap_or(ChannelRole::Member),
-                &tx,
-            )
-            .await
+                .await?;
+            self.join_project_internal(project, user_id, connection, role, &tx)
+                .await
         })
         .await
     }
@@ -814,9 +806,8 @@ impl Database {
         &self,
         project_id: ProjectId,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<(proto::Room, LeftProject)>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+    ) -> Result<TransactionGuard<(Option<proto::Room>, LeftProject)>> {
+        self.project_transaction(project_id, |tx| async move {
             let result = project_collaborator::Entity::delete_many()
                 .filter(
                     Condition::all()
@@ -871,7 +862,12 @@ impl Database {
                 .exec(&*tx)
                 .await?;
 
-            let room = self.get_room(room_id, &tx).await?;
+            let room = if let Some(room_id) = project.room_id {
+                Some(self.get_room(room_id, &tx).await?)
+            } else {
+                None
+            };
+
             let left_project = LeftProject {
                 id: project_id,
                 host_user_id: project.host_user_id,
@@ -888,17 +884,15 @@ impl Database {
         project_id: ProjectId,
         connection_id: ConnectionId,
     ) -> Result<()> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
-            project_collaborator::Entity::find()
+        self.project_transaction(project_id, |tx| async move {
+            project::Entity::find()
                 .filter(
                     Condition::all()
-                        .add(project_collaborator::Column::ProjectId.eq(project_id))
-                        .add(project_collaborator::Column::IsHost.eq(true))
-                        .add(project_collaborator::Column::ConnectionId.eq(connection_id.id))
+                        .add(project::Column::Id.eq(project_id))
+                        .add(project::Column::HostConnectionId.eq(Some(connection_id.id as i32)))
                         .add(
-                            project_collaborator::Column::ConnectionServerId
-                                .eq(connection_id.owner_id),
+                            project::Column::HostConnectionServerId
+                                .eq(Some(connection_id.owner_id as i32)),
                         ),
                 )
                 .one(&*tx)
@@ -911,39 +905,90 @@ impl Database {
         .map(|guard| guard.into_inner())
     }
 
+    /// Returns the current project if the given user is authorized to access it with the specified capability.
+    pub async fn access_project(
+        &self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+        principal_id: PrincipalId,
+        capability: Capability,
+        tx: &DatabaseTransaction,
+    ) -> Result<(project::Model, ChannelRole)> {
+        let (project, remote_project) = project::Entity::find_by_id(project_id)
+            .find_also_related(remote_project::Entity)
+            .one(tx)
+            .await?
+            .ok_or_else(|| anyhow!("no such project"))?;
+
+        let user_id = match principal_id {
+            PrincipalId::DevServerId(_) => {
+                if project
+                    .host_connection()
+                    .is_ok_and(|connection| connection == connection_id)
+                {
+                    return Ok((project, ChannelRole::Admin));
+                }
+                return Err(anyhow!("not the project host"))?;
+            }
+            PrincipalId::UserId(user_id) => user_id,
+        };
+
+        let role = if let Some(remote_project) = remote_project {
+            let channel = channel::Entity::find_by_id(remote_project.channel_id)
+                .one(tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such channel"))?;
+
+            self.check_user_is_channel_participant(&channel, user_id, &tx)
+                .await?
+        } else if let Some(room_id) = project.room_id {
+            // what's the users role?
+            let current_participant = room_participant::Entity::find()
+                .filter(room_participant::Column::RoomId.eq(room_id))
+                .filter(room_participant::Column::AnsweringConnectionId.eq(connection_id.id))
+                .one(tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such room"))?;
+
+            current_participant.role.unwrap_or(ChannelRole::Guest)
+        } else {
+            return Err(anyhow!("not authorized to read projects"))?;
+        };
+
+        match capability {
+            Capability::ReadWrite => {
+                if !role.can_edit_projects() {
+                    return Err(anyhow!("not authorized to edit projects"))?;
+                }
+            }
+            Capability::ReadOnly => {
+                if !role.can_read_projects() {
+                    return Err(anyhow!("not authorized to read projects"))?;
+                }
+            }
+        }
+
+        Ok((project, role))
+    }
+
     /// Returns the host connection for a read-only request to join a shared project.
     pub async fn host_for_read_only_project_request(
         &self,
         project_id: ProjectId,
         connection_id: ConnectionId,
+        user_id: UserId,
     ) -> Result<ConnectionId> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
-            let current_participant = room_participant::Entity::find()
-                .filter(room_participant::Column::RoomId.eq(room_id))
-                .filter(room_participant::Column::AnsweringConnectionId.eq(connection_id.id))
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such room"))?;
-
-            if !current_participant
-                .role
-                .map_or(false, |role| role.can_read_projects())
-            {
-                Err(anyhow!("not authorized to read projects"))?;
-            }
-
-            let host = project_collaborator::Entity::find()
-                .filter(
-                    project_collaborator::Column::ProjectId
-                        .eq(project_id)
-                        .and(project_collaborator::Column::IsHost.eq(true)),
+        self.project_transaction(project_id, |tx| async move {
+            let (project, _) = self
+                .access_project(
+                    project_id,
+                    connection_id,
+                    PrincipalId::UserId(user_id),
+                    Capability::ReadOnly,
+                    &tx,
                 )
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("failed to read project host"))?;
-
-            Ok(host.connection())
+                .await?;
+            project.host_connection()
         })
         .await
         .map(|guard| guard.into_inner())
@@ -954,83 +999,56 @@ impl Database {
         &self,
         project_id: ProjectId,
         connection_id: ConnectionId,
+        user_id: UserId,
     ) -> Result<ConnectionId> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
-            let current_participant = room_participant::Entity::find()
-                .filter(room_participant::Column::RoomId.eq(room_id))
-                .filter(room_participant::Column::AnsweringConnectionId.eq(connection_id.id))
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such room"))?;
-
-            if !current_participant
-                .role
-                .map_or(false, |role| role.can_edit_projects())
-            {
-                Err(anyhow!("not authorized to edit projects"))?;
-            }
-
-            let host = project_collaborator::Entity::find()
-                .filter(
-                    project_collaborator::Column::ProjectId
-                        .eq(project_id)
-                        .and(project_collaborator::Column::IsHost.eq(true)),
+        self.project_transaction(project_id, |tx| async move {
+            let (project, _) = self
+                .access_project(
+                    project_id,
+                    connection_id,
+                    PrincipalId::UserId(user_id),
+                    Capability::ReadWrite,
+                    &tx,
                 )
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("failed to read project host"))?;
-
-            Ok(host.connection())
+                .await?;
+            project.host_connection()
         })
         .await
         .map(|guard| guard.into_inner())
     }
 
-    pub async fn project_collaborators_for_buffer_update(
+    pub async fn connections_for_buffer_update(
         &self,
         project_id: ProjectId,
+        principal_id: PrincipalId,
         connection_id: ConnectionId,
-        requires_write: bool,
-    ) -> Result<RoomGuard<Vec<ProjectCollaborator>>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
-            let current_participant = room_participant::Entity::find()
-                .filter(room_participant::Column::RoomId.eq(room_id))
-                .filter(room_participant::Column::AnsweringConnectionId.eq(connection_id.id))
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such room"))?;
+        capability: Capability,
+    ) -> Result<TransactionGuard<(ConnectionId, Vec<ConnectionId>)>> {
+        self.project_transaction(project_id, |tx| async move {
+            // Authorize
+            let (project, _) = self
+                .access_project(project_id, connection_id, principal_id, capability, &tx)
+                .await?;
 
-            if requires_write
-                && !current_participant
-                    .role
-                    .map_or(false, |role| role.can_edit_projects())
-            {
-                Err(anyhow!("not authorized to edit projects"))?;
-            }
+            let host_connection_id = project.host_connection()?;
 
             let collaborators = project_collaborator::Entity::find()
                 .filter(project_collaborator::Column::ProjectId.eq(project_id))
                 .all(&*tx)
-                .await?
-                .into_iter()
-                .map(|collaborator| ProjectCollaborator {
-                    connection_id: collaborator.connection(),
-                    user_id: collaborator.user_id,
-                    replica_id: collaborator.replica_id,
-                    is_host: collaborator.is_host,
-                })
-                .collect::<Vec<_>>();
+                .await?;
 
-            if collaborators
-                .iter()
-                .any(|collaborator| collaborator.connection_id == connection_id)
-            {
-                Ok(collaborators)
-            } else {
-                Err(anyhow!("no such project"))?
-            }
+            let guest_connection_ids = collaborators
+                .into_iter()
+                .filter_map(|collaborator| {
+                    if collaborator.is_host {
+                        None
+                    } else {
+                        Some(collaborator.connection())
+                    }
+                })
+                .collect();
+
+            Ok((host_connection_id, guest_connection_ids))
         })
         .await
     }
@@ -1043,24 +1061,39 @@ impl Database {
         &self,
         project_id: ProjectId,
         connection_id: ConnectionId,
-    ) -> Result<RoomGuard<HashSet<ConnectionId>>> {
-        let room_id = self.room_id_for_project(project_id).await?;
-        self.room_transaction(room_id, |tx| async move {
+        exclude_dev_server: bool,
+    ) -> Result<TransactionGuard<HashSet<ConnectionId>>> {
+        self.project_transaction(project_id, |tx| async move {
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
+
             let mut collaborators = project_collaborator::Entity::find()
                 .filter(project_collaborator::Column::ProjectId.eq(project_id))
                 .stream(&*tx)
                 .await?;
 
             let mut connection_ids = HashSet::default();
+            if let Some(host_connection) = project.host_connection().log_err() {
+                if !exclude_dev_server {
+                    connection_ids.insert(host_connection);
+                }
+            }
+
             while let Some(collaborator) = collaborators.next().await {
                 let collaborator = collaborator?;
                 connection_ids.insert(collaborator.connection());
             }
 
-            if connection_ids.contains(&connection_id) {
+            if connection_ids.contains(&connection_id)
+                || Some(connection_id) == project.host_connection().ok()
+            {
                 Ok(connection_ids)
             } else {
-                Err(anyhow!("no such project"))?
+                Err(anyhow!(
+                    "can only send project updates to a project you're in"
+                ))?
             }
         })
         .await
@@ -1089,15 +1122,12 @@ impl Database {
     }
 
     /// Returns the [`RoomId`] for the given project.
-    pub async fn room_id_for_project(&self, project_id: ProjectId) -> Result<RoomId> {
+    pub async fn room_id_for_project(&self, project_id: ProjectId) -> Result<Option<RoomId>> {
         self.transaction(|tx| async move {
-            let project = project::Entity::find_by_id(project_id)
+            Ok(project::Entity::find_by_id(project_id)
                 .one(&*tx)
                 .await?
-                .ok_or_else(|| anyhow!("project {} not found", project_id))?;
-            Ok(project
-                .room_id
-                .ok_or_else(|| anyhow!("project not in room"))?)
+                .and_then(|project| project.room_id))
         })
         .await
     }
@@ -1142,7 +1172,7 @@ impl Database {
         project_id: ProjectId,
         leader_connection: ConnectionId,
         follower_connection: ConnectionId,
-    ) -> Result<RoomGuard<proto::Room>> {
+    ) -> Result<TransactionGuard<proto::Room>> {
         self.room_transaction(room_id, |tx| async move {
             follower::ActiveModel {
                 room_id: ActiveValue::set(room_id),
@@ -1173,7 +1203,7 @@ impl Database {
         project_id: ProjectId,
         leader_connection: ConnectionId,
         follower_connection: ConnectionId,
-    ) -> Result<RoomGuard<proto::Room>> {
+    ) -> Result<TransactionGuard<proto::Room>> {
         self.room_transaction(room_id, |tx| async move {
             follower::Entity::delete_many()
                 .filter(

crates/collab/src/db/queries/remote_projects.rs

@@ -0,0 +1,261 @@
+use anyhow::anyhow;
+use rpc::{proto, ConnectionId};
+use sea_orm::{
+    ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, EntityTrait,
+    ModelTrait, QueryFilter,
+};
+
+use crate::db::ProjectId;
+
+use super::{
+    channel, project, project_collaborator, remote_project, worktree, ChannelId, Database,
+    DevServerId, RejoinedProject, RemoteProjectId, ResharedProject, ServerId, UserId,
+};
+
+impl Database {
+    pub async fn get_remote_project(
+        &self,
+        remote_project_id: RemoteProjectId,
+    ) -> crate::Result<remote_project::Model> {
+        self.transaction(|tx| async move {
+            Ok(remote_project::Entity::find_by_id(remote_project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no remote project with id {}", remote_project_id))?)
+        })
+        .await
+    }
+
+    pub async fn get_remote_projects(
+        &self,
+        channel_ids: &Vec<ChannelId>,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<Vec<proto::RemoteProject>> {
+        let servers = remote_project::Entity::find()
+            .filter(remote_project::Column::ChannelId.is_in(channel_ids.iter().map(|id| id.0)))
+            .find_also_related(project::Entity)
+            .all(tx)
+            .await?;
+        Ok(servers
+            .into_iter()
+            .map(|(remote_project, project)| proto::RemoteProject {
+                id: remote_project.id.to_proto(),
+                project_id: project.map(|p| p.id.to_proto()),
+                channel_id: remote_project.channel_id.to_proto(),
+                name: remote_project.name,
+                dev_server_id: remote_project.dev_server_id.to_proto(),
+                path: remote_project.path,
+            })
+            .collect())
+    }
+
+    pub async fn get_remote_projects_for_dev_server(
+        &self,
+        dev_server_id: DevServerId,
+    ) -> crate::Result<Vec<proto::RemoteProject>> {
+        self.transaction(|tx| async move {
+            let servers = remote_project::Entity::find()
+                .filter(remote_project::Column::DevServerId.eq(dev_server_id))
+                .find_also_related(project::Entity)
+                .all(&*tx)
+                .await?;
+            Ok(servers
+                .into_iter()
+                .map(|(remote_project, project)| proto::RemoteProject {
+                    id: remote_project.id.to_proto(),
+                    project_id: project.map(|p| p.id.to_proto()),
+                    channel_id: remote_project.channel_id.to_proto(),
+                    name: remote_project.name,
+                    dev_server_id: remote_project.dev_server_id.to_proto(),
+                    path: remote_project.path,
+                })
+                .collect())
+        })
+        .await
+    }
+
+    pub async fn get_stale_dev_server_projects(
+        &self,
+        connection: ConnectionId,
+    ) -> crate::Result<Vec<ProjectId>> {
+        self.transaction(|tx| async move {
+            let projects = project::Entity::find()
+                .filter(
+                    Condition::all()
+                        .add(project::Column::HostConnectionId.eq(connection.id))
+                        .add(project::Column::HostConnectionServerId.eq(connection.owner_id)),
+                )
+                .all(&*tx)
+                .await?;
+
+            Ok(projects.into_iter().map(|p| p.id).collect())
+        })
+        .await
+    }
+
+    pub async fn create_remote_project(
+        &self,
+        channel_id: ChannelId,
+        dev_server_id: DevServerId,
+        name: &str,
+        path: &str,
+        user_id: UserId,
+    ) -> crate::Result<(channel::Model, remote_project::Model)> {
+        self.transaction(|tx| async move {
+            let channel = self.get_channel_internal(channel_id, &tx).await?;
+            self.check_user_is_channel_admin(&channel, user_id, &tx)
+                .await?;
+
+            let project = remote_project::Entity::insert(remote_project::ActiveModel {
+                name: ActiveValue::Set(name.to_string()),
+                id: ActiveValue::NotSet,
+                channel_id: ActiveValue::Set(channel_id),
+                dev_server_id: ActiveValue::Set(dev_server_id),
+                path: ActiveValue::Set(path.to_string()),
+            })
+            .exec_with_returning(&*tx)
+            .await?;
+
+            Ok((channel, project))
+        })
+        .await
+    }
+
+    pub async fn share_remote_project(
+        &self,
+        remote_project_id: RemoteProjectId,
+        dev_server_id: DevServerId,
+        connection: ConnectionId,
+        worktrees: &[proto::WorktreeMetadata],
+    ) -> crate::Result<proto::RemoteProject> {
+        self.transaction(|tx| async move {
+            let remote_project = remote_project::Entity::find_by_id(remote_project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no remote project with id {}", remote_project_id))?;
+
+            if remote_project.dev_server_id != dev_server_id {
+                return Err(anyhow!("remote project shared from wrong server"))?;
+            }
+
+            let project = project::ActiveModel {
+                room_id: ActiveValue::Set(None),
+                host_user_id: ActiveValue::Set(None),
+                host_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                host_connection_server_id: ActiveValue::set(Some(ServerId(
+                    connection.owner_id as i32,
+                ))),
+                id: ActiveValue::NotSet,
+                hosted_project_id: ActiveValue::Set(None),
+                remote_project_id: ActiveValue::Set(Some(remote_project_id)),
+            }
+            .insert(&*tx)
+            .await?;
+
+            if !worktrees.is_empty() {
+                worktree::Entity::insert_many(worktrees.iter().map(|worktree| {
+                    worktree::ActiveModel {
+                        id: ActiveValue::set(worktree.id as i64),
+                        project_id: ActiveValue::set(project.id),
+                        abs_path: ActiveValue::set(worktree.abs_path.clone()),
+                        root_name: ActiveValue::set(worktree.root_name.clone()),
+                        visible: ActiveValue::set(worktree.visible),
+                        scan_id: ActiveValue::set(0),
+                        completed_scan_id: ActiveValue::set(0),
+                    }
+                }))
+                .exec(&*tx)
+                .await?;
+            }
+
+            Ok(remote_project.to_proto(Some(project)))
+        })
+        .await
+    }
+
+    pub async fn reshare_remote_projects(
+        &self,
+        reshared_projects: &Vec<proto::UpdateProject>,
+        dev_server_id: DevServerId,
+        connection: ConnectionId,
+    ) -> crate::Result<Vec<ResharedProject>> {
+        // todo!() project_transaction? (maybe we can make the lock per-dev-server instead of per-project?)
+        self.transaction(|tx| async move {
+            let mut ret = Vec::new();
+            for reshared_project in reshared_projects {
+                let project_id = ProjectId::from_proto(reshared_project.project_id);
+                let (project, remote_project) = project::Entity::find_by_id(project_id)
+                    .find_also_related(remote_project::Entity)
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| anyhow!("project does not exist"))?;
+
+                if remote_project.map(|rp| rp.dev_server_id) != Some(dev_server_id) {
+                    return Err(anyhow!("remote project reshared from wrong server"))?;
+                }
+
+                let Ok(old_connection_id) = project.host_connection() else {
+                    return Err(anyhow!("remote project was not shared"))?;
+                };
+
+                project::Entity::update(project::ActiveModel {
+                    id: ActiveValue::set(project_id),
+                    host_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                    host_connection_server_id: ActiveValue::set(Some(ServerId(
+                        connection.owner_id as i32,
+                    ))),
+                    ..Default::default()
+                })
+                .exec(&*tx)
+                .await?;
+
+                let collaborators = project
+                    .find_related(project_collaborator::Entity)
+                    .all(&*tx)
+                    .await?;
+
+                self.update_project_worktrees(project_id, &reshared_project.worktrees, &tx)
+                    .await?;
+
+                ret.push(super::ResharedProject {
+                    id: project_id,
+                    old_connection_id,
+                    collaborators: collaborators
+                        .iter()
+                        .map(|collaborator| super::ProjectCollaborator {
+                            connection_id: collaborator.connection(),
+                            user_id: collaborator.user_id,
+                            replica_id: collaborator.replica_id,
+                            is_host: collaborator.is_host,
+                        })
+                        .collect(),
+                    worktrees: reshared_project.worktrees.clone(),
+                });
+            }
+            Ok(ret)
+        })
+        .await
+    }
+
+    pub async fn rejoin_remote_projects(
+        &self,
+        rejoined_projects: &Vec<proto::RejoinProject>,
+        user_id: UserId,
+        connection_id: ConnectionId,
+    ) -> crate::Result<Vec<RejoinedProject>> {
+        // todo!() project_transaction? (maybe we can make the lock per-dev-server instead of per-project?)
+        self.transaction(|tx| async move {
+            let mut ret = Vec::new();
+            for rejoined_project in rejoined_projects {
+                if let Some(project) = self
+                    .rejoin_project_internal(&tx, rejoined_project, user_id, connection_id)
+                    .await?
+                {
+                    ret.push(project);
+                }
+            }
+            Ok(ret)
+        })
+        .await
+    }
+}

crates/collab/src/db/queries/rooms.rs

@@ -6,7 +6,7 @@ impl Database {
         &self,
         room_id: RoomId,
         new_server_id: ServerId,
-    ) -> Result<RoomGuard<RefreshedRoom>> {
+    ) -> Result<TransactionGuard<RefreshedRoom>> {
         self.room_transaction(room_id, |tx| async move {
             let stale_participant_filter = Condition::all()
                 .add(room_participant::Column::RoomId.eq(room_id))
@@ -149,7 +149,7 @@ impl Database {
         calling_connection: ConnectionId,
         called_user_id: UserId,
         initial_project_id: Option<ProjectId>,
-    ) -> Result<RoomGuard<(proto::Room, proto::IncomingCall)>> {
+    ) -> Result<TransactionGuard<(proto::Room, proto::IncomingCall)>> {
         self.room_transaction(room_id, |tx| async move {
             let caller = room_participant::Entity::find()
                 .filter(
@@ -201,7 +201,7 @@ impl Database {
         &self,
         room_id: RoomId,
         called_user_id: UserId,
-    ) -> Result<RoomGuard<proto::Room>> {
+    ) -> Result<TransactionGuard<proto::Room>> {
         self.room_transaction(room_id, |tx| async move {
             room_participant::Entity::delete_many()
                 .filter(
@@ -221,7 +221,7 @@ impl Database {
         &self,
         expected_room_id: Option<RoomId>,
         user_id: UserId,
-    ) -> Result<Option<RoomGuard<proto::Room>>> {
+    ) -> Result<Option<TransactionGuard<proto::Room>>> {
         self.optional_room_transaction(|tx| async move {
             let mut filter = Condition::all()
                 .add(room_participant::Column::UserId.eq(user_id))
@@ -258,7 +258,7 @@ impl Database {
         room_id: RoomId,
         calling_connection: ConnectionId,
         called_user_id: UserId,
-    ) -> Result<RoomGuard<proto::Room>> {
+    ) -> Result<TransactionGuard<proto::Room>> {
         self.room_transaction(room_id, |tx| async move {
             let participant = room_participant::Entity::find()
                 .filter(
@@ -294,7 +294,7 @@ impl Database {
         room_id: RoomId,
         user_id: UserId,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<JoinRoom>> {
+    ) -> Result<TransactionGuard<JoinRoom>> {
         self.room_transaction(room_id, |tx| async move {
             #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
             enum QueryChannelId {
@@ -472,7 +472,7 @@ impl Database {
         rejoin_room: proto::RejoinRoom,
         user_id: UserId,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<RejoinedRoom>> {
+    ) -> Result<TransactionGuard<RejoinedRoom>> {
         let room_id = RoomId::from_proto(rejoin_room.id);
         self.room_transaction(room_id, |tx| async {
             let tx = tx;
@@ -572,180 +572,12 @@ impl Database {
 
             let mut rejoined_projects = Vec::new();
             for rejoined_project in &rejoin_room.rejoined_projects {
-                let project_id = ProjectId::from_proto(rejoined_project.id);
-                let Some(project) = project::Entity::find_by_id(project_id).one(&*tx).await? else {
-                    continue;
-                };
-
-                let mut worktrees = Vec::new();
-                let db_worktrees = project.find_related(worktree::Entity).all(&*tx).await?;
-                for db_worktree in db_worktrees {
-                    let mut worktree = RejoinedWorktree {
-                        id: db_worktree.id as u64,
-                        abs_path: db_worktree.abs_path,
-                        root_name: db_worktree.root_name,
-                        visible: db_worktree.visible,
-                        updated_entries: Default::default(),
-                        removed_entries: Default::default(),
-                        updated_repositories: Default::default(),
-                        removed_repositories: Default::default(),
-                        diagnostic_summaries: Default::default(),
-                        settings_files: Default::default(),
-                        scan_id: db_worktree.scan_id as u64,
-                        completed_scan_id: db_worktree.completed_scan_id as u64,
-                    };
-
-                    let rejoined_worktree = rejoined_project
-                        .worktrees
-                        .iter()
-                        .find(|worktree| worktree.id == db_worktree.id as u64);
-
-                    // File entries
-                    {
-                        let entry_filter = if let Some(rejoined_worktree) = rejoined_worktree {
-                            worktree_entry::Column::ScanId.gt(rejoined_worktree.scan_id)
-                        } else {
-                            worktree_entry::Column::IsDeleted.eq(false)
-                        };
-
-                        let mut db_entries = worktree_entry::Entity::find()
-                            .filter(
-                                Condition::all()
-                                    .add(worktree_entry::Column::ProjectId.eq(project.id))
-                                    .add(worktree_entry::Column::WorktreeId.eq(worktree.id))
-                                    .add(entry_filter),
-                            )
-                            .stream(&*tx)
-                            .await?;
-
-                        while let Some(db_entry) = db_entries.next().await {
-                            let db_entry = db_entry?;
-                            if db_entry.is_deleted {
-                                worktree.removed_entries.push(db_entry.id as u64);
-                            } else {
-                                worktree.updated_entries.push(proto::Entry {
-                                    id: db_entry.id as u64,
-                                    is_dir: db_entry.is_dir,
-                                    path: db_entry.path,
-                                    inode: db_entry.inode as u64,
-                                    mtime: Some(proto::Timestamp {
-                                        seconds: db_entry.mtime_seconds as u64,
-                                        nanos: db_entry.mtime_nanos as u32,
-                                    }),
-                                    is_symlink: db_entry.is_symlink,
-                                    is_ignored: db_entry.is_ignored,
-                                    is_external: db_entry.is_external,
-                                    git_status: db_entry.git_status.map(|status| status as i32),
-                                });
-                            }
-                        }
-                    }
-
-                    // Repository Entries
-                    {
-                        let repository_entry_filter =
-                            if let Some(rejoined_worktree) = rejoined_worktree {
-                                worktree_repository::Column::ScanId.gt(rejoined_worktree.scan_id)
-                            } else {
-                                worktree_repository::Column::IsDeleted.eq(false)
-                            };
-
-                        let mut db_repositories = worktree_repository::Entity::find()
-                            .filter(
-                                Condition::all()
-                                    .add(worktree_repository::Column::ProjectId.eq(project.id))
-                                    .add(worktree_repository::Column::WorktreeId.eq(worktree.id))
-                                    .add(repository_entry_filter),
-                            )
-                            .stream(&*tx)
-                            .await?;
-
-                        while let Some(db_repository) = db_repositories.next().await {
-                            let db_repository = db_repository?;
-                            if db_repository.is_deleted {
-                                worktree
-                                    .removed_repositories
-                                    .push(db_repository.work_directory_id as u64);
-                            } else {
-                                worktree.updated_repositories.push(proto::RepositoryEntry {
-                                    work_directory_id: db_repository.work_directory_id as u64,
-                                    branch: db_repository.branch,
-                                });
-                            }
-                        }
-                    }
-
-                    worktrees.push(worktree);
-                }
-
-                let language_servers = project
-                    .find_related(language_server::Entity)
-                    .all(&*tx)
+                if let Some(rejoined_project) = self
+                    .rejoin_project_internal(&tx, rejoined_project, user_id, connection)
                     .await?
-                    .into_iter()
-                    .map(|language_server| proto::LanguageServer {
-                        id: language_server.id as u64,
-                        name: language_server.name,
-                    })
-                    .collect::<Vec<_>>();
-
                 {
-                    let mut db_settings_files = worktree_settings_file::Entity::find()
-                        .filter(worktree_settings_file::Column::ProjectId.eq(project_id))
-                        .stream(&*tx)
-                        .await?;
-                    while let Some(db_settings_file) = db_settings_files.next().await {
-                        let db_settings_file = db_settings_file?;
-                        if let Some(worktree) = worktrees
-                            .iter_mut()
-                            .find(|w| w.id == db_settings_file.worktree_id as u64)
-                        {
-                            worktree.settings_files.push(WorktreeSettingsFile {
-                                path: db_settings_file.path,
-                                content: db_settings_file.content,
-                            });
-                        }
-                    }
+                    rejoined_projects.push(rejoined_project);
                 }
-
-                let mut collaborators = project
-                    .find_related(project_collaborator::Entity)
-                    .all(&*tx)
-                    .await?;
-                let self_collaborator = if let Some(self_collaborator_ix) = collaborators
-                    .iter()
-                    .position(|collaborator| collaborator.user_id == user_id)
-                {
-                    collaborators.swap_remove(self_collaborator_ix)
-                } else {
-                    continue;
-                };
-                let old_connection_id = self_collaborator.connection();
-                project_collaborator::Entity::update(project_collaborator::ActiveModel {
-                    connection_id: ActiveValue::set(connection.id as i32),
-                    connection_server_id: ActiveValue::set(ServerId(connection.owner_id as i32)),
-                    ..self_collaborator.into_active_model()
-                })
-                .exec(&*tx)
-                .await?;
-
-                let collaborators = collaborators
-                    .into_iter()
-                    .map(|collaborator| ProjectCollaborator {
-                        connection_id: collaborator.connection(),
-                        user_id: collaborator.user_id,
-                        replica_id: collaborator.replica_id,
-                        is_host: collaborator.is_host,
-                    })
-                    .collect::<Vec<_>>();
-
-                rejoined_projects.push(RejoinedProject {
-                    id: project_id,
-                    old_connection_id,
-                    collaborators,
-                    worktrees,
-                    language_servers,
-                });
             }
 
             let (channel, room) = self.get_channel_room(room_id, &tx).await?;
@@ -760,10 +592,192 @@ impl Database {
         .await
     }
 
+    pub async fn rejoin_project_internal(
+        &self,
+        tx: &DatabaseTransaction,
+        rejoined_project: &proto::RejoinProject,
+        user_id: UserId,
+        connection: ConnectionId,
+    ) -> Result<Option<RejoinedProject>> {
+        let project_id = ProjectId::from_proto(rejoined_project.id);
+        let Some(project) = project::Entity::find_by_id(project_id).one(tx).await? else {
+            return Ok(None);
+        };
+
+        let mut worktrees = Vec::new();
+        let db_worktrees = project.find_related(worktree::Entity).all(tx).await?;
+        for db_worktree in db_worktrees {
+            let mut worktree = RejoinedWorktree {
+                id: db_worktree.id as u64,
+                abs_path: db_worktree.abs_path,
+                root_name: db_worktree.root_name,
+                visible: db_worktree.visible,
+                updated_entries: Default::default(),
+                removed_entries: Default::default(),
+                updated_repositories: Default::default(),
+                removed_repositories: Default::default(),
+                diagnostic_summaries: Default::default(),
+                settings_files: Default::default(),
+                scan_id: db_worktree.scan_id as u64,
+                completed_scan_id: db_worktree.completed_scan_id as u64,
+            };
+
+            let rejoined_worktree = rejoined_project
+                .worktrees
+                .iter()
+                .find(|worktree| worktree.id == db_worktree.id as u64);
+
+            // File entries
+            {
+                let entry_filter = if let Some(rejoined_worktree) = rejoined_worktree {
+                    worktree_entry::Column::ScanId.gt(rejoined_worktree.scan_id)
+                } else {
+                    worktree_entry::Column::IsDeleted.eq(false)
+                };
+
+                let mut db_entries = worktree_entry::Entity::find()
+                    .filter(
+                        Condition::all()
+                            .add(worktree_entry::Column::ProjectId.eq(project.id))
+                            .add(worktree_entry::Column::WorktreeId.eq(worktree.id))
+                            .add(entry_filter),
+                    )
+                    .stream(tx)
+                    .await?;
+
+                while let Some(db_entry) = db_entries.next().await {
+                    let db_entry = db_entry?;
+                    if db_entry.is_deleted {
+                        worktree.removed_entries.push(db_entry.id as u64);
+                    } else {
+                        worktree.updated_entries.push(proto::Entry {
+                            id: db_entry.id as u64,
+                            is_dir: db_entry.is_dir,
+                            path: db_entry.path,
+                            inode: db_entry.inode as u64,
+                            mtime: Some(proto::Timestamp {
+                                seconds: db_entry.mtime_seconds as u64,
+                                nanos: db_entry.mtime_nanos as u32,
+                            }),
+                            is_symlink: db_entry.is_symlink,
+                            is_ignored: db_entry.is_ignored,
+                            is_external: db_entry.is_external,
+                            git_status: db_entry.git_status.map(|status| status as i32),
+                        });
+                    }
+                }
+            }
+
+            // Repository Entries
+            {
+                let repository_entry_filter = if let Some(rejoined_worktree) = rejoined_worktree {
+                    worktree_repository::Column::ScanId.gt(rejoined_worktree.scan_id)
+                } else {
+                    worktree_repository::Column::IsDeleted.eq(false)
+                };
+
+                let mut db_repositories = worktree_repository::Entity::find()
+                    .filter(
+                        Condition::all()
+                            .add(worktree_repository::Column::ProjectId.eq(project.id))
+                            .add(worktree_repository::Column::WorktreeId.eq(worktree.id))
+                            .add(repository_entry_filter),
+                    )
+                    .stream(tx)
+                    .await?;
+
+                while let Some(db_repository) = db_repositories.next().await {
+                    let db_repository = db_repository?;
+                    if db_repository.is_deleted {
+                        worktree
+                            .removed_repositories
+                            .push(db_repository.work_directory_id as u64);
+                    } else {
+                        worktree.updated_repositories.push(proto::RepositoryEntry {
+                            work_directory_id: db_repository.work_directory_id as u64,
+                            branch: db_repository.branch,
+                        });
+                    }
+                }
+            }
+
+            worktrees.push(worktree);
+        }
+
+        let language_servers = project
+            .find_related(language_server::Entity)
+            .all(tx)
+            .await?
+            .into_iter()
+            .map(|language_server| proto::LanguageServer {
+                id: language_server.id as u64,
+                name: language_server.name,
+            })
+            .collect::<Vec<_>>();
+
+        {
+            let mut db_settings_files = worktree_settings_file::Entity::find()
+                .filter(worktree_settings_file::Column::ProjectId.eq(project_id))
+                .stream(tx)
+                .await?;
+            while let Some(db_settings_file) = db_settings_files.next().await {
+                let db_settings_file = db_settings_file?;
+                if let Some(worktree) = worktrees
+                    .iter_mut()
+                    .find(|w| w.id == db_settings_file.worktree_id as u64)
+                {
+                    worktree.settings_files.push(WorktreeSettingsFile {
+                        path: db_settings_file.path,
+                        content: db_settings_file.content,
+                    });
+                }
+            }
+        }
+
+        let mut collaborators = project
+            .find_related(project_collaborator::Entity)
+            .all(tx)
+            .await?;
+        let self_collaborator = if let Some(self_collaborator_ix) = collaborators
+            .iter()
+            .position(|collaborator| collaborator.user_id == user_id)
+        {
+            collaborators.swap_remove(self_collaborator_ix)
+        } else {
+            return Ok(None);
+        };
+        let old_connection_id = self_collaborator.connection();
+        project_collaborator::Entity::update(project_collaborator::ActiveModel {
+            connection_id: ActiveValue::set(connection.id as i32),
+            connection_server_id: ActiveValue::set(ServerId(connection.owner_id as i32)),
+            ..self_collaborator.into_active_model()
+        })
+        .exec(tx)
+        .await?;
+
+        let collaborators = collaborators
+            .into_iter()
+            .map(|collaborator| ProjectCollaborator {
+                connection_id: collaborator.connection(),
+                user_id: collaborator.user_id,
+                replica_id: collaborator.replica_id,
+                is_host: collaborator.is_host,
+            })
+            .collect::<Vec<_>>();
+
+        return Ok(Some(RejoinedProject {
+            id: project_id,
+            old_connection_id,
+            collaborators,
+            worktrees,
+            language_servers,
+        }));
+    }
+
     pub async fn leave_room(
         &self,
         connection: ConnectionId,
-    ) -> Result<Option<RoomGuard<LeftRoom>>> {
+    ) -> Result<Option<TransactionGuard<LeftRoom>>> {
         self.optional_room_transaction(|tx| async move {
             let leaving_participant = room_participant::Entity::find()
                 .filter(
@@ -935,7 +949,7 @@ impl Database {
         room_id: RoomId,
         connection: ConnectionId,
         location: proto::ParticipantLocation,
-    ) -> Result<RoomGuard<proto::Room>> {
+    ) -> Result<TransactionGuard<proto::Room>> {
         self.room_transaction(room_id, |tx| async {
             let tx = tx;
             let location_kind;
@@ -997,7 +1011,7 @@ impl Database {
         room_id: RoomId,
         user_id: UserId,
         role: ChannelRole,
-    ) -> Result<RoomGuard<proto::Room>> {
+    ) -> Result<TransactionGuard<proto::Room>> {
         self.room_transaction(room_id, |tx| async move {
             room_participant::Entity::find()
                 .filter(
@@ -1150,7 +1164,7 @@ impl Database {
         &self,
         room_id: RoomId,
         connection_id: ConnectionId,
-    ) -> Result<RoomGuard<HashSet<ConnectionId>>> {
+    ) -> Result<TransactionGuard<HashSet<ConnectionId>>> {
         self.room_transaction(room_id, |tx| async move {
             let mut participants = room_participant::Entity::find()
                 .filter(room_participant::Column::RoomId.eq(room_id))

crates/collab/src/db/tables.rs

@@ -24,6 +24,7 @@ pub mod observed_channel_messages;
 pub mod project;
 pub mod project_collaborator;
 pub mod rate_buckets;
+pub mod remote_project;
 pub mod room;
 pub mod room_participant;
 pub mod server;

crates/collab/src/db/tables/dev_server.rs

@@ -1,4 +1,5 @@
 use crate::db::{ChannelId, DevServerId};
+use rpc::proto;
 use sea_orm::entity::prelude::*;
 
 #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
@@ -15,3 +16,14 @@ impl ActiveModelBehavior for ActiveModel {}
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
 pub enum Relation {}
+
+impl Model {
+    pub fn to_proto(&self, status: proto::DevServerStatus) -> proto::DevServer {
+        proto::DevServer {
+            dev_server_id: self.id.to_proto(),
+            channel_id: self.channel_id.to_proto(),
+            name: self.name.clone(),
+            status: status as i32,
+        }
+    }
+}

crates/collab/src/db/tables/project.rs

@@ -1,4 +1,4 @@
-use crate::db::{HostedProjectId, ProjectId, Result, RoomId, ServerId, UserId};
+use crate::db::{HostedProjectId, ProjectId, RemoteProjectId, Result, RoomId, ServerId, UserId};
 use anyhow::anyhow;
 use rpc::ConnectionId;
 use sea_orm::entity::prelude::*;
@@ -13,6 +13,7 @@ pub struct Model {
     pub host_connection_id: Option<i32>,
     pub host_connection_server_id: Option<ServerId>,
     pub hosted_project_id: Option<HostedProjectId>,
+    pub remote_project_id: Option<RemoteProjectId>,
 }
 
 impl Model {
@@ -56,6 +57,12 @@ pub enum Relation {
         to = "super::hosted_project::Column::Id"
     )]
     HostedProject,
+    #[sea_orm(
+        belongs_to = "super::remote_project::Entity",
+        from = "Column::RemoteProjectId",
+        to = "super::remote_project::Column::Id"
+    )]
+    RemoteProject,
 }
 
 impl Related<super::user::Entity> for Entity {
@@ -94,4 +101,10 @@ impl Related<super::hosted_project::Entity> for Entity {
     }
 }
 
+impl Related<super::remote_project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::RemoteProject.def()
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/db/tables/remote_project.rs

@@ -0,0 +1,42 @@
+use super::project;
+use crate::db::{ChannelId, DevServerId, RemoteProjectId};
+use rpc::proto;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "remote_projects")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: RemoteProjectId,
+    pub channel_id: ChannelId,
+    pub dev_server_id: DevServerId,
+    pub name: String,
+    pub path: String,
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_one = "super::project::Entity")]
+    Project,
+}
+
+impl Related<super::project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Project.def()
+    }
+}
+
+impl Model {
+    pub fn to_proto(&self, project: Option<project::Model>) -> proto::RemoteProject {
+        proto::RemoteProject {
+            id: self.id.to_proto(),
+            project_id: project.map(|p| p.id.to_proto()),
+            channel_id: self.channel_id.to_proto(),
+            dev_server_id: self.dev_server_id.to_proto(),
+            name: self.name.clone(),
+            path: self.path.clone(),
+        }
+    }
+}

crates/collab/src/rpc/connection_pool.rs

@@ -1,7 +1,7 @@
-use crate::db::{ChannelId, ChannelRole, UserId};
+use crate::db::{ChannelId, ChannelRole, DevServerId, PrincipalId, UserId};
 use anyhow::{anyhow, Result};
 use collections::{BTreeMap, HashMap, HashSet};
-use rpc::ConnectionId;
+use rpc::{proto, ConnectionId};
 use semantic_version::SemanticVersion;
 use serde::Serialize;
 use std::fmt;
@@ -10,12 +10,13 @@ use tracing::instrument;
 #[derive(Default, Serialize)]
 pub struct ConnectionPool {
     connections: BTreeMap<ConnectionId, Connection>,
-    connected_users: BTreeMap<UserId, ConnectedUser>,
+    connected_users: BTreeMap<UserId, ConnectedPrincipal>,
+    connected_dev_servers: BTreeMap<DevServerId, ConnectionId>,
     channels: ChannelPool,
 }
 
 #[derive(Default, Serialize)]
-struct ConnectedUser {
+struct ConnectedPrincipal {
     connection_ids: HashSet<ConnectionId>,
 }
 
@@ -36,7 +37,7 @@ impl ZedVersion {
 
 #[derive(Serialize)]
 pub struct Connection {
-    pub user_id: UserId,
+    pub principal_id: PrincipalId,
     pub admin: bool,
     pub zed_version: ZedVersion,
 }
@@ -59,7 +60,7 @@ impl ConnectionPool {
         self.connections.insert(
             connection_id,
             Connection {
-                user_id,
+                principal_id: PrincipalId::UserId(user_id),
                 admin,
                 zed_version,
             },
@@ -68,6 +69,25 @@ impl ConnectionPool {
         connected_user.connection_ids.insert(connection_id);
     }
 
+    pub fn add_dev_server(
+        &mut self,
+        connection_id: ConnectionId,
+        dev_server_id: DevServerId,
+        zed_version: ZedVersion,
+    ) {
+        self.connections.insert(
+            connection_id,
+            Connection {
+                principal_id: PrincipalId::DevServerId(dev_server_id),
+                admin: false,
+                zed_version,
+            },
+        );
+
+        self.connected_dev_servers
+            .insert(dev_server_id, connection_id);
+    }
+
     #[instrument(skip(self))]
     pub fn remove_connection(&mut self, connection_id: ConnectionId) -> Result<()> {
         let connection = self
@@ -75,12 +95,18 @@ impl ConnectionPool {
             .get_mut(&connection_id)
             .ok_or_else(|| anyhow!("no such connection"))?;
 
-        let user_id = connection.user_id;
-        let connected_user = self.connected_users.get_mut(&user_id).unwrap();
-        connected_user.connection_ids.remove(&connection_id);
-        if connected_user.connection_ids.is_empty() {
-            self.connected_users.remove(&user_id);
-            self.channels.remove_user(&user_id);
+        match connection.principal_id {
+            PrincipalId::UserId(user_id) => {
+                let connected_user = self.connected_users.get_mut(&user_id).unwrap();
+                connected_user.connection_ids.remove(&connection_id);
+                if connected_user.connection_ids.is_empty() {
+                    self.connected_users.remove(&user_id);
+                    self.channels.remove_user(&user_id);
+                }
+            }
+            PrincipalId::DevServerId(dev_server_id) => {
+                self.connected_dev_servers.remove(&dev_server_id);
+            }
         }
         self.connections.remove(&connection_id).unwrap();
         Ok(())
@@ -110,6 +136,18 @@ impl ConnectionPool {
             .copied()
     }
 
+    pub fn dev_server_status(&self, dev_server_id: DevServerId) -> proto::DevServerStatus {
+        if self.dev_server_connection_id(dev_server_id).is_some() {
+            proto::DevServerStatus::Online
+        } else {
+            proto::DevServerStatus::Offline
+        }
+    }
+
+    pub fn dev_server_connection_id(&self, dev_server_id: DevServerId) -> Option<ConnectionId> {
+        self.connected_dev_servers.get(&dev_server_id).copied()
+    }
+
     pub fn channel_user_ids(
         &self,
         channel_id: ChannelId,
@@ -154,22 +192,39 @@ impl ConnectionPool {
     #[cfg(test)]
     pub fn check_invariants(&self) {
         for (connection_id, connection) in &self.connections {
-            assert!(self
-                .connected_users
-                .get(&connection.user_id)
-                .unwrap()
-                .connection_ids
-                .contains(connection_id));
+            match &connection.principal_id {
+                PrincipalId::UserId(user_id) => {
+                    assert!(self
+                        .connected_users
+                        .get(user_id)
+                        .unwrap()
+                        .connection_ids
+                        .contains(connection_id));
+                }
+                PrincipalId::DevServerId(dev_server_id) => {
+                    assert_eq!(
+                        self.connected_dev_servers.get(&dev_server_id).unwrap(),
+                        connection_id
+                    );
+                }
+            }
         }
 
         for (user_id, state) in &self.connected_users {
             for connection_id in &state.connection_ids {
                 assert_eq!(
-                    self.connections.get(connection_id).unwrap().user_id,
-                    *user_id
+                    self.connections.get(connection_id).unwrap().principal_id,
+                    PrincipalId::UserId(*user_id)
                 );
             }
         }
+
+        for (dev_server_id, connection_id) in &self.connected_dev_servers {
+            assert_eq!(
+                self.connections.get(connection_id).unwrap().principal_id,
+                PrincipalId::DevServerId(*dev_server_id)
+            );
+        }
     }
 }
 

crates/collab/src/tests.rs

@@ -8,6 +8,7 @@ mod channel_buffer_tests;
 mod channel_guest_tests;
 mod channel_message_tests;
 mod channel_tests;
+mod dev_server_tests;
 mod editor_tests;
 mod following_tests;
 mod integration_tests;

crates/collab/src/tests/dev_server_tests.rs

@@ -0,0 +1,110 @@
+use std::path::Path;
+
+use editor::Editor;
+use fs::Fs;
+use gpui::VisualTestContext;
+use rpc::proto::DevServerStatus;
+use serde_json::json;
+
+use crate::tests::TestServer;
+
+#[gpui::test]
+async fn test_dev_server(cx: &mut gpui::TestAppContext, cx2: &mut gpui::TestAppContext) {
+    let (server, client) = TestServer::start1(cx).await;
+
+    let channel_id = server
+        .make_channel("test", None, (&client, cx), &mut [])
+        .await;
+
+    let resp = client
+        .channel_store()
+        .update(cx, |store, cx| {
+            store.create_dev_server(channel_id, "server-1".to_string(), cx)
+        })
+        .await
+        .unwrap();
+
+    client.channel_store().update(cx, |store, _| {
+        assert_eq!(store.dev_servers_for_id(channel_id).len(), 1);
+        assert_eq!(store.dev_servers_for_id(channel_id)[0].name, "server-1");
+        assert_eq!(
+            store.dev_servers_for_id(channel_id)[0].status,
+            DevServerStatus::Offline
+        );
+    });
+
+    let dev_server = server.create_dev_server(resp.access_token, cx2).await;
+    cx.executor().run_until_parked();
+    client.channel_store().update(cx, |store, _| {
+        assert_eq!(
+            store.dev_servers_for_id(channel_id)[0].status,
+            DevServerStatus::Online
+        );
+    });
+
+    dev_server
+        .fs()
+        .insert_tree(
+            "/remote",
+            json!({
+                "1.txt": "remote\nremote\nremote",
+                "2.js": "function two() { return 2; }",
+                "3.rs": "mod test",
+            }),
+        )
+        .await;
+
+    client
+        .channel_store()
+        .update(cx, |store, cx| {
+            store.create_remote_project(
+                channel_id,
+                client::DevServerId(resp.dev_server_id),
+                "project-1".to_string(),
+                "/remote".to_string(),
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+
+    cx.executor().run_until_parked();
+
+    let remote_workspace = client
+        .channel_store()
+        .update(cx, |store, cx| {
+            let projects = store.remote_projects_for_id(channel_id);
+            assert_eq!(projects.len(), 1);
+            assert_eq!(projects[0].name, "project-1");
+            workspace::join_remote_project(
+                projects[0].project_id.unwrap(),
+                client.app_state.clone(),
+                cx,
+            )
+        })
+        .await
+        .unwrap();
+
+    cx.executor().run_until_parked();
+
+    let cx2 = VisualTestContext::from_window(remote_workspace.into(), cx).as_mut();
+    cx2.simulate_keystrokes("cmd-p 1 enter");
+
+    let editor = remote_workspace
+        .update(cx2, |ws, cx| {
+            ws.active_item_as::<Editor>(cx).unwrap().clone()
+        })
+        .unwrap();
+    editor.update(cx2, |ed, cx| {
+        assert_eq!(ed.text(cx).to_string(), "remote\nremote\nremote");
+    });
+    cx2.simulate_input("wow!");
+    cx2.simulate_keystrokes("cmd-s");
+
+    let content = dev_server
+        .fs()
+        .load(&Path::new("/remote/1.txt"))
+        .await
+        .unwrap();
+    assert_eq!(content, "wow!remote\nremote\nremote\n");
+}

crates/collab/src/tests/integration_tests.rs

@@ -3760,7 +3760,7 @@ async fn test_leaving_project(
 
     // Client B can't join the project, unless they re-join the room.
     cx_b.spawn(|cx| {
-        Project::remote(
+        Project::in_room(
             project_id,
             client_b.app_state.client.clone(),
             client_b.user_store().clone(),

crates/collab/src/tests/test_server.rs

@@ -1,4 +1,5 @@
 use crate::{
+    auth::split_dev_server_token,
     db::{tests::TestDb, NewUserParams, UserId},
     executor::Executor,
     rpc::{Principal, Server, ZedVersion, CLEANUP_TIMEOUT, RECONNECT_TIMEOUT},
@@ -302,6 +303,130 @@ impl TestServer {
         client
     }
 
+    pub async fn create_dev_server(
+        &self,
+        access_token: String,
+        cx: &mut TestAppContext,
+    ) -> TestClient {
+        cx.update(|cx| {
+            if cx.has_global::<SettingsStore>() {
+                panic!("Same cx used to create two test clients")
+            }
+            let settings = SettingsStore::test(cx);
+            cx.set_global(settings);
+            release_channel::init("0.0.0", cx);
+            client::init_settings(cx);
+        });
+        let (dev_server_id, _) = split_dev_server_token(&access_token).unwrap();
+
+        let clock = Arc::new(FakeSystemClock::default());
+        let http = FakeHttpClient::with_404_response();
+        let mut client = cx.update(|cx| Client::new(clock, http.clone(), cx));
+        let server = self.server.clone();
+        let db = self.app_state.db.clone();
+        let connection_killers = self.connection_killers.clone();
+        let forbid_connections = self.forbid_connections.clone();
+        Arc::get_mut(&mut client)
+            .unwrap()
+            .set_id(1)
+            .set_dev_server_token(client::DevServerToken(access_token.clone()))
+            .override_establish_connection(move |credentials, cx| {
+                assert_eq!(
+                    credentials,
+                    &Credentials::DevServer {
+                        token: client::DevServerToken(access_token.to_string())
+                    }
+                );
+
+                let server = server.clone();
+                let db = db.clone();
+                let connection_killers = connection_killers.clone();
+                let forbid_connections = forbid_connections.clone();
+                cx.spawn(move |cx| async move {
+                    if forbid_connections.load(SeqCst) {
+                        Err(EstablishConnectionError::other(anyhow!(
+                            "server is forbidding connections"
+                        )))
+                    } else {
+                        let (client_conn, server_conn, killed) =
+                            Connection::in_memory(cx.background_executor().clone());
+                        let (connection_id_tx, connection_id_rx) = oneshot::channel();
+                        let dev_server = db
+                            .get_dev_server(dev_server_id)
+                            .await
+                            .expect("retrieving dev_server failed");
+                        cx.background_executor()
+                            .spawn(server.handle_connection(
+                                server_conn,
+                                "dev-server".to_string(),
+                                Principal::DevServer(dev_server),
+                                ZedVersion(SemanticVersion::new(1, 0, 0)),
+                                Some(connection_id_tx),
+                                Executor::Deterministic(cx.background_executor().clone()),
+                            ))
+                            .detach();
+                        let connection_id = connection_id_rx.await.map_err(|e| {
+                            EstablishConnectionError::Other(anyhow!(
+                                "{} (is server shutting down?)",
+                                e
+                            ))
+                        })?;
+                        connection_killers
+                            .lock()
+                            .insert(connection_id.into(), killed);
+                        Ok(client_conn)
+                    }
+                })
+            });
+
+        let fs = FakeFs::new(cx.executor());
+        let user_store = cx.new_model(|cx| UserStore::new(client.clone(), cx));
+        let workspace_store = cx.new_model(|cx| WorkspaceStore::new(client.clone(), cx));
+        let language_registry = Arc::new(LanguageRegistry::test(cx.executor()));
+        let app_state = Arc::new(workspace::AppState {
+            client: client.clone(),
+            user_store: user_store.clone(),
+            workspace_store,
+            languages: language_registry,
+            fs: fs.clone(),
+            build_window_options: |_, _| Default::default(),
+            node_runtime: FakeNodeRuntime::new(),
+        });
+
+        cx.update(|cx| {
+            theme::init(theme::LoadThemes::JustBase, cx);
+            Project::init(&client, cx);
+            client::init(&client, cx);
+            language::init(cx);
+            editor::init(cx);
+            workspace::init(app_state.clone(), cx);
+            call::init(client.clone(), user_store.clone(), cx);
+            channel::init(&client, user_store.clone(), cx);
+            notifications::init(client.clone(), user_store, cx);
+            collab_ui::init(&app_state, cx);
+            file_finder::init(cx);
+            menu::init();
+            headless::init(
+                client.clone(),
+                headless::AppState {
+                    languages: app_state.languages.clone(),
+                    user_store: app_state.user_store.clone(),
+                    fs: fs.clone(),
+                    node_runtime: app_state.node_runtime.clone(),
+                },
+                cx,
+            );
+        });
+
+        TestClient {
+            app_state,
+            username: "dev-server".to_string(),
+            channel_store: cx.read(ChannelStore::global).clone(),
+            notification_store: cx.read(NotificationStore::global).clone(),
+            state: Default::default(),
+        }
+    }
+
     pub fn disconnect_client(&self, peer_id: PeerId) {
         self.connection_killers
             .lock()