0.42.0

Command palette filter

.github/workflows/ci.yml

@@ -18,7 +18,9 @@ env:
 jobs:
   tests:
     name: Run tests
-    runs-on: self-hosted
+    runs-on:
+      - self-hosted
+      - test
     env:
       RUSTFLAGS: -D warnings
     steps:
@@ -29,6 +31,11 @@ jobs:
           target: x86_64-apple-darwin
           profile: minimal
 
+      - name: Install Node
+        uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+
       - name: Checkout repo
         uses: actions/checkout@v2
         with:
@@ -36,10 +43,15 @@ jobs:
 
       - name: Run tests
         run: cargo test --workspace --no-fail-fast
+    
+      - name: Build collab binaries
+        run: cargo build --bins --all-features 
 
   bundle:
     name: Bundle app
-    runs-on: self-hosted
+    runs-on:
+      - self-hosted
+      - bundle
     env:
       MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
       MACOS_CERTIFICATE_PASSWORD: ${{ secrets.MACOS_CERTIFICATE_PASSWORD }}
@@ -60,6 +72,11 @@ jobs:
           target: aarch64-apple-darwin
           profile: minimal
 
+      - name: Install Node
+        uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+
       - name: Checkout repo
         uses: actions/checkout@v2
         with:

.gitignore

@@ -2,6 +2,8 @@
 /zed.xcworkspace
 .DS_Store
 /script/node_modules
-/crates/server/.env.toml
-/crates/server/static/styles.css
+/styles/node_modules
+/crates/collab/.env.toml
+/crates/collab/static/styles.css
 /vendor/bin
+/assets/themes/*.json

.zed.toml

@@ -1 +0,0 @@
-collaborators = ["nathansobo", "as-cii", "maxbrunsfeld", "iamnbutler"]

Cargo.toml

@@ -6,11 +6,11 @@ resolver = "2"
 [patch.crates-io]
 async-task = { git = "https://github.com/zed-industries/async-task", rev = "341b57d6de98cdfd7b418567b8de2022ca993a6e" }
 # TODO - Remove when a version is released with this PR: https://github.com/servo/core-foundation-rs/pull/457
-cocoa = { git = "https://github.com/servo/core-foundation-rs", rev = "025dcb3c0d1ef01530f57ef65f3b1deb948f5737" }
-cocoa-foundation = { git = "https://github.com/servo/core-foundation-rs", rev = "025dcb3c0d1ef01530f57ef65f3b1deb948f5737" }
-core-foundation = { git = "https://github.com/servo/core-foundation-rs", rev = "025dcb3c0d1ef01530f57ef65f3b1deb948f5737" }
-core-foundation-sys = { git = "https://github.com/servo/core-foundation-rs", rev = "025dcb3c0d1ef01530f57ef65f3b1deb948f5737" }
-core-graphics = { git = "https://github.com/servo/core-foundation-rs", rev = "025dcb3c0d1ef01530f57ef65f3b1deb948f5737" }
+cocoa = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
+cocoa-foundation = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
+core-foundation = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
+core-foundation-sys = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
+core-graphics = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
 
 [profile.dev]
 split-debuginfo = "unpacked"

Dockerfile

@@ -2,32 +2,22 @@
 
 FROM rust:1.58-bullseye as builder
 WORKDIR app
-RUN curl -fsSL https://deb.nodesource.com/setup_16.x | bash -
-RUN apt-get install -y nodejs
 COPY . .
 
-# Install script dependencies
-RUN --mount=type=cache,target=./script/node_modules \
-    cd ./script && npm install --quiet
-
-# Build CSS
-RUN --mount=type=cache,target=./script/node_modules \
-    script/build-css --release
-
-# Compile server
+# Compile collab server
 RUN --mount=type=cache,target=./script/node_modules \
     --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=./target \
-    cargo build --release --package zed-server --bin zed-server
+    cargo build --release --package collab --bin collab
 
-# Copy server binary out of cached directory
+# Copy collab server binary out of cached directory
 RUN --mount=type=cache,target=./target \
-    cp /app/target/release/zed-server /app/zed-server
+    cp /app/target/release/collab /app/collab
 
-# Copy server binary to the runtime image
+# Copy collab server binary to the runtime image
 FROM debian:bullseye-slim as runtime
 RUN apt-get update; \
     apt-get install -y --no-install-recommends libcurl4-openssl-dev ca-certificates
 WORKDIR app
-COPY --from=builder /app/zed-server /app
-ENTRYPOINT ["/app/zed-server"]
+COPY --from=builder /app/collab /app
+ENTRYPOINT ["/app/collab"]

Dockerfile.migrator

@@ -11,5 +11,5 @@ RUN apt-get update; \
     apt-get install -y --no-install-recommends libssl1.1
 WORKDIR app
 COPY --from=builder /app/bin/sqlx /app
-COPY ./server/migrations /app/migrations
+COPY ./crates/collab/migrations /app/migrations
 ENTRYPOINT ["/app/sqlx", "migrate", "run"]

Procfile

@@ -1,2 +1,2 @@
 web: cd ../zed.dev && PORT=3000 npx next dev
-collab: cd crates/server && cargo run
+collab: cd crates/collab && cargo run

README.md

@@ -23,7 +23,7 @@ script/sqlx migrate run
 script/seed-db
 ```
 
-Run `zed.dev` and the collaboration server.
+Run the web frontend and the collaboration server.
 
 ```
 brew install foreman

assets/icons/accept.svg

@@ -0,0 +1,3 @@
+<svg width="8" height="6" viewBox="0 0 8 6" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.25 1L3.25 5L1 2.75" stroke="white" stroke-width="1.33333"/>
+</svg>

assets/icons/add-contact.svg

@@ -0,0 +1,3 @@
+<svg width="12" height="10" viewBox="0 0 12 10" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4.2 5.0002C5.52563 5.0002 6.6 3.92563 6.6 2.6002C6.6 1.27476 5.52563 0.200195 4.2 0.200195C2.87438 0.200195 1.8 1.27476 1.8 2.6002C1.8 3.92563 2.87438 5.0002 4.2 5.0002ZM5.15063 5.9002H3.24938C1.45519 5.9002 0 7.3552 0 9.14957C0 9.50957 0.291 9.8002 0.649875 9.8002H7.7505C8.10938 9.8002 8.4 9.50957 8.4 9.14957C8.4 7.3552 6.945 5.9002 5.15063 5.9002ZM11.55 3.9502H10.65V3.0502C10.65 2.8027 10.4494 2.6002 10.2 2.6002C9.95063 2.6002 9.75 2.80176 9.75 3.0502V3.9502H8.85C8.6025 3.9502 8.4 4.1527 8.4 4.4002C8.4 4.6477 8.60156 4.8502 8.85 4.8502H9.75V5.7502C9.75 5.99957 9.9525 6.2002 10.2 6.2002C10.4475 6.2002 10.65 5.99863 10.65 5.7502V4.8502H11.55C11.7994 4.8502 12 4.64957 12 4.4002C12 4.15082 11.7994 3.9502 11.55 3.9502Z" fill="#9C9C9C"/>
+</svg>

assets/icons/contacts-solid-14.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.2 7C6.52563 7 7.6 5.92544 7.6 4.6C7.6 3.27456 6.52563 2.2 5.2 2.2C3.87438 2.2 2.8 3.27456 2.8 4.6C2.8 5.92544 3.87438 7 5.2 7ZM6.15063 7.9H4.24938C2.45444 7.9 1 9.355 1 11.1494C1 11.5094 1.291 11.8 1.64988 11.8H8.74938C9.10938 11.8 9.4 11.5094 9.4 11.1494C9.4 9.355 7.945 7.9 6.15063 7.9ZM9.98313 8.2H8.59844C9.46 8.90688 10 9.96438 10 11.1494C10 11.3894 9.92875 11.6106 9.8125 11.8H12.4C12.7319 11.8 13 11.53 13 11.1831C13 9.5425 11.6575 8.2 9.98313 8.2ZM9.1 7C10.2606 7 11.2 6.06063 11.2 4.9C11.2 3.73938 10.2606 2.8 9.1 2.8C8.62919 2.8 8.19925 2.96041 7.849 3.22206C8.065 3.63681 8.2 4.10125 8.2 4.6C8.2 5.266 7.97631 5.87763 7.60769 6.37581C7.98813 6.76 8.515 7 9.1 7Z" fill="white"/>
+</svg>

assets/icons/decline.svg

@@ -0,0 +1,3 @@
+<svg width="8" height="8" viewBox="0 0 8 8" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M1 7L4 4M7 1L4 4M4 4L1 1M4 4L7 7" stroke="#9C9C9C" stroke-width="1.33333"/>
+</svg>

assets/icons/download-solid-14.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4 10C3.58579 10 3.25 10.3358 3.25 10.75C3.25 11.1642 3.58579 11.5 4 11.5V10ZM10 11.5C10.4142 11.5 10.75 11.1642 10.75 10.75C10.75 10.3358 10.4142 10 10 10V11.5ZM7.75 3.5C7.75 3.08579 7.41421 2.75 7 2.75C6.58579 2.75 6.25 3.08579 6.25 3.5H7.75ZM7 8L6.51191 8.56944C6.79277 8.81019 7.20723 8.81019 7.48809 8.56944L7 8ZM9.23809 7.06944C9.55259 6.79988 9.58901 6.3264 9.31944 6.01191C9.04988 5.69741 8.5764 5.66099 8.26191 5.93056L9.23809 7.06944ZM5.73809 5.93056C5.4236 5.66099 4.95012 5.69741 4.68056 6.01191C4.41099 6.3264 4.44741 6.79988 4.76191 7.06944L5.73809 5.93056ZM4 11.5H10V10H4V11.5ZM6.25 3.5V8H7.75V3.5H6.25ZM7.48809 8.56944L9.23809 7.06944L8.26191 5.93056L6.51191 7.43056L7.48809 8.56944ZM7.48809 7.43056L5.73809 5.93056L4.76191 7.06944L6.51191 8.56944L7.48809 7.43056Z" fill="white"/>
+</svg>

assets/icons/error-solid-14.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M7 11.5C9.48528 11.5 11.5 9.48528 11.5 7C11.5 4.51472 9.48528 2.5 7 2.5C4.51472 2.5 2.5 4.51472 2.5 7C2.5 9.48528 4.51472 11.5 7 11.5ZM4.91475 5.71025L6.2045 7L4.91475 8.28975L5.71025 9.08525L7 7.79549L8.28975 9.08525L9.08525 8.28975L7.79549 7L9.08525 5.71025L8.28975 4.91475L7 6.2045L5.71025 4.91475L4.91475 5.71025Z" fill="white"/>
+</svg>

assets/icons/folder-tree-solid-14.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12.3333 2.33333H10L9.33333 1.66666H7.66667C7.29958 1.66666 7 1.96625 7 2.33333V5.66666C7 6.03375 7.29958 6.33333 7.66667 6.33333H12.3333C12.7004 6.33333 13 6.03375 13 5.66666V3C13 2.63291 12.7 2.33333 12.3333 2.33333ZM12.3333 8.33333H10L9.33333 7.66666H7.66667C7.29958 7.66666 7 7.96625 7 8.33333V11.6667C7 12.0337 7.29958 12.3333 7.66667 12.3333H12.3333C12.7004 12.3333 13 12.0337 13 11.6667V9C13 8.63333 12.7 8.33333 12.3333 8.33333ZM2.33333 2C2.33333 1.8151 2.185 1.66666 2 1.66666H1.33333C1.14844 1.66666 1 1.815 1 2V10.3333C1 10.7004 1.29958 11 1.66667 11H6.33333V9.66666H2.33333V5H6.33333V3.66666H2.33333V2Z" fill="white"/>
+</svg>

assets/icons/jump.svg

@@ -0,0 +1,3 @@
+<svg width="8" height="8" viewBox="0 0 8 8" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.5 1.02501V6.27499C7.5 6.56484 7.26484 6.79999 6.975 6.79999C6.68516 6.79999 6.45 6.56484 6.45 6.27499V2.29157L1.3969 7.34468C1.29365 7.44968 1.15934 7.49999 1.02503 7.49999C0.890713 7.49999 0.756401 7.44871 0.653808 7.34619C0.448731 7.14111 0.448731 6.80894 0.653808 6.60375L5.70844 1.55001H1.72502C1.43518 1.55001 1.20002 1.31595 1.20002 1.02501C1.20002 0.734077 1.43518 0.500015 1.72502 0.500015H6.975C7.26594 0.500015 7.5 0.736264 7.5 1.02501Z" fill="white" fill-opacity="0.6"/>
+</svg>

assets/icons/lock-8.svg

@@ -0,0 +1,3 @@
+<svg width="8" height="8" viewBox="0 0 8 8" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M1.75 3V2.25C1.75 1.00734 2.75781 0 4 0C5.24219 0 6.25 1.00734 6.25 2.25V3H6.5C7.05156 3 7.5 3.44844 7.5 4V7C7.5 7.55156 7.05156 8 6.5 8H1.5C0.947656 8 0.5 7.55156 0.5 7V4C0.5 3.44844 0.947656 3 1.5 3H1.75ZM2.75 3H5.25V2.25C5.25 1.55969 4.69063 1 4 1C3.30938 1 2.75 1.55969 2.75 2.25V3Z" fill="#8B8792"/>
+</svg>

assets/icons/magnifier.svg

@@ -0,0 +1,3 @@
+<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M11.0893 10.4092L8.34129 7.66113C8.93602 6.93311 9.26414 6.01641 9.26414 5.01562C9.26414 2.65928 7.35425 0.75 4.99851 0.75C2.64278 0.75 0.751343 2.65989 0.751343 5.01562C0.751343 7.37136 2.66103 9.28125 4.99851 9.28125C5.99909 9.28125 6.91702 8.93446 7.64402 8.35758L10.3921 11.1056C10.5069 11.2028 10.6341 11.25 10.7592 11.25C10.8843 11.25 11.011 11.2019 11.1072 11.1058C11.2985 10.9137 11.2985 10.602 11.0893 10.4092ZM1.73572 5.01562C1.73572 3.20643 3.20777 1.73438 5.01697 1.73438C6.82617 1.73438 8.29822 3.20643 8.29822 5.01562C8.29822 6.82482 6.82617 8.29688 5.01697 8.29688C3.20777 8.29688 1.73572 6.82441 1.73572 5.01562Z" fill="white" fill-opacity="0.5"/>
+</svg>

assets/icons/no-error-solid-14.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M7 11.5C9.48528 11.5 11.5 9.48528 11.5 7C11.5 4.51472 9.48528 2.5 7 2.5C4.51472 2.5 2.5 4.51472 2.5 7C2.5 9.48528 4.51472 11.5 7 11.5ZM9.64775 5.71025L8.85225 4.91475L6.15625 7.61076L5.14775 6.60225L4.35225 7.39775L6.15625 9.20174L9.64775 5.71025Z" fill="white"/>
+</svg>

assets/icons/share.svg

@@ -0,0 +1,3 @@
+<svg width="12" height="14" viewBox="0 0 12 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M6.0002 0.333344C2.77885 0.333344 0.16687 2.94532 0.16687 6.16668C0.16687 8.56824 1.61921 10.6302 3.69291 11.5234C3.60229 10.9831 3.53223 10.4404 3.51062 10.0091C2.25203 9.19011 1.41661 7.77605 1.41661 6.16668C1.41661 3.63933 3.4726 1.58334 5.99994 1.58334C8.52729 1.58334 10.5833 3.63933 10.5833 6.16668C10.5833 7.77579 9.74786 9.19011 8.48979 10.0104C8.46791 10.4401 8.39734 10.9836 8.30645 11.5253C10.38 10.6302 11.8331 8.56772 11.8331 6.16668C11.8331 2.94532 9.22117 0.333344 5.99981 0.333344H6.0002ZM6.0002 8.45834C5.14395 8.45834 4.33354 8.68295 4.33354 9.59767C4.33354 10.4604 4.66895 12.3138 4.87052 13.056C5.00541 13.5521 5.50802 13.6667 6.0002 13.6667C6.49239 13.6667 6.9963 13.5527 7.12989 13.0578C7.33093 12.3099 7.66687 10.4583 7.66687 9.59897C7.66687 8.6823 6.85697 8.45834 6.0002 8.45834ZM6.0002 7.62501C6.80619 7.62501 7.45854 6.97267 7.45854 6.16668C7.45854 5.36069 6.78406 4.70834 6.0002 4.70834C5.21635 4.70834 4.54187 5.35939 4.54187 6.16668C4.54187 6.97397 5.19291 7.62501 6.0002 7.62501ZM9.7502 6.16668C9.7502 4.09558 8.0713 2.41668 6.0002 2.41668C3.92911 2.41668 2.2502 4.09636 2.2502 6.16668C2.2502 7.33413 2.79499 8.36407 3.63145 9.05209C3.75776 8.72267 3.99942 8.37814 4.46609 8.13959C4.46635 8.13803 4.47416 8.13803 4.47937 8.13803C3.88822 7.6797 3.5002 6.97136 3.5002 6.16668C3.5002 4.78595 4.61947 3.66668 6.0002 3.66668C7.38093 3.66668 8.5002 4.78595 8.5002 6.16668C8.5002 6.97189 8.11296 7.68048 7.52182 8.13751C7.5252 8.13803 7.53484 8.13855 7.53406 8.13933C8.00098 8.37788 8.24213 8.72215 8.36869 9.05183C9.20567 8.36433 9.74994 7.33308 9.74994 6.16642L9.7502 6.16668Z" fill="white"/>
+</svg>

assets/icons/warning-solid-14.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M11.5 11.5H2.5V9.7L6.4375 2.5H7.5625L11.5 9.7V11.5ZM6.4375 4.9H7.5625V7.9H6.4375V4.9ZM6.4375 9.1H7.5625V10.3H6.4375V9.1Z" fill="white"/>
+</svg>

assets/keymaps/default.json

@@ -0,0 +1,356 @@
+[
+    // Standard macOS bindings
+    {
+        "bindings": {
+            "up": "menu::SelectPrev",
+            "ctrl-p": "menu::SelectPrev",
+            "down": "menu::SelectNext",
+            "ctrl-n": "menu::SelectNext",
+            "cmd-up": "menu::SelectFirst",
+            "cmd-down": "menu::SelectLast",
+            "enter": "menu::Confirm",
+            "escape": "menu::Cancel",
+            "ctrl-c": "menu::Cancel",
+            "shift-cmd-{": "pane::ActivatePrevItem",
+            "shift-cmd-}": "pane::ActivateNextItem",
+            "cmd-w": "pane::CloseActiveItem",
+            "cmd-shift-W": "workspace::CloseWindow",
+            "alt-cmd-t": "pane::CloseInactiveItems",
+            "cmd-s": "workspace::Save",
+            "cmd-shift-S": "workspace::SaveAs",
+            "cmd-=": "zed::IncreaseBufferFontSize",
+            "cmd--": "zed::DecreaseBufferFontSize",
+            "cmd-0": "zed::ResetBufferFontSize",
+            "cmd-,": "zed::OpenSettings",
+            "cmd-q": "zed::Quit",
+            "cmd-n": "workspace::NewFile",
+            "cmd-shift-N": "workspace::NewWindow",
+            "cmd-o": "workspace::Open"
+        }
+    },
+    {
+        "context": "Editor",
+        "bindings": {
+            "escape": "editor::Cancel",
+            "backspace": "editor::Backspace",
+            "shift-backspace": "editor::Backspace",
+            "ctrl-h": "editor::Backspace",
+            "delete": "editor::Delete",
+            "ctrl-d": "editor::Delete",
+            "tab": "editor::Tab",
+            "shift-tab": "editor::TabPrev",
+            "ctrl-k": "editor::CutToEndOfLine",
+            "ctrl-t": "editor::Transpose",
+            "cmd-backspace": "editor::DeleteToBeginningOfLine",
+            "cmd-delete": "editor::DeleteToEndOfLine",
+            "alt-backspace": "editor::DeleteToPreviousWordStart",
+            "alt-delete": "editor::DeleteToNextWordEnd",
+            "alt-h": "editor::DeleteToPreviousWordStart",
+            "alt-d": "editor::DeleteToNextWordEnd",
+            "cmd-x": "editor::Cut",
+            "cmd-c": "editor::Copy",
+            "cmd-v": "editor::Paste",
+            "cmd-z": "editor::Undo",
+            "cmd-shift-Z": "editor::Redo",
+            "up": "editor::MoveUp",
+            "down": "editor::MoveDown",
+            "left": "editor::MoveLeft",
+            "right": "editor::MoveRight",
+            "ctrl-p": "editor::MoveUp",
+            "ctrl-n": "editor::MoveDown",
+            "ctrl-b": "editor::MoveLeft",
+            "ctrl-f": "editor::MoveRight",
+            "alt-left": "editor::MoveToPreviousWordStart",
+            "alt-b": "editor::MoveToPreviousWordStart",
+            "alt-right": "editor::MoveToNextWordEnd",
+            "alt-f": "editor::MoveToNextWordEnd",
+            "cmd-left": "editor::MoveToBeginningOfLine",
+            "ctrl-a": "editor::MoveToBeginningOfLine",
+            "cmd-right": "editor::MoveToEndOfLine",
+            "ctrl-e": "editor::MoveToEndOfLine",
+            "cmd-up": "editor::MoveToBeginning",
+            "cmd-down": "editor::MoveToEnd",
+            "shift-up": "editor::SelectUp",
+            "ctrl-shift-P": "editor::SelectUp",
+            "shift-down": "editor::SelectDown",
+            "ctrl-shift-N": "editor::SelectDown",
+            "shift-left": "editor::SelectLeft",
+            "ctrl-shift-B": "editor::SelectLeft",
+            "shift-right": "editor::SelectRight",
+            "ctrl-shift-F": "editor::SelectRight",
+            "alt-shift-left": "editor::SelectToPreviousWordStart",
+            "alt-shift-B": "editor::SelectToPreviousWordStart",
+            "alt-shift-right": "editor::SelectToNextWordEnd",
+            "alt-shift-F": "editor::SelectToNextWordEnd",
+            "cmd-shift-up": "editor::SelectToBeginning",
+            "cmd-shift-down": "editor::SelectToEnd",
+            "cmd-a": "editor::SelectAll",
+            "cmd-l": "editor::SelectLine",
+            "cmd-shift-left": [
+                "editor::SelectToBeginningOfLine",
+                {
+                    "stop_at_soft_wraps": true
+                }
+            ],
+            "ctrl-shift-A": [
+                "editor::SelectToBeginningOfLine",
+                {
+                    "stop_at_soft_wraps": true
+                }
+            ],
+            "cmd-shift-right": [
+                "editor::SelectToEndOfLine",
+                {
+                    "stop_at_soft_wraps": true
+                }
+            ],
+            "ctrl-shift-E": [
+                "editor::SelectToEndOfLine",
+                {
+                    "stop_at_soft_wraps": true
+                }
+            ],
+            "pageup": "editor::PageUp",
+            "pagedown": "editor::PageDown"
+        }
+    },
+    {
+        "context": "Editor && mode == full",
+        "bindings": {
+            "enter": "editor::Newline",
+            "cmd-f": [
+                "buffer_search::Deploy",
+                {
+                    "focus": true
+                }
+            ],
+            "cmd-e": [
+                "buffer_search::Deploy",
+                {
+                    "focus": false
+                }
+            ]
+        }
+    },
+    {
+        "context": "Editor && mode == auto_height",
+        "bindings": {
+            "alt-enter": [
+                "editor::Input",
+                "\n"
+            ]
+        }
+    },
+    {
+        "context": "BufferSearchBar",
+        "bindings": {
+            "escape": "buffer_search::Dismiss",
+            "cmd-f": "buffer_search::FocusEditor",
+            "enter": "search::SelectNextMatch",
+            "shift-enter": "search::SelectPrevMatch"
+        }
+    },
+    {
+        "context": "Pane",
+        "bindings": {
+            "cmd-f": "project_search::ToggleFocus",
+            "cmd-g": "search::SelectNextMatch",
+            "cmd-shift-G": "search::SelectPrevMatch",
+            "alt-cmd-c": "search::ToggleCaseSensitive",
+            "alt-cmd-w": "search::ToggleWholeWord",
+            "alt-cmd-r": "search::ToggleRegex"
+        }
+    },
+    // Bindings from VS Code
+    {
+        "context": "Editor",
+        "bindings": {
+            "cmd-[": "editor::Outdent",
+            "cmd-]": "editor::Indent",
+            "cmd-alt-up": "editor::AddSelectionAbove",
+            "cmd-ctrl-p": "editor::AddSelectionAbove",
+            "cmd-alt-down": "editor::AddSelectionBelow",
+            "cmd-ctrl-n": "editor::AddSelectionBelow",
+            "cmd-d": [
+                "editor::SelectNext",
+                {
+                    "replace_newest": false
+                }
+            ],
+            "cmd-k cmd-d": [
+                "editor::SelectNext",
+                {
+                    "replace_newest": true
+                }
+            ],
+            "cmd-/": "editor::ToggleComments",
+            "alt-up": "editor::SelectLargerSyntaxNode",
+            "alt-down": "editor::SelectSmallerSyntaxNode",
+            "cmd-u": "editor::UndoSelection",
+            "cmd-shift-U": "editor::RedoSelection",
+            "f8": "editor::GoToNextDiagnostic",
+            "shift-f8": "editor::GoToPrevDiagnostic",
+            "f2": "editor::Rename",
+            "f12": "editor::GoToDefinition",
+            "alt-shift-f12": "editor::FindAllReferences",
+            "ctrl-m": "editor::MoveToEnclosingBracket",
+            "alt-cmd-[": "editor::Fold",
+            "alt-cmd-]": "editor::UnfoldLines",
+            "ctrl-space": "editor::ShowCompletions",
+            "cmd-.": "editor::ToggleCodeActions"
+        }
+    },
+    {
+        "context": "Editor && mode == full",
+        "bindings": {
+            "cmd-shift-O": "outline::Toggle",
+            "ctrl-g": "go_to_line::Toggle"
+        }
+    },
+    {
+        "context": "Pane",
+        "bindings": {
+            "ctrl--": "pane::GoBack",
+            "shift-ctrl-_": "pane::GoForward",
+            "cmd-shift-T": "pane::ReopenClosedItem",
+            "cmd-shift-F": "project_search::ToggleFocus"
+        }
+    },
+    {
+        "context": "Workspace",
+        "bindings": {
+            "cmd-shift-F": "project_search::Deploy",
+            "cmd-k cmd-t": "theme_selector::Toggle",
+            "cmd-k cmd-s": "zed::OpenKeymap",
+            "cmd-t": "project_symbols::Toggle",
+            "cmd-p": "file_finder::Toggle",
+            "cmd-shift-P": "command_palette::Toggle",
+            "cmd-shift-M": "diagnostics::Deploy",
+            "cmd-alt-s": "workspace::SaveAll"
+        }
+    },
+    // Bindings from Sublime Text
+    {
+        "context": "Editor",
+        "bindings": {
+            "ctrl-shift-K": "editor::DeleteLine",
+            "cmd-shift-D": "editor::DuplicateLine",
+            "cmd-shift-L": "editor::SplitSelectionIntoLines",
+            "ctrl-cmd-up": "editor::MoveLineUp",
+            "ctrl-cmd-down": "editor::MoveLineDown",
+            "ctrl-alt-backspace": "editor::DeleteToPreviousSubwordStart",
+            "ctrl-alt-h": "editor::DeleteToPreviousSubwordStart",
+            "ctrl-alt-delete": "editor::DeleteToNextSubwordEnd",
+            "ctrl-alt-d": "editor::DeleteToNextSubwordEnd",
+            "ctrl-alt-left": "editor::MoveToPreviousSubwordStart",
+            "ctrl-alt-b": "editor::MoveToPreviousSubwordStart",
+            "ctrl-alt-right": "editor::MoveToNextSubwordEnd",
+            "ctrl-alt-f": "editor::MoveToNextSubwordEnd",
+            "ctrl-alt-shift-left": "editor::SelectToPreviousSubwordStart",
+            "ctrl-alt-shift-B": "editor::SelectToPreviousSubwordStart",
+            "ctrl-alt-shift-right": "editor::SelectToNextSubwordEnd",
+            "ctrl-alt-shift-F": "editor::SelectToNextSubwordEnd"
+        }
+    },
+    {
+        "bindings": {
+            "cmd-k cmd-left": "workspace::ActivatePreviousPane",
+            "cmd-k cmd-right": "workspace::ActivateNextPane"
+        }
+    },
+    // Bindings from Atom
+    {
+        "context": "Pane",
+        "bindings": {
+            "cmd-k up": "pane::SplitUp",
+            "cmd-k down": "pane::SplitDown",
+            "cmd-k left": "pane::SplitLeft",
+            "cmd-k right": "pane::SplitRight"
+        }
+    },
+    // Bindings that should be unified with bindings for more general actions
+    {
+        "context": "Editor && renaming",
+        "bindings": {
+            "enter": "editor::ConfirmRename"
+        }
+    },
+    {
+        "context": "Editor && showing_completions",
+        "bindings": {
+            "enter": "editor::ConfirmCompletion",
+            "tab": "editor::ConfirmCompletion"
+        }
+    },
+    {
+        "context": "Editor && showing_code_actions",
+        "bindings": {
+            "enter": "editor::ConfirmCodeAction"
+        }
+    },
+    // Custom bindings
+    {
+        "bindings": {
+            "ctrl-alt-cmd-f": "workspace::FollowNextCollaborator",
+            "cmd-alt-i": "zed::DebugElements"
+        }
+    },
+    {
+        "context": "Editor",
+        "bindings": {
+            "alt-enter": "editor::OpenExcerpts"
+        }
+    },
+    {
+        "context": "ProjectSearchBar",
+        "bindings": {
+            "cmd-enter": "project_search::SearchInNew"
+        }
+    },
+    {
+        "context": "Workspace",
+        "bindings": {
+            "cmd-1": [
+                "workspace::ToggleSidebarItemFocus",
+                {
+                    "side": "Left",
+                    "item_index": 0
+                }
+            ],
+            "cmd-shift-!": [
+                "workspace::ToggleSidebarItem",
+                {
+                    "side": "Left",
+                    "item_index": 0
+                }
+            ],
+            "cmd-9": [
+                "workspace::ToggleSidebarItemFocus",
+                {
+                    "side": "Right",
+                    "item_index": 0
+                }
+            ],
+            "cmd-shift-(": [
+                "workspace::ToggleSidebarItem",
+                {
+                    "side": "Right",
+                    "item_index": 0
+                }
+            ]
+        }
+    },
+    {
+        "context": "ProjectPanel",
+        "bindings": {
+            "left": "project_panel::CollapseSelectedEntry",
+            "right": "project_panel::ExpandSelectedEntry",
+            "cmd-x": "project_panel::Cut",
+            "cmd-c": "project_panel::Copy",
+            "cmd-v": "project_panel::Paste",
+            "cmd-alt-c": "project_panel::CopyPath",
+            "f2": "project_panel::Rename",
+            "backspace": "project_panel::Delete"
+        }
+    }
+]

assets/keymaps/vim.json

@@ -0,0 +1,156 @@
+[
+    {
+        "context": "Editor && VimControl",
+        "bindings": {
+            "g": [
+                "vim::PushOperator",
+                {
+                    "Namespace": "G"
+                }
+            ],
+            "h": "vim::Left",
+            "backspace": "vim::Left",
+            "j": "vim::Down",
+            "k": "vim::Up",
+            "l": "vim::Right",
+            "0": "vim::StartOfLine",
+            "shift-$": "vim::EndOfLine",
+            "shift-G": "vim::EndOfDocument",
+            "w": "vim::NextWordStart",
+            "shift-W": [
+                "vim::NextWordStart",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "e": "vim::NextWordEnd",
+            "shift-E": [
+                "vim::NextWordEnd",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "b": "vim::PreviousWordStart",
+            "shift-B": [
+                "vim::PreviousWordStart",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "escape": [
+                "vim::SwitchMode",
+                "Normal"
+            ]
+        }
+    },
+    {
+        "context": "Editor && vim_mode == normal",
+        "bindings": {
+            "escape": "editor::Cancel",
+            "c": [
+                "vim::PushOperator",
+                "Change"
+            ],
+            "shift-C": "vim::ChangeToEndOfLine",
+            "d": [
+                "vim::PushOperator",
+                "Delete"
+            ],
+            "shift-D": "vim::DeleteToEndOfLine",
+            "y": [
+                "vim::PushOperator",
+                "Yank"
+            ],
+            "i": [
+                "vim::SwitchMode",
+                "Insert"
+            ],
+            "shift-I": "vim::InsertFirstNonWhitespace",
+            "a": "vim::InsertAfter",
+            "shift-A": "vim::InsertEndOfLine",
+            "x": "vim::DeleteRight",
+            "shift-X": "vim::DeleteLeft",
+            "shift-^": "vim::FirstNonWhitespace",
+            "o": "vim::InsertLineBelow",
+            "shift-O": "vim::InsertLineAbove",
+            "v": [
+                "vim::SwitchMode",
+                {
+                    "Visual": {
+                        "line": false
+                    }
+                }
+            ],
+            "shift-V": [
+                "vim::SwitchMode",
+                {
+                    "Visual": {
+                        "line": true
+                    }
+                }
+            ],
+            "p": "vim::Paste",
+            "u": "editor::Undo",
+            "ctrl-r": "editor::Redo",
+            "ctrl-o": "pane::GoBack"
+        }
+    },
+    {
+        "context": "Editor && vim_operator == g",
+        "bindings": {
+            "g": "vim::StartOfDocument",
+            "h": "editor::Hover",
+            "escape": [
+                "vim::SwitchMode",
+                "Normal"
+            ]
+        }
+    },
+    {
+        "context": "Editor && vim_operator == c",
+        "bindings": {
+            "w": "vim::ChangeWord",
+            "shift-W": [
+                "vim::ChangeWord",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "c": "vim::CurrentLine"
+        }
+    },
+    {
+        "context": "Editor && vim_operator == d",
+        "bindings": {
+            "d": "vim::CurrentLine"
+        }
+    },
+    {
+        "context": "Editor && vim_operator == y",
+        "bindings": {
+            "y": "vim::CurrentLine"
+        }
+    },
+    {
+        "context": "Editor && vim_mode == visual",
+        "bindings": {
+            "c": "vim::VisualChange",
+            "d": "vim::VisualDelete",
+            "x": "vim::VisualDelete",
+            "y": "vim::VisualYank"
+        }
+    },
+    {
+        "context": "Editor && vim_mode == insert",
+        "bindings": {
+            "escape": "vim::NormalBefore",
+            "ctrl-c": "vim::NormalBefore"
+        }
+    },
+    {
+        "context": "Editor && mode == singleline",
+        "bindings": {
+            "escape": "editor::Cancel"
+        }
+    }
+]

crates/assets/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "assets"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/assets.rs"
+doctest = false
+
+[dependencies]
+gpui = { path = "../gpui" }
+anyhow = "1.0.38"
+rust-embed = { version = "6.3", features = ["include-exclude"] }
+

crates/assets/src/assets.rs

@@ -3,7 +3,7 @@ use gpui::AssetSource;
 use rust_embed::RustEmbed;
 
 #[derive(RustEmbed)]
-#[folder = "assets"]
+#[folder = "../../assets"]
 #[exclude = "*.DS_Store"]
 pub struct Assets;
 

crates/auto_update/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "auto_update"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/auto_update.rs"
+doctest = false
+
+[dependencies]
+client = { path = "../client" }
+gpui = { path = "../gpui" }
+menu = { path = "../menu" }
+project = { path = "../project" }
+settings = { path = "../settings" }
+theme = { path = "../theme" }
+workspace = { path = "../workspace" }
+util = { path = "../util" }
+anyhow = "1.0.38"
+isahc = "1.7"
+lazy_static = "1.4"
+log = "0.4"
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = { version = "1.0", features = ["preserve_order"] }
+smol = "1.2.5"
+tempdir = "0.3.7"

crates/auto_update/src/auto_update.rs

@@ -0,0 +1,377 @@
+mod update_notification;
+
+use anyhow::{anyhow, Context, Result};
+use client::{http::HttpClient, ZED_SECRET_CLIENT_TOKEN};
+use gpui::{
+    actions,
+    elements::{Empty, MouseEventHandler, Text},
+    platform::AppVersion,
+    AppContext, AsyncAppContext, Element, Entity, ModelContext, ModelHandle, MutableAppContext,
+    Task, View, ViewContext, WeakViewHandle,
+};
+use lazy_static::lazy_static;
+use serde::Deserialize;
+use settings::Settings;
+use smol::{fs::File, io::AsyncReadExt, process::Command};
+use std::{env, ffi::OsString, path::PathBuf, sync::Arc, time::Duration};
+use update_notification::UpdateNotification;
+use workspace::{ItemHandle, StatusItemView, Workspace};
+
+const SHOULD_SHOW_UPDATE_NOTIFICATION_KEY: &'static str =
+    "auto-updater-should-show-updated-notification";
+const POLL_INTERVAL: Duration = Duration::from_secs(60 * 60);
+
+lazy_static! {
+    pub static ref ZED_APP_VERSION: Option<AppVersion> = env::var("ZED_APP_VERSION")
+        .ok()
+        .and_then(|v| v.parse().ok());
+    pub static ref ZED_APP_PATH: Option<PathBuf> = env::var("ZED_APP_PATH").ok().map(PathBuf::from);
+}
+
+actions!(auto_update, [Check, DismissErrorMessage, ViewReleaseNotes]);
+
+#[derive(Clone, PartialEq, Eq)]
+pub enum AutoUpdateStatus {
+    Idle,
+    Checking,
+    Downloading,
+    Installing,
+    Updated,
+    Errored,
+}
+
+pub struct AutoUpdater {
+    status: AutoUpdateStatus,
+    current_version: AppVersion,
+    http_client: Arc<dyn HttpClient>,
+    pending_poll: Option<Task<()>>,
+    db: Arc<project::Db>,
+    server_url: String,
+}
+
+pub struct AutoUpdateIndicator {
+    updater: Option<ModelHandle<AutoUpdater>>,
+}
+
+#[derive(Deserialize)]
+struct JsonRelease {
+    version: String,
+    url: String,
+}
+
+impl Entity for AutoUpdater {
+    type Event = ();
+}
+
+pub fn init(
+    db: Arc<project::Db>,
+    http_client: Arc<dyn HttpClient>,
+    server_url: String,
+    cx: &mut MutableAppContext,
+) {
+    if let Some(version) = ZED_APP_VERSION.clone().or(cx.platform().app_version().ok()) {
+        let auto_updater = cx.add_model(|cx| {
+            let updater = AutoUpdater::new(version, db.clone(), http_client, server_url.clone());
+            updater.start_polling(cx).detach();
+            updater
+        });
+        cx.set_global(Some(auto_updater));
+        cx.add_global_action(|_: &Check, cx| {
+            if let Some(updater) = AutoUpdater::get(cx) {
+                updater.update(cx, |updater, cx| updater.poll(cx));
+            }
+        });
+        cx.add_global_action(move |_: &ViewReleaseNotes, cx| {
+            cx.platform().open_url(&format!("{server_url}/releases"));
+        });
+        cx.add_action(AutoUpdateIndicator::dismiss_error_message);
+        cx.add_action(UpdateNotification::dismiss);
+    }
+}
+
+pub fn notify_of_any_new_update(
+    workspace: WeakViewHandle<Workspace>,
+    cx: &mut MutableAppContext,
+) -> Option<()> {
+    let updater = AutoUpdater::get(cx)?;
+    let version = updater.read(cx).current_version;
+    let should_show_notification = updater.read(cx).should_show_update_notification(cx);
+
+    cx.spawn(|mut cx| async move {
+        let should_show_notification = should_show_notification.await?;
+        if should_show_notification {
+            if let Some(workspace) = workspace.upgrade(&cx) {
+                workspace.update(&mut cx, |workspace, cx| {
+                    workspace.show_notification(0, cx, |cx| {
+                        cx.add_view(|_| UpdateNotification::new(version))
+                    });
+                    updater
+                        .read(cx)
+                        .set_should_show_update_notification(false, cx)
+                        .detach_and_log_err(cx);
+                });
+            }
+        }
+        anyhow::Ok(())
+    })
+    .detach();
+
+    None
+}
+
+impl AutoUpdater {
+    fn get(cx: &mut MutableAppContext) -> Option<ModelHandle<Self>> {
+        cx.default_global::<Option<ModelHandle<Self>>>().clone()
+    }
+
+    fn new(
+        current_version: AppVersion,
+        db: Arc<project::Db>,
+        http_client: Arc<dyn HttpClient>,
+        server_url: String,
+    ) -> Self {
+        Self {
+            status: AutoUpdateStatus::Idle,
+            current_version,
+            db,
+            http_client,
+            server_url,
+            pending_poll: None,
+        }
+    }
+
+    pub fn start_polling(&self, cx: &mut ModelContext<Self>) -> Task<()> {
+        cx.spawn(|this, mut cx| async move {
+            loop {
+                this.update(&mut cx, |this, cx| this.poll(cx));
+                cx.background().timer(POLL_INTERVAL).await;
+            }
+        })
+    }
+
+    pub fn poll(&mut self, cx: &mut ModelContext<Self>) {
+        if self.pending_poll.is_some() || self.status == AutoUpdateStatus::Updated {
+            return;
+        }
+
+        self.status = AutoUpdateStatus::Checking;
+        cx.notify();
+
+        self.pending_poll = Some(cx.spawn(|this, mut cx| async move {
+            let result = Self::update(this.clone(), cx.clone()).await;
+            this.update(&mut cx, |this, cx| {
+                this.pending_poll = None;
+                if let Err(error) = result {
+                    log::error!("auto-update failed: error:{:?}", error);
+                    this.status = AutoUpdateStatus::Errored;
+                    cx.notify();
+                }
+            });
+        }));
+    }
+
+    async fn update(this: ModelHandle<Self>, mut cx: AsyncAppContext) -> Result<()> {
+        let (client, server_url, current_version) = this.read_with(&cx, |this, _| {
+            (
+                this.http_client.clone(),
+                this.server_url.clone(),
+                this.current_version,
+            )
+        });
+        let mut response = client
+            .get(
+                &format!("{server_url}/api/releases/latest?token={ZED_SECRET_CLIENT_TOKEN}&asset=Zed.dmg"),
+                Default::default(),
+                true,
+            )
+            .await?;
+
+        let mut body = Vec::new();
+        response
+            .body_mut()
+            .read_to_end(&mut body)
+            .await
+            .context("error reading release")?;
+        let release: JsonRelease =
+            serde_json::from_slice(body.as_slice()).context("error deserializing release")?;
+
+        let latest_version = release.version.parse::<AppVersion>()?;
+        if latest_version <= current_version {
+            this.update(&mut cx, |this, cx| {
+                this.status = AutoUpdateStatus::Idle;
+                cx.notify();
+            });
+            return Ok(());
+        }
+
+        this.update(&mut cx, |this, cx| {
+            this.status = AutoUpdateStatus::Downloading;
+            cx.notify();
+        });
+
+        let temp_dir = tempdir::TempDir::new("zed-auto-update")?;
+        let dmg_path = temp_dir.path().join("Zed.dmg");
+        let mount_path = temp_dir.path().join("Zed");
+        let mut mounted_app_path: OsString = mount_path.join("Zed.app").into();
+        mounted_app_path.push("/");
+        let running_app_path = ZED_APP_PATH
+            .clone()
+            .map_or_else(|| cx.platform().app_path(), Ok)?;
+
+        let mut dmg_file = File::create(&dmg_path).await?;
+        let mut response = client.get(&release.url, Default::default(), true).await?;
+        smol::io::copy(response.body_mut(), &mut dmg_file).await?;
+        log::info!("downloaded update. path:{:?}", dmg_path);
+
+        this.update(&mut cx, |this, cx| {
+            this.status = AutoUpdateStatus::Installing;
+            cx.notify();
+        });
+
+        let output = Command::new("hdiutil")
+            .args(&["attach", "-nobrowse"])
+            .arg(&dmg_path)
+            .arg("-mountroot")
+            .arg(&temp_dir.path())
+            .output()
+            .await?;
+        if !output.status.success() {
+            Err(anyhow!(
+                "failed to mount: {:?}",
+                String::from_utf8_lossy(&output.stderr)
+            ))?;
+        }
+
+        let output = Command::new("rsync")
+            .args(&["-av", "--delete"])
+            .arg(&mounted_app_path)
+            .arg(&running_app_path)
+            .output()
+            .await?;
+        if !output.status.success() {
+            Err(anyhow!(
+                "failed to copy app: {:?}",
+                String::from_utf8_lossy(&output.stderr)
+            ))?;
+        }
+
+        let output = Command::new("hdiutil")
+            .args(&["detach"])
+            .arg(&mount_path)
+            .output()
+            .await?;
+        if !output.status.success() {
+            Err(anyhow!(
+                "failed to unmount: {:?}",
+                String::from_utf8_lossy(&output.stderr)
+            ))?;
+        }
+
+        this.update(&mut cx, |this, cx| {
+            this.set_should_show_update_notification(true, cx)
+                .detach_and_log_err(cx);
+            this.status = AutoUpdateStatus::Updated;
+            cx.notify();
+        });
+        Ok(())
+    }
+
+    fn set_should_show_update_notification(
+        &self,
+        should_show: bool,
+        cx: &AppContext,
+    ) -> Task<Result<()>> {
+        let db = self.db.clone();
+        cx.background().spawn(async move {
+            if should_show {
+                db.write([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY, "")])?;
+            } else {
+                db.delete([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?;
+            }
+            Ok(())
+        })
+    }
+
+    fn should_show_update_notification(&self, cx: &AppContext) -> Task<Result<bool>> {
+        let db = self.db.clone();
+        cx.background().spawn(async move {
+            Ok(db.read([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?[0].is_some())
+        })
+    }
+}
+
+impl Entity for AutoUpdateIndicator {
+    type Event = ();
+}
+
+impl View for AutoUpdateIndicator {
+    fn ui_name() -> &'static str {
+        "AutoUpdateIndicator"
+    }
+
+    fn render(&mut self, cx: &mut gpui::RenderContext<'_, Self>) -> gpui::ElementBox {
+        if let Some(updater) = &self.updater {
+            let theme = &cx.global::<Settings>().theme.workspace.status_bar;
+            match &updater.read(cx).status {
+                AutoUpdateStatus::Checking => Text::new(
+                    "Checking for updates…".to_string(),
+                    theme.auto_update_progress_message.clone(),
+                )
+                .boxed(),
+                AutoUpdateStatus::Downloading => Text::new(
+                    "Downloading update…".to_string(),
+                    theme.auto_update_progress_message.clone(),
+                )
+                .boxed(),
+                AutoUpdateStatus::Installing => Text::new(
+                    "Installing update…".to_string(),
+                    theme.auto_update_progress_message.clone(),
+                )
+                .boxed(),
+                AutoUpdateStatus::Updated => Text::new(
+                    "Restart to update Zed".to_string(),
+                    theme.auto_update_done_message.clone(),
+                )
+                .boxed(),
+                AutoUpdateStatus::Errored => {
+                    MouseEventHandler::new::<Self, _, _>(0, cx, |_, cx| {
+                        let theme = &cx.global::<Settings>().theme.workspace.status_bar;
+                        Text::new(
+                            "Auto update failed".to_string(),
+                            theme.auto_update_done_message.clone(),
+                        )
+                        .boxed()
+                    })
+                    .on_click(|_, _, cx| cx.dispatch_action(DismissErrorMessage))
+                    .boxed()
+                }
+                AutoUpdateStatus::Idle => Empty::new().boxed(),
+            }
+        } else {
+            Empty::new().boxed()
+        }
+    }
+}
+
+impl StatusItemView for AutoUpdateIndicator {
+    fn set_active_pane_item(&mut self, _: Option<&dyn ItemHandle>, _: &mut ViewContext<Self>) {}
+}
+
+impl AutoUpdateIndicator {
+    pub fn new(cx: &mut ViewContext<Self>) -> Self {
+        let updater = AutoUpdater::get(cx);
+        if let Some(updater) = &updater {
+            cx.observe(updater, |_, _, cx| cx.notify()).detach();
+        }
+        Self { updater }
+    }
+
+    fn dismiss_error_message(&mut self, _: &DismissErrorMessage, cx: &mut ViewContext<Self>) {
+        if let Some(updater) = &self.updater {
+            updater.update(cx, |updater, cx| {
+                updater.status = AutoUpdateStatus::Idle;
+                cx.notify();
+            });
+        }
+    }
+}

crates/auto_update/src/update_notification.rs

@@ -0,0 +1,106 @@
+use crate::ViewReleaseNotes;
+use gpui::{
+    elements::{Flex, MouseEventHandler, Padding, ParentElement, Svg, Text},
+    platform::{AppVersion, CursorStyle},
+    Element, Entity, View, ViewContext,
+};
+use menu::Cancel;
+use settings::Settings;
+use workspace::Notification;
+
+pub struct UpdateNotification {
+    version: AppVersion,
+}
+
+pub enum Event {
+    Dismiss,
+}
+
+impl Entity for UpdateNotification {
+    type Event = Event;
+}
+
+impl View for UpdateNotification {
+    fn ui_name() -> &'static str {
+        "UpdateNotification"
+    }
+
+    fn render(&mut self, cx: &mut gpui::RenderContext<'_, Self>) -> gpui::ElementBox {
+        let theme = cx.global::<Settings>().theme.clone();
+        let theme = &theme.update_notification;
+
+        MouseEventHandler::new::<ViewReleaseNotes, _, _>(0, cx, |state, cx| {
+            Flex::column()
+                .with_child(
+                    Flex::row()
+                        .with_child(
+                            Text::new(
+                                format!("Updated to Zed {}", self.version),
+                                theme.message.text.clone(),
+                            )
+                            .contained()
+                            .with_style(theme.message.container)
+                            .aligned()
+                            .top()
+                            .left()
+                            .flex(1., true)
+                            .boxed(),
+                        )
+                        .with_child(
+                            MouseEventHandler::new::<Cancel, _, _>(0, cx, |state, _| {
+                                let style = theme.dismiss_button.style_for(state, false);
+                                Svg::new("icons/decline.svg")
+                                    .with_color(style.color)
+                                    .constrained()
+                                    .with_width(style.icon_width)
+                                    .aligned()
+                                    .contained()
+                                    .with_style(style.container)
+                                    .constrained()
+                                    .with_width(style.button_width)
+                                    .with_height(style.button_width)
+                                    .boxed()
+                            })
+                            .with_padding(Padding::uniform(5.))
+                            .on_click(move |_, _, cx| cx.dispatch_action(Cancel))
+                            .aligned()
+                            .constrained()
+                            .with_height(cx.font_cache().line_height(theme.message.text.font_size))
+                            .aligned()
+                            .top()
+                            .flex_float()
+                            .boxed(),
+                        )
+                        .boxed(),
+                )
+                .with_child({
+                    let style = theme.action_message.style_for(state, false);
+                    Text::new("View the release notes".to_string(), style.text.clone())
+                        .contained()
+                        .with_style(style.container)
+                        .boxed()
+                })
+                .contained()
+                .boxed()
+        })
+        .with_cursor_style(CursorStyle::PointingHand)
+        .on_click(|_, _, cx| cx.dispatch_action(ViewReleaseNotes))
+        .boxed()
+    }
+}
+
+impl Notification for UpdateNotification {
+    fn should_dismiss_notification_on_event(&self, event: &<Self as Entity>::Event) -> bool {
+        matches!(event, Event::Dismiss)
+    }
+}
+
+impl UpdateNotification {
+    pub fn new(version: AppVersion) -> Self {
+        Self { version }
+    }
+
+    pub fn dismiss(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
+        cx.emit(Event::Dismiss);
+    }
+}

crates/breadcrumbs/Cargo.toml

@@ -1,25 +1,24 @@
 [package]
-name = "find"
+name = "breadcrumbs"
 version = "0.1.0"
 edition = "2021"
 
 [lib]
-path = "src/find.rs"
+path = "src/breadcrumbs.rs"
+doctest = false
 
 [dependencies]
 collections = { path = "../collections" }
 editor = { path = "../editor" }
 gpui = { path = "../gpui" }
+language = { path = "../language" }
+project = { path = "../project" }
+search = { path = "../search" }
+settings = { path = "../settings" }
 theme = { path = "../theme" }
 workspace = { path = "../workspace" }
-aho-corasick = "0.7"
-anyhow = "1.0"
-postage = { version = "0.4.1", features = ["futures-traits"] }
-regex = "1.5"
-smol = { version = "1.2" }
 
 [dev-dependencies]
 editor = { path = "../editor", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 workspace = { path = "../workspace", features = ["test-support"] }
-unindent = "0.1"

crates/breadcrumbs/src/breadcrumbs.rs

@@ -0,0 +1,157 @@
+use editor::{Anchor, Editor};
+use gpui::{
+    elements::*, AppContext, Entity, ModelHandle, RenderContext, Subscription, View, ViewContext,
+    ViewHandle,
+};
+use language::{Buffer, OutlineItem};
+use project::Project;
+use search::ProjectSearchView;
+use settings::Settings;
+use theme::SyntaxTheme;
+use workspace::{ItemHandle, ToolbarItemLocation, ToolbarItemView};
+
+pub enum Event {
+    UpdateLocation,
+}
+
+pub struct Breadcrumbs {
+    project: ModelHandle<Project>,
+    editor: Option<ViewHandle<Editor>>,
+    project_search: Option<ViewHandle<ProjectSearchView>>,
+    subscriptions: Vec<Subscription>,
+}
+
+impl Breadcrumbs {
+    pub fn new(project: ModelHandle<Project>) -> Self {
+        Self {
+            project,
+            editor: Default::default(),
+            subscriptions: Default::default(),
+            project_search: Default::default(),
+        }
+    }
+
+    fn active_symbols(
+        &self,
+        theme: &SyntaxTheme,
+        cx: &AppContext,
+    ) -> Option<(ModelHandle<Buffer>, Vec<OutlineItem<Anchor>>)> {
+        let editor = self.editor.as_ref()?.read(cx);
+        let cursor = editor.selections.newest_anchor().head();
+        let multibuffer = &editor.buffer().read(cx);
+        let (buffer_id, symbols) = multibuffer.symbols_containing(cursor, Some(theme), cx)?;
+        let buffer = multibuffer.buffer(buffer_id)?;
+        Some((buffer, symbols))
+    }
+}
+
+impl Entity for Breadcrumbs {
+    type Event = Event;
+}
+
+impl View for Breadcrumbs {
+    fn ui_name() -> &'static str {
+        "Breadcrumbs"
+    }
+
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = cx.global::<Settings>().theme.clone();
+        let (buffer, symbols) =
+            if let Some((buffer, symbols)) = self.active_symbols(&theme.editor.syntax, cx) {
+                (buffer, symbols)
+            } else {
+                return Empty::new().boxed();
+            };
+        let buffer = buffer.read(cx);
+        let filename = if let Some(file) = buffer.file() {
+            if file.path().file_name().is_none()
+                || self.project.read(cx).visible_worktrees(cx).count() > 1
+            {
+                file.full_path(cx).to_string_lossy().to_string()
+            } else {
+                file.path().to_string_lossy().to_string()
+            }
+        } else {
+            "untitled".to_string()
+        };
+
+        Flex::row()
+            .with_child(Label::new(filename, theme.breadcrumbs.text.clone()).boxed())
+            .with_children(symbols.into_iter().flat_map(|symbol| {
+                [
+                    Label::new(" 〉 ".to_string(), theme.breadcrumbs.text.clone()).boxed(),
+                    Text::new(symbol.text, theme.breadcrumbs.text.clone())
+                        .with_highlights(symbol.highlight_ranges)
+                        .boxed(),
+                ]
+            }))
+            .contained()
+            .with_style(theme.breadcrumbs.container)
+            .aligned()
+            .left()
+            .boxed()
+    }
+}
+
+impl ToolbarItemView for Breadcrumbs {
+    fn set_active_pane_item(
+        &mut self,
+        active_pane_item: Option<&dyn ItemHandle>,
+        cx: &mut ViewContext<Self>,
+    ) -> ToolbarItemLocation {
+        cx.notify();
+        self.subscriptions.clear();
+        self.editor = None;
+        self.project_search = None;
+        if let Some(item) = active_pane_item {
+            if let Some(editor) = item.act_as::<Editor>(cx) {
+                self.subscriptions
+                    .push(cx.subscribe(&editor, |_, _, event, cx| match event {
+                        editor::Event::BufferEdited
+                        | editor::Event::TitleChanged
+                        | editor::Event::Saved
+                        | editor::Event::Reparsed => cx.notify(),
+                        editor::Event::SelectionsChanged { local } if *local => cx.notify(),
+                        _ => {}
+                    }));
+                self.editor = Some(editor);
+                if let Some(project_search) = item.downcast::<ProjectSearchView>() {
+                    self.subscriptions
+                        .push(cx.subscribe(&project_search, |_, _, _, cx| {
+                            cx.emit(Event::UpdateLocation);
+                        }));
+                    self.project_search = Some(project_search.clone());
+
+                    if project_search.read(cx).has_matches() {
+                        ToolbarItemLocation::Secondary
+                    } else {
+                        ToolbarItemLocation::Hidden
+                    }
+                } else {
+                    ToolbarItemLocation::PrimaryLeft { flex: None }
+                }
+            } else {
+                ToolbarItemLocation::Hidden
+            }
+        } else {
+            ToolbarItemLocation::Hidden
+        }
+    }
+
+    fn location_for_event(
+        &self,
+        _: &Event,
+        current_location: ToolbarItemLocation,
+        cx: &AppContext,
+    ) -> ToolbarItemLocation {
+        if let Some(project_search) = self.project_search.as_ref() {
+            if project_search.read(cx).has_matches() {
+                ToolbarItemLocation::Secondary
+            } else {
+                ToolbarItemLocation::Hidden
+            }
+        } else {
+            current_location
+        }
+    }
+}

crates/chat_panel/Cargo.toml

@@ -5,13 +5,16 @@ edition = "2021"
 
 [lib]
 path = "src/chat_panel.rs"
+doctest = false
 
 [dependencies]
 client = { path = "../client" }
 editor = { path = "../editor" }
 gpui = { path = "../gpui" }
+menu = { path = "../menu" }
+settings = { path = "../settings" }
 theme = { path = "../theme" }
 util = { path = "../util" }
 workspace = { path = "../workspace" }
 postage = { version = "0.4.1", features = ["futures-traits"] }
-time = "0.3"
+time = { version = "0.3", features = ["serde", "serde-well-known"] }

crates/chat_panel/src/chat_panel.rs

@@ -2,21 +2,21 @@ use client::{
     channel::{Channel, ChannelEvent, ChannelList, ChannelMessage},
     Client,
 };
-use editor::{Editor, EditorSettings};
+use editor::Editor;
 use gpui::{
-    action,
+    actions,
     elements::*,
-    keymap::Binding,
     platform::CursorStyle,
     views::{ItemType, Select, SelectStyle},
     AppContext, Entity, ModelHandle, MutableAppContext, RenderContext, Subscription, Task, View,
     ViewContext, ViewHandle,
 };
-use postage::{prelude::Stream, watch};
+use menu::Confirm;
+use postage::prelude::Stream;
+use settings::{Settings, SoftWrap};
 use std::sync::Arc;
 use time::{OffsetDateTime, UtcOffset};
 use util::{ResultExt, TryFutureExt};
-use workspace::Settings;
 
 const MESSAGE_LOADING_THRESHOLD: usize = 50;
 
@@ -27,80 +27,60 @@ pub struct ChatPanel {
     message_list: ListState,
     input_editor: ViewHandle<Editor>,
     channel_select: ViewHandle<Select>,
-    settings: watch::Receiver<Settings>,
     local_timezone: UtcOffset,
     _observe_status: Task<()>,
 }
 
 pub enum Event {}
 
-action!(Send);
-action!(LoadMoreMessages);
+actions!(chat_panel, [LoadMoreMessages]);
 
 pub fn init(cx: &mut MutableAppContext) {
     cx.add_action(ChatPanel::send);
     cx.add_action(ChatPanel::load_more_messages);
-
-    cx.add_bindings(vec![Binding::new("enter", Send, Some("ChatPanel"))]);
 }
 
 impl ChatPanel {
     pub fn new(
         rpc: Arc<Client>,
         channel_list: ModelHandle<ChannelList>,
-        settings: watch::Receiver<Settings>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
         let input_editor = cx.add_view(|cx| {
-            Editor::auto_height(
-                4,
-                {
-                    let settings = settings.clone();
-                    Arc::new(move |_| {
-                        let settings = settings.borrow();
-                        EditorSettings {
-                            tab_size: settings.tab_size,
-                            style: settings.theme.chat_panel.input_editor.as_editor(),
-                            soft_wrap: editor::SoftWrap::EditorWidth,
-                        }
-                    })
-                },
-                cx,
-            )
+            let mut editor =
+                Editor::auto_height(4, Some(|theme| theme.chat_panel.input_editor.clone()), cx);
+            editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
+            editor
         });
         let channel_select = cx.add_view(|cx| {
             let channel_list = channel_list.clone();
             Select::new(0, cx, {
-                let settings = settings.clone();
                 move |ix, item_type, is_hovered, cx| {
                     Self::render_channel_name(
                         &channel_list,
                         ix,
                         item_type,
                         is_hovered,
-                        &settings.borrow().theme.chat_panel.channel_select,
+                        &cx.global::<Settings>().theme.chat_panel.channel_select,
                         cx,
                     )
                 }
             })
-            .with_style({
-                let settings = settings.clone();
-                move |_| {
-                    let theme = &settings.borrow().theme.chat_panel.channel_select;
-                    SelectStyle {
-                        header: theme.header.container.clone(),
-                        menu: theme.menu.clone(),
-                    }
+            .with_style(move |cx| {
+                let theme = &cx.global::<Settings>().theme.chat_panel.channel_select;
+                SelectStyle {
+                    header: theme.header.container,
+                    menu: theme.menu.clone(),
                 }
             })
         });
 
-        let mut message_list = ListState::new(0, Orientation::Bottom, 1000., {
+        let mut message_list = ListState::new(0, Orientation::Bottom, 1000., cx, {
             let this = cx.weak_handle();
-            move |ix, cx| {
+            move |_, ix, cx| {
                 let this = this.upgrade(cx).unwrap().read(cx);
                 let message = this.active_channel.as_ref().unwrap().0.read(cx).message(ix);
-                this.render_message(message)
+                this.render_message(message, cx)
             }
         });
         message_list.set_scroll_handler(|visible_range, cx| {
@@ -108,11 +88,15 @@ impl ChatPanel {
                 cx.dispatch_action(LoadMoreMessages);
             }
         });
-        let _observe_status = cx.spawn(|this, mut cx| {
+        let _observe_status = cx.spawn_weak(|this, mut cx| {
             let mut status = rpc.status();
             async move {
                 while let Some(_) = status.recv().await {
-                    this.update(&mut cx, |_, cx| cx.notify());
+                    if let Some(this) = this.upgrade(&cx) {
+                        this.update(&mut cx, |_, cx| cx.notify());
+                    } else {
+                        break;
+                    }
                 }
             }
         });
@@ -124,7 +108,6 @@ impl ChatPanel {
             message_list,
             input_editor,
             channel_select,
-            settings,
             local_timezone: cx.platform().local_timezone(),
             _observe_status,
         };
@@ -213,8 +196,8 @@ impl ChatPanel {
         cx.notify();
     }
 
-    fn render_channel(&self) -> ElementBox {
-        let theme = &self.settings.borrow().theme;
+    fn render_channel(&self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = &cx.global::<Settings>().theme;
         Flex::column()
             .with_child(
                 Container::new(ChildView::new(&self.channel_select).boxed())
@@ -222,7 +205,7 @@ impl ChatPanel {
                     .boxed(),
             )
             .with_child(self.render_active_channel_messages())
-            .with_child(self.render_input_box())
+            .with_child(self.render_input_box(cx))
             .boxed()
     }
 
@@ -233,12 +216,12 @@ impl ChatPanel {
             Empty::new().boxed()
         };
 
-        Flexible::new(1., true, messages).boxed()
+        FlexItem::new(messages).flex(1., true).boxed()
     }
 
-    fn render_message(&self, message: &ChannelMessage) -> ElementBox {
+    fn render_message(&self, message: &ChannelMessage, cx: &AppContext) -> ElementBox {
         let now = OffsetDateTime::now_utc();
-        let settings = self.settings.borrow();
+        let settings = cx.global::<Settings>();
         let theme = if message.is_pending() {
             &settings.theme.chat_panel.pending_message
         } else {
@@ -280,8 +263,8 @@ impl ChatPanel {
         .boxed()
     }
 
-    fn render_input_box(&self) -> ElementBox {
-        let theme = &self.settings.borrow().theme;
+    fn render_input_box(&self, cx: &AppContext) -> ElementBox {
+        let theme = &cx.global::<Settings>().theme;
         Container::new(ChildView::new(&self.input_editor).boxed())
             .with_style(theme.chat_panel.input_editor.container)
             .boxed()
@@ -318,7 +301,7 @@ impl ChatPanel {
     }
 
     fn render_sign_in_prompt(&self, cx: &mut RenderContext<Self>) -> ElementBox {
-        let theme = &self.settings.borrow().theme;
+        let theme = cx.global::<Settings>().theme.clone();
         let rpc = self.rpc.clone();
         let this = cx.handle();
 
@@ -337,11 +320,16 @@ impl ChatPanel {
                 .boxed()
             })
             .with_cursor_style(CursorStyle::PointingHand)
-            .on_click(move |cx| {
+            .on_click(move |_, _, cx| {
                 let rpc = rpc.clone();
                 let this = this.clone();
                 cx.spawn(|mut cx| async move {
-                    if rpc.authenticate_and_connect(&cx).log_err().await.is_some() {
+                    if rpc
+                        .authenticate_and_connect(true, &cx)
+                        .log_err()
+                        .await
+                        .is_some()
+                    {
                         cx.update(|cx| {
                             if let Some(this) = this.upgrade(cx) {
                                 if this.is_focused(cx) {
@@ -358,7 +346,7 @@ impl ChatPanel {
         .boxed()
     }
 
-    fn send(&mut self, _: &Send, cx: &mut ViewContext<Self>) {
+    fn send(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
         if let Some((channel, _)) = self.active_channel.as_ref() {
             let body = self.input_editor.update(cx, |editor, cx| {
                 let body = editor.text(cx);
@@ -394,12 +382,12 @@ impl View for ChatPanel {
     }
 
     fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
-        let theme = &self.settings.borrow().theme;
         let element = if self.rpc.user_id().is_some() {
-            self.render_channel()
+            self.render_channel(cx)
         } else {
             self.render_sign_in_prompt(cx)
         };
+        let theme = &cx.global::<Settings>().theme;
         ConstrainedBox::new(
             Container::new(element)
                 .with_style(theme.chat_panel.container)

crates/cli/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "cli"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/cli.rs"
+doctest = false
+
+[[bin]]
+name = "cli"
+path = "src/main.rs"
+
+[dependencies]
+anyhow = "1.0"
+clap = { version = "3.1", features = ["derive"] }
+dirs = "3.0"
+ipc-channel = "0.16"
+serde = { version = "1.0", features = ["derive", "rc"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+core-foundation = "0.9"
+core-services = "0.2"
+plist = "1.3"

crates/cli/src/cli.rs

@@ -0,0 +1,22 @@
+pub use ipc_channel::ipc;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Serialize, Deserialize)]
+pub struct IpcHandshake {
+    pub requests: ipc::IpcSender<CliRequest>,
+    pub responses: ipc::IpcReceiver<CliResponse>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CliRequest {
+    Open { paths: Vec<PathBuf>, wait: bool },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum CliResponse {
+    Ping,
+    Stdout { message: String },
+    Stderr { message: String },
+    Exit { status: i32 },
+}

crates/cli/src/main.rs

@@ -0,0 +1,124 @@
+use anyhow::{anyhow, Result};
+use clap::Parser;
+use cli::{CliRequest, CliResponse, IpcHandshake};
+use core_foundation::{
+    array::{CFArray, CFIndex},
+    string::kCFStringEncodingUTF8,
+    url::{CFURLCreateWithBytes, CFURL},
+};
+use core_services::{kLSLaunchDefaults, LSLaunchURLSpec, LSOpenFromURLSpec, TCFType};
+use ipc_channel::ipc::{IpcOneShotServer, IpcReceiver, IpcSender};
+use serde::Deserialize;
+use std::{ffi::OsStr, fs, path::PathBuf, ptr};
+
+#[derive(Parser)]
+#[clap(name = "zed", global_setting(clap::AppSettings::NoAutoVersion))]
+struct Args {
+    /// Wait for all of the given paths to be closed before exiting.
+    #[clap(short, long)]
+    wait: bool,
+    /// A sequence of space-separated paths that you want to open.
+    #[clap()]
+    paths: Vec<PathBuf>,
+    /// Print Zed's version and the app path.
+    #[clap(short, long)]
+    version: bool,
+    /// Custom Zed.app path
+    #[clap(short, long)]
+    bundle_path: Option<PathBuf>,
+}
+
+#[derive(Debug, Deserialize)]
+struct InfoPlist {
+    #[serde(rename = "CFBundleShortVersionString")]
+    bundle_short_version_string: String,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    let bundle_path = if let Some(bundle_path) = args.bundle_path {
+        bundle_path.canonicalize()?
+    } else {
+        locate_bundle()?
+    };
+
+    if args.version {
+        let plist_path = bundle_path.join("Contents/Info.plist");
+        let plist = plist::from_file::<_, InfoPlist>(plist_path)?;
+        println!(
+            "Zed {} – {}",
+            plist.bundle_short_version_string,
+            bundle_path.to_string_lossy()
+        );
+        return Ok(());
+    }
+
+    let (tx, rx) = launch_app(bundle_path)?;
+
+    tx.send(CliRequest::Open {
+        paths: args
+            .paths
+            .into_iter()
+            .map(|path| fs::canonicalize(path).map_err(|error| anyhow!(error)))
+            .collect::<Result<Vec<PathBuf>>>()?,
+        wait: args.wait,
+    })?;
+
+    while let Ok(response) = rx.recv() {
+        match response {
+            CliResponse::Ping => {}
+            CliResponse::Stdout { message } => println!("{message}"),
+            CliResponse::Stderr { message } => eprintln!("{message}"),
+            CliResponse::Exit { status } => std::process::exit(status),
+        }
+    }
+
+    Ok(())
+}
+
+fn locate_bundle() -> Result<PathBuf> {
+    let cli_path = std::env::current_exe()?.canonicalize()?;
+    let mut app_path = cli_path.clone();
+    while app_path.extension() != Some(OsStr::new("app")) {
+        if !app_path.pop() {
+            return Err(anyhow!("cannot find app bundle containing {:?}", cli_path));
+        }
+    }
+    Ok(app_path)
+}
+
+fn launch_app(app_path: PathBuf) -> Result<(IpcSender<CliRequest>, IpcReceiver<CliResponse>)> {
+    let (server, server_name) = IpcOneShotServer::<IpcHandshake>::new()?;
+    let url = format!("zed-cli://{server_name}");
+
+    let status = unsafe {
+        let app_url =
+            CFURL::from_path(&app_path, true).ok_or_else(|| anyhow!("invalid app path"))?;
+        let url_to_open = CFURL::wrap_under_create_rule(CFURLCreateWithBytes(
+            ptr::null(),
+            url.as_ptr(),
+            url.len() as CFIndex,
+            kCFStringEncodingUTF8,
+            ptr::null(),
+        ));
+        let urls_to_open = CFArray::from_copyable(&[url_to_open.as_concrete_TypeRef()]);
+        LSOpenFromURLSpec(
+            &LSLaunchURLSpec {
+                appURL: app_url.as_concrete_TypeRef(),
+                itemURLs: urls_to_open.as_concrete_TypeRef(),
+                passThruParams: ptr::null(),
+                launchFlags: kLSLaunchDefaults,
+                asyncRefCon: ptr::null_mut(),
+            },
+            ptr::null_mut(),
+        )
+    };
+
+    if status == 0 {
+        let (_, handshake) = server.accept()?;
+        Ok((handshake.requests, handshake.responses))
+    } else {
+        Err(anyhow!("cannot start {:?}", app_path))
+    }
+}

crates/client/Cargo.toml

@@ -5,11 +5,13 @@ edition = "2021"
 
 [lib]
 path = "src/client.rs"
+doctest = false
 
 [features]
-test-support = ["gpui/test-support", "rpc/test-support"]
+test-support = ["collections/test-support", "gpui/test-support", "rpc/test-support"]
 
 [dependencies]
+collections = { path = "../collections" }
 gpui = { path = "../gpui" }
 util = { path = "../util" }
 rpc = { path = "../rpc" }
@@ -19,17 +21,19 @@ async-recursion = "0.3"
 async-tungstenite = { version = "0.16", features = ["async-tls"] }
 futures = "0.3"
 image = "0.23"
+isahc = "1.7"
 lazy_static = "1.4.0"
-log = "0.4"
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 parking_lot = "0.11.1"
 postage = { version = "0.4.1", features = ["futures-traits"] }
 rand = "0.8.3"
 smol = "1.2.5"
-surf = "2.2"
 thiserror = "1.0.29"
-time = "0.3"
+time = { version = "0.3", features = ["serde", "serde-well-known"] }
 tiny_http = "0.8"
+url = "2.2"
 
 [dev-dependencies]
+collections = { path = "../collections", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 rpc = { path = "../rpc", features = ["test-support"] }

crates/client/src/channel.rs

@@ -181,7 +181,7 @@ impl Entity for Channel {
 
 impl Channel {
     pub fn init(rpc: &Arc<Client>) {
-        rpc.add_entity_message_handler(Self::handle_message_sent);
+        rpc.add_model_message_handler(Self::handle_message_sent);
     }
 
     pub fn new(
@@ -500,7 +500,7 @@ async fn messages_from_proto(
         .collect();
     user_store
         .update(cx, |user_store, cx| {
-            user_store.load_users(unique_user_ids, cx)
+            user_store.get_users(unique_user_ids, cx)
         })
         .await?;
 
@@ -594,14 +594,13 @@ mod tests {
     use super::*;
     use crate::test::{FakeHttpClient, FakeServer};
     use gpui::TestAppContext;
-    use surf::http::Response;
 
     #[gpui::test]
-    async fn test_channel_messages(mut cx: TestAppContext) {
+    async fn test_channel_messages(cx: &mut TestAppContext) {
         cx.foreground().forbid_parking();
 
         let user_id = 5;
-        let http_client = FakeHttpClient::new(|_| async move { Ok(Response::new(404)) });
+        let http_client = FakeHttpClient::with_404_response();
         let mut client = Client::new(http_client.clone());
         let server = FakeServer::for_client(user_id, &mut client, &cx).await;
 
@@ -609,7 +608,7 @@ mod tests {
         let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http_client, cx));
 
         let channel_list = cx.add_model(|cx| ChannelList::new(user_store, client.clone(), cx));
-        channel_list.read_with(&cx, |list, _| assert_eq!(list.available_channels(), None));
+        channel_list.read_with(cx, |list, _| assert_eq!(list.available_channels(), None));
 
         // Get the available channels.
         let get_channels = server.receive::<proto::GetChannels>().await.unwrap();
@@ -625,7 +624,7 @@ mod tests {
             )
             .await;
         channel_list.next_notification(&cx).await;
-        channel_list.read_with(&cx, |list, _| {
+        channel_list.read_with(cx, |list, _| {
             assert_eq!(
                 list.available_channels().unwrap(),
                 &[ChannelDetails {
@@ -640,7 +639,7 @@ mod tests {
         server
             .respond(
                 get_users.receipt(),
-                proto::GetUsersResponse {
+                proto::UsersResponse {
                     users: vec![proto::User {
                         id: 5,
                         github_login: "nathansobo".into(),
@@ -652,12 +651,12 @@ mod tests {
 
         // Join a channel and populate its existing messages.
         let channel = channel_list
-            .update(&mut cx, |list, cx| {
+            .update(cx, |list, cx| {
                 let channel_id = list.available_channels().unwrap()[0].id;
                 list.get_channel(channel_id, cx)
             })
             .unwrap();
-        channel.read_with(&cx, |channel, _| assert!(channel.messages().is_empty()));
+        channel.read_with(cx, |channel, _| assert!(channel.messages().is_empty()));
         let join_channel = server.receive::<proto::JoinChannel>().await.unwrap();
         server
             .respond(
@@ -691,7 +690,7 @@ mod tests {
         server
             .respond(
                 get_users.receipt(),
-                proto::GetUsersResponse {
+                proto::UsersResponse {
                     users: vec![proto::User {
                         id: 6,
                         github_login: "maxbrunsfeld".into(),
@@ -708,7 +707,7 @@ mod tests {
                 new_count: 2,
             }
         );
-        channel.read_with(&cx, |channel, _| {
+        channel.read_with(cx, |channel, _| {
             assert_eq!(
                 channel
                     .messages_in_range(0..2)
@@ -723,7 +722,7 @@ mod tests {
 
         // Receive a new message.
         server.send(proto::ChannelMessageSent {
-            channel_id: channel.read_with(&cx, |channel, _| channel.details.id),
+            channel_id: channel.read_with(cx, |channel, _| channel.details.id),
             message: Some(proto::ChannelMessage {
                 id: 12,
                 body: "c".into(),
@@ -739,7 +738,7 @@ mod tests {
         server
             .respond(
                 get_users.receipt(),
-                proto::GetUsersResponse {
+                proto::UsersResponse {
                     users: vec![proto::User {
                         id: 7,
                         github_login: "as-cii".into(),
@@ -756,7 +755,7 @@ mod tests {
                 new_count: 1,
             }
         );
-        channel.read_with(&cx, |channel, _| {
+        channel.read_with(cx, |channel, _| {
             assert_eq!(
                 channel
                     .messages_in_range(2..3)
@@ -767,7 +766,7 @@ mod tests {
         });
 
         // Scroll up to view older messages.
-        channel.update(&mut cx, |channel, cx| {
+        channel.update(cx, |channel, cx| {
             assert!(channel.load_more_messages(cx));
         });
         let get_messages = server.receive::<proto::GetChannelMessages>().await.unwrap();
@@ -805,7 +804,7 @@ mod tests {
                 new_count: 2,
             }
         );
-        channel.read_with(&cx, |channel, _| {
+        channel.read_with(cx, |channel, _| {
             assert_eq!(
                 channel
                     .messages_in_range(0..2)

crates/client/src/client.rs

@@ -11,10 +11,10 @@ use async_tungstenite::tungstenite::{
     error::Error as WebsocketError,
     http::{Request, StatusCode},
 };
-use futures::{future::LocalBoxFuture, FutureExt, StreamExt};
+use futures::{future::LocalBoxFuture, FutureExt, SinkExt, StreamExt, TryStreamExt};
 use gpui::{
-    action, AnyModelHandle, AnyWeakModelHandle, AsyncAppContext, Entity, ModelContext, ModelHandle,
-    MutableAppContext, Task,
+    actions, AnyModelHandle, AnyViewHandle, AnyWeakModelHandle, AnyWeakViewHandle, AsyncAppContext,
+    Entity, ModelContext, ModelHandle, MutableAppContext, Task, View, ViewContext, ViewHandle,
 };
 use http::HttpClient;
 use lazy_static::lazy_static;
@@ -34,8 +34,8 @@ use std::{
     },
     time::{Duration, Instant},
 };
-use surf::{http::Method, Url};
 use thiserror::Error;
+use url::Url;
 use util::{ResultExt, TryFutureExt};
 
 pub use channel::*;
@@ -43,19 +43,21 @@ pub use rpc::*;
 pub use user::*;
 
 lazy_static! {
-    static ref ZED_SERVER_URL: String =
+    pub static ref ZED_SERVER_URL: String =
         std::env::var("ZED_SERVER_URL").unwrap_or("https://zed.dev".to_string());
-    static ref IMPERSONATE_LOGIN: Option<String> = std::env::var("ZED_IMPERSONATE")
+    pub static ref IMPERSONATE_LOGIN: Option<String> = std::env::var("ZED_IMPERSONATE")
         .ok()
         .and_then(|s| if s.is_empty() { None } else { Some(s) });
 }
 
-action!(Authenticate);
+pub const ZED_SECRET_CLIENT_TOKEN: &'static str = "618033988749894";
+
+actions!(client, [Authenticate]);
 
 pub fn init(rpc: Arc<Client>, cx: &mut MutableAppContext) {
     cx.add_global_action(move |_: &Authenticate, cx| {
         let rpc = rpc.clone();
-        cx.spawn(|cx| async move { rpc.authenticate_and_connect(&cx).log_err().await })
+        cx.spawn(|cx| async move { rpc.authenticate_and_connect(true, &cx).log_err().await })
             .detach();
     });
 }
@@ -65,17 +67,23 @@ pub struct Client {
     peer: Arc<Peer>,
     http: Arc<dyn HttpClient>,
     state: RwLock<ClientState>,
-    authenticate:
+
+    #[cfg(any(test, feature = "test-support"))]
+    authenticate: RwLock<
         Option<Box<dyn 'static + Send + Sync + Fn(&AsyncAppContext) -> Task<Result<Credentials>>>>,
-    establish_connection: Option<
-        Box<
-            dyn 'static
-                + Send
-                + Sync
-                + Fn(
-                    &Credentials,
-                    &AsyncAppContext,
-                ) -> Task<Result<Connection, EstablishConnectionError>>,
+    >,
+    #[cfg(any(test, feature = "test-support"))]
+    establish_connection: RwLock<
+        Option<
+            Box<
+                dyn 'static
+                    + Send
+                    + Sync
+                    + Fn(
+                        &Credentials,
+                        &AsyncAppContext,
+                    ) -> Task<Result<Connection, EstablishConnectionError>>,
+            >,
         >,
     >,
 }
@@ -89,9 +97,11 @@ pub enum EstablishConnectionError {
     #[error("{0}")]
     Other(#[from] anyhow::Error),
     #[error("{0}")]
+    Http(#[from] http::Error),
+    #[error("{0}")]
     Io(#[from] std::io::Error),
     #[error("{0}")]
-    Http(#[from] async_tungstenite::tungstenite::http::Error),
+    Websocket(#[from] async_tungstenite::tungstenite::http::Error),
 }
 
 impl From<WebsocketError> for EstablishConnectionError {
@@ -113,7 +123,7 @@ impl EstablishConnectionError {
     }
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum Status {
     SignedOut,
     UpgradeRequired,
@@ -127,30 +137,46 @@ pub enum Status {
     ReconnectionError { next_reconnection: Instant },
 }
 
+impl Status {
+    pub fn is_connected(&self) -> bool {
+        matches!(self, Self::Connected { .. })
+    }
+}
+
 struct ClientState {
     credentials: Option<Credentials>,
     status: (watch::Sender<Status>, watch::Receiver<Status>),
-    entity_id_extractors: HashMap<TypeId, Box<dyn Send + Sync + Fn(&dyn AnyTypedEnvelope) -> u64>>,
-    _maintain_connection: Option<Task<()>>,
-    heartbeat_interval: Duration,
-
-    models_by_entity_type_and_remote_id: HashMap<(TypeId, u64), AnyWeakModelHandle>,
-    models_by_message_type: HashMap<TypeId, AnyModelHandle>,
-    model_types_by_message_type: HashMap<TypeId, TypeId>,
+    entity_id_extractors: HashMap<TypeId, fn(&dyn AnyTypedEnvelope) -> u64>,
+    _reconnect_task: Option<Task<()>>,
+    reconnect_interval: Duration,
+    entities_by_type_and_remote_id: HashMap<(TypeId, u64), AnyWeakEntityHandle>,
+    models_by_message_type: HashMap<TypeId, AnyWeakModelHandle>,
+    entity_types_by_message_type: HashMap<TypeId, TypeId>,
     message_handlers: HashMap<
         TypeId,
         Arc<
             dyn Send
                 + Sync
                 + Fn(
-                    AnyModelHandle,
+                    AnyEntityHandle,
                     Box<dyn AnyTypedEnvelope>,
+                    &Arc<Client>,
                     AsyncAppContext,
                 ) -> LocalBoxFuture<'static, Result<()>>,
         >,
     >,
 }
 
+enum AnyWeakEntityHandle {
+    Model(AnyWeakModelHandle),
+    View(AnyWeakViewHandle),
+}
+
+enum AnyEntityHandle {
+    Model(AnyModelHandle),
+    View(AnyViewHandle),
+}
+
 #[derive(Clone, Debug)]
 pub struct Credentials {
     pub user_id: u64,
@@ -163,11 +189,11 @@ impl Default for ClientState {
             credentials: None,
             status: watch::channel_with(Status::SignedOut),
             entity_id_extractors: Default::default(),
-            _maintain_connection: None,
-            heartbeat_interval: Duration::from_secs(5),
+            _reconnect_task: None,
+            reconnect_interval: Duration::from_secs(5),
             models_by_message_type: Default::default(),
-            models_by_entity_type_and_remote_id: Default::default(),
-            model_types_by_message_type: Default::default(),
+            entities_by_type_and_remote_id: Default::default(),
+            entity_types_by_message_type: Default::default(),
             message_handlers: Default::default(),
         }
     }
@@ -190,13 +216,13 @@ impl Drop for Subscription {
             Subscription::Entity { client, id } => {
                 if let Some(client) = client.upgrade() {
                     let mut state = client.state.write();
-                    let _ = state.models_by_entity_type_and_remote_id.remove(id);
+                    let _ = state.entities_by_type_and_remote_id.remove(id);
                 }
             }
             Subscription::Message { client, id } => {
                 if let Some(client) = client.upgrade() {
                     let mut state = client.state.write();
-                    let _ = state.model_types_by_message_type.remove(id);
+                    let _ = state.entity_types_by_message_type.remove(id);
                     let _ = state.message_handlers.remove(id);
                 }
             }
@@ -215,8 +241,11 @@ impl Client {
             peer: Peer::new(),
             http,
             state: Default::default(),
-            authenticate: None,
-            establish_connection: None,
+
+            #[cfg(any(test, feature = "test-support"))]
+            authenticate: Default::default(),
+            #[cfg(any(test, feature = "test-support"))]
+            establish_connection: Default::default(),
         })
     }
 
@@ -229,23 +258,34 @@ impl Client {
     }
 
     #[cfg(any(test, feature = "test-support"))]
-    pub fn override_authenticate<F>(&mut self, authenticate: F) -> &mut Self
+    pub fn tear_down(&self) {
+        let mut state = self.state.write();
+        state._reconnect_task.take();
+        state.message_handlers.clear();
+        state.models_by_message_type.clear();
+        state.entities_by_type_and_remote_id.clear();
+        state.entity_id_extractors.clear();
+        self.peer.reset();
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn override_authenticate<F>(&self, authenticate: F) -> &Self
     where
         F: 'static + Send + Sync + Fn(&AsyncAppContext) -> Task<Result<Credentials>>,
     {
-        self.authenticate = Some(Box::new(authenticate));
+        *self.authenticate.write() = Some(Box::new(authenticate));
         self
     }
 
     #[cfg(any(test, feature = "test-support"))]
-    pub fn override_establish_connection<F>(&mut self, connect: F) -> &mut Self
+    pub fn override_establish_connection<F>(&self, connect: F) -> &Self
     where
         F: 'static
             + Send
             + Sync
             + Fn(&Credentials, &AsyncAppContext) -> Task<Result<Connection, EstablishConnectionError>>,
     {
-        self.establish_connection = Some(Box::new(connect));
+        *self.establish_connection.write() = Some(Box::new(connect));
         self
     }
 
@@ -262,61 +302,72 @@ impl Client {
     }
 
     fn set_status(self: &Arc<Self>, status: Status, cx: &AsyncAppContext) {
+        log::info!("set status on client {}: {:?}", self.id, status);
         let mut state = self.state.write();
         *state.status.0.borrow_mut() = status;
 
         match status {
             Status::Connected { .. } => {
-                let heartbeat_interval = state.heartbeat_interval;
-                let this = self.clone();
-                let foreground = cx.foreground();
-                state._maintain_connection = Some(cx.foreground().spawn(async move {
-                    loop {
-                        foreground.timer(heartbeat_interval).await;
-                        let _ = this.request(proto::Ping {}).await;
-                    }
-                }));
+                state._reconnect_task = None;
             }
             Status::ConnectionLost => {
                 let this = self.clone();
-                let foreground = cx.foreground();
-                let heartbeat_interval = state.heartbeat_interval;
-                state._maintain_connection = Some(cx.spawn(|cx| async move {
+                let reconnect_interval = state.reconnect_interval;
+                state._reconnect_task = Some(cx.spawn(|cx| async move {
                     let mut rng = StdRng::from_entropy();
                     let mut delay = Duration::from_millis(100);
-                    while let Err(error) = this.authenticate_and_connect(&cx).await {
+                    while let Err(error) = this.authenticate_and_connect(true, &cx).await {
                         log::error!("failed to connect {}", error);
-                        this.set_status(
-                            Status::ReconnectionError {
-                                next_reconnection: Instant::now() + delay,
-                            },
-                            &cx,
-                        );
-                        foreground.timer(delay).await;
-                        delay = delay
-                            .mul_f32(rng.gen_range(1.0..=2.0))
-                            .min(heartbeat_interval);
+                        if matches!(*this.status().borrow(), Status::ConnectionError) {
+                            this.set_status(
+                                Status::ReconnectionError {
+                                    next_reconnection: Instant::now() + delay,
+                                },
+                                &cx,
+                            );
+                            cx.background().timer(delay).await;
+                            delay = delay
+                                .mul_f32(rng.gen_range(1.0..=2.0))
+                                .min(reconnect_interval);
+                        } else {
+                            break;
+                        }
                     }
                 }));
             }
             Status::SignedOut | Status::UpgradeRequired => {
-                state._maintain_connection.take();
+                state._reconnect_task.take();
             }
             _ => {}
         }
     }
 
+    pub fn add_view_for_remote_entity<T: View>(
+        self: &Arc<Self>,
+        remote_id: u64,
+        cx: &mut ViewContext<T>,
+    ) -> Subscription {
+        let id = (TypeId::of::<T>(), remote_id);
+        self.state
+            .write()
+            .entities_by_type_and_remote_id
+            .insert(id, AnyWeakEntityHandle::View(cx.weak_handle().into()));
+        Subscription::Entity {
+            client: Arc::downgrade(self),
+            id,
+        }
+    }
+
     pub fn add_model_for_remote_entity<T: Entity>(
         self: &Arc<Self>,
         remote_id: u64,
         cx: &mut ModelContext<T>,
     ) -> Subscription {
-        let handle = AnyModelHandle::from(cx.handle());
-        let mut state = self.state.write();
         let id = (TypeId::of::<T>(), remote_id);
-        state
-            .models_by_entity_type_and_remote_id
-            .insert(id, handle.downgrade());
+        self.state
+            .write()
+            .entities_by_type_and_remote_id
+            .insert(id, AnyWeakEntityHandle::Model(cx.weak_handle().into()));
         Subscription::Entity {
             client: Arc::downgrade(self),
             id,
@@ -339,15 +390,19 @@ impl Client {
     {
         let message_type_id = TypeId::of::<M>();
 
-        let client = self.clone();
         let mut state = self.state.write();
         state
             .models_by_message_type
-            .insert(message_type_id, model.into());
+            .insert(message_type_id, model.downgrade().into());
 
         let prev_handler = state.message_handlers.insert(
             message_type_id,
-            Arc::new(move |handle, envelope, cx| {
+            Arc::new(move |handle, envelope, client, cx| {
+                let handle = if let AnyEntityHandle::Model(handle) = handle {
+                    handle
+                } else {
+                    unreachable!();
+                };
                 let model = handle.downcast::<E>().unwrap();
                 let envelope = envelope.into_any().downcast::<TypedEnvelope<M>>().unwrap();
                 handler(model, *envelope, client.clone(), cx).boxed_local()
@@ -363,7 +418,26 @@ impl Client {
         }
     }
 
-    pub fn add_entity_message_handler<M, E, H, F>(self: &Arc<Self>, handler: H)
+    pub fn add_view_message_handler<M, E, H, F>(self: &Arc<Self>, handler: H)
+    where
+        M: EntityMessage,
+        E: View,
+        H: 'static
+            + Send
+            + Sync
+            + Fn(ViewHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
+        F: 'static + Future<Output = Result<()>>,
+    {
+        self.add_entity_message_handler::<M, E, _, _>(move |handle, message, client, cx| {
+            if let AnyEntityHandle::View(handle) = handle {
+                handler(handle.downcast::<E>().unwrap(), message, client, cx)
+            } else {
+                unreachable!();
+            }
+        })
+    }
+
+    pub fn add_model_message_handler<M, E, H, F>(self: &Arc<Self>, handler: H)
     where
         M: EntityMessage,
         E: Entity,
@@ -372,34 +446,51 @@ impl Client {
             + Sync
             + Fn(ModelHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
         F: 'static + Future<Output = Result<()>>,
+    {
+        self.add_entity_message_handler::<M, E, _, _>(move |handle, message, client, cx| {
+            if let AnyEntityHandle::Model(handle) = handle {
+                handler(handle.downcast::<E>().unwrap(), message, client, cx)
+            } else {
+                unreachable!();
+            }
+        })
+    }
+
+    fn add_entity_message_handler<M, E, H, F>(self: &Arc<Self>, handler: H)
+    where
+        M: EntityMessage,
+        E: Entity,
+        H: 'static
+            + Send
+            + Sync
+            + Fn(AnyEntityHandle, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
+        F: 'static + Future<Output = Result<()>>,
     {
         let model_type_id = TypeId::of::<E>();
         let message_type_id = TypeId::of::<M>();
 
-        let client = self.clone();
         let mut state = self.state.write();
         state
-            .model_types_by_message_type
+            .entity_types_by_message_type
             .insert(message_type_id, model_type_id);
         state
             .entity_id_extractors
             .entry(message_type_id)
             .or_insert_with(|| {
-                Box::new(|envelope| {
-                    let envelope = envelope
+                |envelope| {
+                    envelope
                         .as_any()
                         .downcast_ref::<TypedEnvelope<M>>()
-                        .unwrap();
-                    envelope.payload.remote_entity_id()
-                })
+                        .unwrap()
+                        .payload
+                        .remote_entity_id()
+                }
             });
-
         let prev_handler = state.message_handlers.insert(
             message_type_id,
-            Arc::new(move |handle, envelope, cx| {
-                let model = handle.downcast::<E>().unwrap();
+            Arc::new(move |handle, envelope, client, cx| {
                 let envelope = envelope.into_any().downcast::<TypedEnvelope<M>>().unwrap();
-                handler(model, *envelope, client.clone(), cx).boxed_local()
+                handler(handle, *envelope, client.clone(), cx).boxed_local()
             }),
         );
         if prev_handler.is_some() {
@@ -407,7 +498,7 @@ impl Client {
         }
     }
 
-    pub fn add_entity_request_handler<M, E, H, F>(self: &Arc<Self>, handler: H)
+    pub fn add_model_request_handler<M, E, H, F>(self: &Arc<Self>, handler: H)
     where
         M: EntityMessage + RequestMessage,
         E: Entity,
@@ -417,29 +508,56 @@ impl Client {
             + Fn(ModelHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
         F: 'static + Future<Output = Result<M::Response>>,
     {
-        self.add_entity_message_handler(move |model, envelope, client, cx| {
-            let receipt = envelope.receipt();
-            let response = handler(model, envelope, client.clone(), cx);
-            async move {
-                match response.await {
-                    Ok(response) => {
-                        client.respond(receipt, response)?;
-                        Ok(())
-                    }
-                    Err(error) => {
-                        client.respond_with_error(
-                            receipt,
-                            proto::Error {
-                                message: error.to_string(),
-                            },
-                        )?;
-                        Err(error)
-                    }
-                }
-            }
+        self.add_model_message_handler(move |entity, envelope, client, cx| {
+            Self::respond_to_request::<M, _>(
+                envelope.receipt(),
+                handler(entity, envelope, client.clone(), cx),
+                client,
+            )
         })
     }
 
+    pub fn add_view_request_handler<M, E, H, F>(self: &Arc<Self>, handler: H)
+    where
+        M: EntityMessage + RequestMessage,
+        E: View,
+        H: 'static
+            + Send
+            + Sync
+            + Fn(ViewHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
+        F: 'static + Future<Output = Result<M::Response>>,
+    {
+        self.add_view_message_handler(move |entity, envelope, client, cx| {
+            Self::respond_to_request::<M, _>(
+                envelope.receipt(),
+                handler(entity, envelope, client.clone(), cx),
+                client,
+            )
+        })
+    }
+
+    async fn respond_to_request<T: RequestMessage, F: Future<Output = Result<T::Response>>>(
+        receipt: Receipt<T>,
+        response: F,
+        client: Arc<Self>,
+    ) -> Result<()> {
+        match response.await {
+            Ok(response) => {
+                client.respond(receipt, response)?;
+                Ok(())
+            }
+            Err(error) => {
+                client.respond_with_error(
+                    receipt,
+                    proto::Error {
+                        message: error.to_string(),
+                    },
+                )?;
+                Err(error)
+            }
+        }
+    }
+
     pub fn has_keychain_credentials(&self, cx: &AsyncAppContext) -> bool {
         read_credentials_from_keychain(cx).is_some()
     }
@@ -447,6 +565,7 @@ impl Client {
     #[async_recursion(?Send)]
     pub async fn authenticate_and_connect(
         self: &Arc<Self>,
+        try_keychain: bool,
         cx: &AsyncAppContext,
     ) -> anyhow::Result<()> {
         let was_disconnected = match *self.status().borrow() {
@@ -468,23 +587,22 @@ impl Client {
             self.set_status(Status::Reauthenticating, cx)
         }
 
-        let mut used_keychain = false;
-        let credentials = self.state.read().credentials.clone();
-        let credentials = if let Some(credentials) = credentials {
-            credentials
-        } else if let Some(credentials) = read_credentials_from_keychain(cx) {
-            used_keychain = true;
-            credentials
-        } else {
-            let credentials = match self.authenticate(&cx).await {
+        let mut read_from_keychain = false;
+        let mut credentials = self.state.read().credentials.clone();
+        if credentials.is_none() && try_keychain {
+            credentials = read_credentials_from_keychain(cx);
+            read_from_keychain = credentials.is_some();
+        }
+        if credentials.is_none() {
+            credentials = Some(match self.authenticate(&cx).await {
                 Ok(credentials) => credentials,
                 Err(err) => {
                     self.set_status(Status::ConnectionError, cx);
                     return Err(err);
                 }
-            };
-            credentials
-        };
+            });
+        }
+        let credentials = credentials.unwrap();
 
         if was_disconnected {
             self.set_status(Status::Connecting, cx);
@@ -495,7 +613,7 @@ impl Client {
         match self.establish_connection(&credentials, cx).await {
             Ok(conn) => {
                 self.state.write().credentials = Some(credentials.clone());
-                if !used_keychain && IMPERSONATE_LOGIN.is_none() {
+                if !read_from_keychain && IMPERSONATE_LOGIN.is_none() {
                     write_credentials_to_keychain(&credentials, cx).log_err();
                 }
                 self.set_connection(conn, cx).await;
@@ -503,10 +621,10 @@ impl Client {
             }
             Err(EstablishConnectionError::Unauthorized) => {
                 self.state.write().credentials.take();
-                if used_keychain {
+                if read_from_keychain {
                     cx.platform().delete_credentials(&ZED_SERVER_URL).log_err();
                     self.set_status(Status::SignedOut, cx);
-                    self.authenticate_and_connect(cx).await
+                    self.authenticate_and_connect(false, cx).await
                 } else {
                     self.set_status(Status::ConnectionError, cx);
                     Err(EstablishConnectionError::Unauthorized)?
@@ -524,39 +642,51 @@ impl Client {
     }
 
     async fn set_connection(self: &Arc<Self>, conn: Connection, cx: &AsyncAppContext) {
-        let (connection_id, handle_io, mut incoming) = self.peer.add_connection(conn).await;
+        let executor = cx.background();
+        log::info!("add connection to peer");
+        let (connection_id, handle_io, mut incoming) = self
+            .peer
+            .add_connection(conn, move |duration| executor.timer(duration))
+            .await;
+        log::info!("set status to connected {}", connection_id);
+        self.set_status(Status::Connected { connection_id }, cx);
         cx.foreground()
             .spawn({
                 let cx = cx.clone();
                 let this = self.clone();
                 async move {
+                    let mut message_id = 0_usize;
                     while let Some(message) = incoming.next().await {
                         let mut state = this.state.write();
-                        let payload_type_id = message.payload_type_id();
+                        message_id += 1;
                         let type_name = message.payload_type_name();
+                        let payload_type_id = message.payload_type_id();
+                        let sender_id = message.original_sender_id().map(|id| id.0);
 
                         let model = state
                             .models_by_message_type
                             .get(&payload_type_id)
-                            .cloned()
+                            .and_then(|model| model.upgrade(&cx))
+                            .map(AnyEntityHandle::Model)
                             .or_else(|| {
-                                let model_type_id =
-                                    *state.model_types_by_message_type.get(&payload_type_id)?;
+                                let entity_type_id =
+                                    *state.entity_types_by_message_type.get(&payload_type_id)?;
                                 let entity_id = state
                                     .entity_id_extractors
                                     .get(&message.payload_type_id())
                                     .map(|extract_entity_id| {
                                         (extract_entity_id)(message.as_ref())
                                     })?;
-                                let model = state
-                                    .models_by_entity_type_and_remote_id
-                                    .get(&(model_type_id, entity_id))?;
-                                if let Some(model) = model.upgrade(&cx) {
-                                    Some(model)
+
+                                let entity = state
+                                    .entities_by_type_and_remote_id
+                                    .get(&(entity_type_id, entity_id))?;
+                                if let Some(entity) = entity.upgrade(&cx) {
+                                    Some(entity)
                                 } else {
                                     state
-                                        .models_by_entity_type_and_remote_id
-                                        .remove(&(model_type_id, entity_id));
+                                        .entities_by_type_and_remote_id
+                                        .remove(&(entity_type_id, entity_id));
                                     None
                                 }
                             });
@@ -571,12 +701,14 @@ impl Client {
                         if let Some(handler) = state.message_handlers.get(&payload_type_id).cloned()
                         {
                             drop(state); // Avoid deadlocks if the handler interacts with rpc::Client
-                            let future = handler(model, message, cx.clone());
+                            let future = handler(model, message, &this, cx.clone());
 
                             let client_id = this.id;
                             log::debug!(
-                                "rpc message received. client_id:{}, name:{}",
+                                "rpc message received. client_id:{}, message_id:{}, sender_id:{:?}, type:{}",
                                 client_id,
+                                message_id,
+                                sender_id,
                                 type_name
                             );
                             cx.foreground()
@@ -584,15 +716,19 @@ impl Client {
                                     match future.await {
                                         Ok(()) => {
                                             log::debug!(
-                                                "rpc message handled. client_id:{}, name:{}",
+                                                "rpc message handled. client_id:{}, message_id:{}, sender_id:{:?}, type:{}",
                                                 client_id,
+                                                message_id,
+                                                sender_id,
                                                 type_name
                                             );
                                         }
                                         Err(error) => {
                                             log::error!(
-                                                "error handling message. client_id:{}, name:{}, {}",
+                                                "error handling message. client_id:{}, message_id:{}, sender_id:{:?}, type:{}, error:{:?}",
                                                 client_id,
+                                                message_id,
+                                                sender_id,
                                                 type_name,
                                                 error
                                             );
@@ -603,20 +739,25 @@ impl Client {
                         } else {
                             log::info!("unhandled message {}", type_name);
                         }
+
+                        // Don't starve the main thread when receiving lots of messages at once.
+                        smol::future::yield_now().await;
                     }
                 }
             })
             .detach();
 
-        self.set_status(Status::Connected { connection_id }, cx);
-
         let handle_io = cx.background().spawn(handle_io);
         let this = self.clone();
         let cx = cx.clone();
         cx.foreground()
             .spawn(async move {
                 match handle_io.await {
-                    Ok(()) => this.set_status(Status::SignedOut, &cx),
+                    Ok(()) => {
+                        if *this.status().borrow() == (Status::Connected { connection_id }) {
+                            this.set_status(Status::SignedOut, &cx);
+                        }
+                    }
                     Err(err) => {
                         log::error!("connection error: {:?}", err);
                         this.set_status(Status::ConnectionLost, &cx);
@@ -627,11 +768,12 @@ impl Client {
     }
 
     fn authenticate(self: &Arc<Self>, cx: &AsyncAppContext) -> Task<Result<Credentials>> {
-        if let Some(callback) = self.authenticate.as_ref() {
-            callback(cx)
-        } else {
-            self.authenticate_with_browser(cx)
+        #[cfg(any(test, feature = "test-support"))]
+        if let Some(callback) = self.authenticate.read().as_ref() {
+            return callback(cx);
         }
+
+        self.authenticate_with_browser(cx)
     }
 
     fn establish_connection(
@@ -639,11 +781,12 @@ impl Client {
         credentials: &Credentials,
         cx: &AsyncAppContext,
     ) -> Task<Result<Connection, EstablishConnectionError>> {
-        if let Some(callback) = self.establish_connection.as_ref() {
-            callback(credentials, cx)
-        } else {
-            self.establish_websocket_connection(credentials, cx)
+        #[cfg(any(test, feature = "test-support"))]
+        if let Some(callback) = self.establish_connection.read().as_ref() {
+            return callback(credentials, cx);
         }
+
+        self.establish_websocket_connection(credentials, cx)
     }
 
     fn establish_websocket_connection(
@@ -656,35 +799,32 @@ impl Client {
                 "Authorization",
                 format!("{} {}", credentials.user_id, credentials.access_token),
             )
-            .header("X-Zed-Protocol-Version", rpc::PROTOCOL_VERSION);
+            .header("x-zed-protocol-version", rpc::PROTOCOL_VERSION);
 
         let http = self.http.clone();
         cx.background().spawn(async move {
             let mut rpc_url = format!("{}/rpc", *ZED_SERVER_URL);
-            let rpc_request = surf::Request::new(
-                Method::Get,
-                surf::Url::parse(&rpc_url).context("invalid ZED_SERVER_URL")?,
-            );
-            let rpc_response = http.send(rpc_request).await?;
-
+            let rpc_response = http.get(&rpc_url, Default::default(), false).await?;
             if rpc_response.status().is_redirection() {
                 rpc_url = rpc_response
-                    .header("Location")
+                    .headers()
+                    .get("Location")
                     .ok_or_else(|| anyhow!("missing location header in /rpc response"))?
-                    .as_str()
+                    .to_str()
+                    .map_err(|error| EstablishConnectionError::other(error))?
                     .to_string();
             }
             // Until we switch the zed.dev domain to point to the new Next.js app, there
             // will be no redirect required, and the app will connect directly to
             // wss://zed.dev/rpc.
-            else if rpc_response.status() != surf::StatusCode::UpgradeRequired {
+            else if rpc_response.status() != StatusCode::UPGRADE_REQUIRED {
                 Err(anyhow!(
                     "unexpected /rpc response status {}",
                     rpc_response.status()
                 ))?
             }
 
-            let mut rpc_url = surf::Url::parse(&rpc_url).context("invalid rpc url")?;
+            let mut rpc_url = Url::parse(&rpc_url).context("invalid rpc url")?;
             let rpc_host = rpc_url
                 .host_str()
                 .zip(rpc_url.port_or_known_default())
@@ -699,13 +839,21 @@ impl Client {
                     let request = request.uri(rpc_url.as_str()).body(())?;
                     let (stream, _) =
                         async_tungstenite::async_tls::client_async_tls(request, stream).await?;
-                    Ok(Connection::new(stream))
+                    Ok(Connection::new(
+                        stream
+                            .map_err(|error| anyhow!(error))
+                            .sink_map_err(|error| anyhow!(error)),
+                    ))
                 }
                 "http" => {
                     rpc_url.set_scheme("ws").unwrap();
                     let request = request.uri(rpc_url.as_str()).body(())?;
                     let (stream, _) = async_tungstenite::client_async(request, stream).await?;
-                    Ok(Connection::new(stream))
+                    Ok(Connection::new(
+                        stream
+                            .map_err(|error| anyhow!(error))
+                            .sink_map_err(|error| anyhow!(error)),
+                    ))
                 }
                 _ => Err(anyhow!("invalid rpc url: {}", rpc_url))?,
             }
@@ -827,7 +975,7 @@ impl Client {
     ) -> impl Future<Output = Result<T::Response>> {
         let client_id = self.id;
         log::debug!(
-            "rpc request start. client_id: {}. name:{}",
+            "rpc request start. client_id:{}. name:{}",
             client_id,
             T::NAME
         );
@@ -837,7 +985,7 @@ impl Client {
         async move {
             let response = response?.await;
             log::debug!(
-                "rpc request finish. client_id: {}. name:{}",
+                "rpc request finish. client_id:{}. name:{}",
                 client_id,
                 T::NAME
             );
@@ -846,7 +994,7 @@ impl Client {
     }
 
     fn respond<T: RequestMessage>(&self, receipt: Receipt<T>, response: T::Response) -> Result<()> {
-        log::debug!("rpc respond. client_id: {}. name:{}", self.id, T::NAME);
+        log::debug!("rpc respond. client_id:{}. name:{}", self.id, T::NAME);
         self.peer.respond(receipt, response)
     }
 
@@ -855,11 +1003,20 @@ impl Client {
         receipt: Receipt<T>,
         error: proto::Error,
     ) -> Result<()> {
-        log::debug!("rpc respond. client_id: {}. name:{}", self.id, T::NAME);
+        log::debug!("rpc respond. client_id:{}. name:{}", self.id, T::NAME);
         self.peer.respond_with_error(receipt, error)
     }
 }
 
+impl AnyWeakEntityHandle {
+    fn upgrade(&self, cx: &AsyncAppContext) -> Option<AnyEntityHandle> {
+        match self {
+            AnyWeakEntityHandle::Model(handle) => handle.upgrade(cx).map(AnyEntityHandle::Model),
+            AnyWeakEntityHandle::View(handle) => handle.upgrade(cx).map(AnyEntityHandle::View),
+        }
+    }
+}
+
 fn read_credentials_from_keychain(cx: &AsyncAppContext) -> Option<Credentials> {
     if IMPERSONATE_LOGIN.is_some() {
         return None;
@@ -908,27 +1065,7 @@ mod tests {
     use gpui::TestAppContext;
 
     #[gpui::test(iterations = 10)]
-    async fn test_heartbeat(cx: TestAppContext) {
-        cx.foreground().forbid_parking();
-
-        let user_id = 5;
-        let mut client = Client::new(FakeHttpClient::with_404_response());
-        let server = FakeServer::for_client(user_id, &mut client, &cx).await;
-
-        cx.foreground().advance_clock(Duration::from_secs(10));
-        let ping = server.receive::<proto::Ping>().await.unwrap();
-        server.respond(ping.receipt(), proto::Ack {}).await;
-
-        cx.foreground().advance_clock(Duration::from_secs(10));
-        let ping = server.receive::<proto::Ping>().await.unwrap();
-        server.respond(ping.receipt(), proto::Ack {}).await;
-
-        client.disconnect(&cx.to_async()).unwrap();
-        assert!(server.receive::<proto::Ping>().await.is_err());
-    }
-
-    #[gpui::test(iterations = 10)]
-    async fn test_reconnection(cx: TestAppContext) {
+    async fn test_reconnection(cx: &mut TestAppContext) {
         cx.foreground().forbid_parking();
 
         let user_id = 5;
@@ -958,8 +1095,6 @@ mod tests {
         server.roll_access_token();
         server.allow_connections();
         cx.foreground().advance_clock(Duration::from_secs(10));
-        assert_eq!(server.auth_count(), 1);
-        cx.foreground().advance_clock(Duration::from_secs(10));
         while !matches!(status.next().await, Some(Status::Connected { .. })) {}
         assert_eq!(server.auth_count(), 2); // Client re-authenticated due to an invalid token
     }
@@ -976,7 +1111,7 @@ mod tests {
     }
 
     #[gpui::test]
-    async fn test_subscribing_to_entity(mut cx: TestAppContext) {
+    async fn test_subscribing_to_entity(cx: &mut TestAppContext) {
         cx.foreground().forbid_parking();
 
         let user_id = 5;
@@ -985,8 +1120,8 @@ mod tests {
 
         let (done_tx1, mut done_rx1) = smol::channel::unbounded();
         let (done_tx2, mut done_rx2) = smol::channel::unbounded();
-        client.add_entity_message_handler(
-            move |model: ModelHandle<Model>, _: TypedEnvelope<proto::UnshareProject>, _, cx| {
+        client.add_model_message_handler(
+            move |model: ModelHandle<Model>, _: TypedEnvelope<proto::JoinProject>, _, cx| {
                 match model.read_with(&cx, |model, _| model.id) {
                     1 => done_tx1.try_send(()).unwrap(),
                     2 => done_tx2.try_send(()).unwrap(),
@@ -1008,24 +1143,21 @@ mod tests {
             subscription: None,
         });
 
-        let _subscription1 =
-            model1.update(&mut cx, |_, cx| client.add_model_for_remote_entity(1, cx));
-        let _subscription2 =
-            model2.update(&mut cx, |_, cx| client.add_model_for_remote_entity(2, cx));
+        let _subscription1 = model1.update(cx, |_, cx| client.add_model_for_remote_entity(1, cx));
+        let _subscription2 = model2.update(cx, |_, cx| client.add_model_for_remote_entity(2, cx));
         // Ensure dropping a subscription for the same entity type still allows receiving of
         // messages for other entity IDs of the same type.
-        let subscription3 =
-            model3.update(&mut cx, |_, cx| client.add_model_for_remote_entity(3, cx));
+        let subscription3 = model3.update(cx, |_, cx| client.add_model_for_remote_entity(3, cx));
         drop(subscription3);
 
-        server.send(proto::UnshareProject { project_id: 1 });
-        server.send(proto::UnshareProject { project_id: 2 });
+        server.send(proto::JoinProject { project_id: 1 });
+        server.send(proto::JoinProject { project_id: 2 });
         done_rx1.next().await.unwrap();
         done_rx2.next().await.unwrap();
     }
 
     #[gpui::test]
-    async fn test_subscribing_after_dropping_subscription(mut cx: TestAppContext) {
+    async fn test_subscribing_after_dropping_subscription(cx: &mut TestAppContext) {
         cx.foreground().forbid_parking();
 
         let user_id = 5;
@@ -1053,7 +1185,7 @@ mod tests {
     }
 
     #[gpui::test]
-    async fn test_dropping_subscription_in_handler(mut cx: TestAppContext) {
+    async fn test_dropping_subscription_in_handler(cx: &mut TestAppContext) {
         cx.foreground().forbid_parking();
 
         let user_id = 5;
@@ -1070,7 +1202,7 @@ mod tests {
                 async { Ok(()) }
             },
         );
-        model.update(&mut cx, |model, _| {
+        model.update(cx, |model, _| {
             model.subscription = Some(subscription);
         });
         server.send(proto::Ping {});

crates/client/src/http.rs

@@ -1,26 +1,51 @@
 pub use anyhow::{anyhow, Result};
 use futures::future::BoxFuture;
-use std::sync::Arc;
-pub use surf::{
-    http::{Method, Response as ServerResponse},
-    Request, Response, Url,
+use isahc::{
+    config::{Configurable, RedirectPolicy},
+    AsyncBody,
 };
+pub use isahc::{
+    http::{Method, Uri},
+    Error,
+};
+use smol::future::FutureExt;
+use std::sync::Arc;
+pub use url::Url;
+
+pub type Request = isahc::Request<AsyncBody>;
+pub type Response = isahc::Response<AsyncBody>;
 
 pub trait HttpClient: Send + Sync {
-    fn send<'a>(&'a self, req: Request) -> BoxFuture<'a, Result<Response>>;
+    fn send<'a>(&'a self, req: Request) -> BoxFuture<'a, Result<Response, Error>>;
+
+    fn get<'a>(
+        &'a self,
+        uri: &str,
+        body: AsyncBody,
+        follow_redirects: bool,
+    ) -> BoxFuture<'a, Result<Response, Error>> {
+        let request = isahc::Request::builder()
+            .redirect_policy(if follow_redirects {
+                RedirectPolicy::Follow
+            } else {
+                RedirectPolicy::None
+            })
+            .method(Method::GET)
+            .uri(uri)
+            .body(body);
+        match request {
+            Ok(request) => self.send(request),
+            Err(error) => async move { Err(error.into()) }.boxed(),
+        }
+    }
 }
 
 pub fn client() -> Arc<dyn HttpClient> {
-    Arc::new(surf::client())
+    Arc::new(isahc::HttpClient::builder().build().unwrap())
 }
 
-impl HttpClient for surf::Client {
-    fn send<'a>(&'a self, req: Request) -> BoxFuture<'a, Result<Response>> {
-        Box::pin(async move {
-            Ok(self
-                .send(req)
-                .await
-                .map_err(|e| anyhow!("http request failed: {}", e))?)
-        })
+impl HttpClient for isahc::HttpClient {
+    fn send<'a>(&'a self, req: Request) -> BoxFuture<'a, Result<Response, Error>> {
+        Box::pin(async move { self.send_async(req).await })
     }
 }

crates/client/src/test.rs

@@ -1,5 +1,5 @@
 use crate::{
-    http::{HttpClient, Request, Response, ServerResponse},
+    http::{self, HttpClient, Request, Response},
     Client, Connection, Credentials, EstablishConnectionError, UserStore,
 };
 use anyhow::{anyhow, Result};
@@ -28,7 +28,7 @@ struct FakeServerState {
 impl FakeServer {
     pub async fn for_client(
         client_user_id: u64,
-        client: &mut Arc<Client>,
+        client: &Arc<Client>,
         cx: &TestAppContext,
     ) -> Self {
         let server = Self {
@@ -38,15 +38,16 @@ impl FakeServer {
             executor: cx.foreground(),
         };
 
-        Arc::get_mut(client)
-            .unwrap()
+        client
             .override_authenticate({
-                let state = server.state.clone();
+                let state = Arc::downgrade(&server.state);
                 move |cx| {
-                    let mut state = state.lock();
-                    state.auth_count += 1;
-                    let access_token = state.access_token.to_string();
+                    let state = state.clone();
                     cx.spawn(move |_| async move {
+                        let state = state.upgrade().ok_or_else(|| anyhow!("server dropped"))?;
+                        let mut state = state.lock();
+                        state.auth_count += 1;
+                        let access_token = state.access_token.to_string();
                         Ok(Credentials {
                             user_id: client_user_id,
                             access_token,
@@ -55,27 +56,30 @@ impl FakeServer {
                 }
             })
             .override_establish_connection({
-                let peer = server.peer.clone();
-                let state = server.state.clone();
+                let peer = Arc::downgrade(&server.peer).clone();
+                let state = Arc::downgrade(&server.state);
                 move |credentials, cx| {
                     let peer = peer.clone();
                     let state = state.clone();
                     let credentials = credentials.clone();
                     cx.spawn(move |cx| async move {
-                        assert_eq!(credentials.user_id, client_user_id);
-
+                        let state = state.upgrade().ok_or_else(|| anyhow!("server dropped"))?;
+                        let peer = peer.upgrade().ok_or_else(|| anyhow!("server dropped"))?;
                         if state.lock().forbid_connections {
                             Err(EstablishConnectionError::Other(anyhow!(
                                 "server is forbidding connections"
                             )))?
                         }
 
+                        assert_eq!(credentials.user_id, client_user_id);
+
                         if credentials.access_token != state.lock().access_token.to_string() {
                             Err(EstablishConnectionError::Unauthorized)?
                         }
 
                         let (client_conn, server_conn, _) = Connection::in_memory(cx.background());
-                        let (connection_id, io, incoming) = peer.add_connection(server_conn).await;
+                        let (connection_id, io, incoming) =
+                            peer.add_test_connection(server_conn, cx.background()).await;
                         cx.background().spawn(io).detach();
                         let mut state = state.lock();
                         state.connection_id = Some(connection_id);
@@ -86,7 +90,7 @@ impl FakeServer {
             });
 
         client
-            .authenticate_and_connect(&cx.to_async())
+            .authenticate_and_connect(false, &cx.to_async())
             .await
             .unwrap();
         server
@@ -174,15 +178,25 @@ impl FakeServer {
     }
 }
 
+impl Drop for FakeServer {
+    fn drop(&mut self) {
+        self.disconnect();
+    }
+}
+
 pub struct FakeHttpClient {
-    handler:
-        Box<dyn 'static + Send + Sync + Fn(Request) -> BoxFuture<'static, Result<ServerResponse>>>,
+    handler: Box<
+        dyn 'static
+            + Send
+            + Sync
+            + Fn(Request) -> BoxFuture<'static, Result<Response, http::Error>>,
+    >,
 }
 
 impl FakeHttpClient {
     pub fn new<Fut, F>(handler: F) -> Arc<dyn HttpClient>
     where
-        Fut: 'static + Send + Future<Output = Result<ServerResponse>>,
+        Fut: 'static + Send + Future<Output = Result<Response, http::Error>>,
         F: 'static + Send + Sync + Fn(Request) -> Fut,
     {
         Arc::new(Self {
@@ -191,7 +205,12 @@ impl FakeHttpClient {
     }
 
     pub fn with_404_response() -> Arc<dyn HttpClient> {
-        Self::new(|_| async move { Ok(ServerResponse::new(404)) })
+        Self::new(|_| async move {
+            Ok(isahc::Response::builder()
+                .status(404)
+                .body(Default::default())
+                .unwrap())
+        })
     }
 }
 
@@ -202,7 +221,7 @@ impl fmt::Debug for FakeHttpClient {
 }
 
 impl HttpClient for FakeHttpClient {
-    fn send<'a>(&'a self, req: Request) -> BoxFuture<'a, Result<Response>> {
+    fn send<'a>(&'a self, req: Request) -> BoxFuture<'a, Result<Response, crate::http::Error>> {
         let future = (self.handler)(req);
         Box::pin(async move { future.await.map(Into::into) })
     }

crates/client/src/user.rs

@@ -1,15 +1,11 @@
-use super::{
-    http::{HttpClient, Method, Request, Url},
-    proto, Client, Status, TypedEnvelope,
-};
+use super::{http::HttpClient, proto, Client, Status, TypedEnvelope};
 use anyhow::{anyhow, Context, Result};
-use futures::future;
+use collections::{hash_map::Entry, BTreeSet, HashMap, HashSet};
+use futures::{channel::mpsc, future, AsyncReadExt, Future, StreamExt};
 use gpui::{AsyncAppContext, Entity, ImageData, ModelContext, ModelHandle, Task};
 use postage::{prelude::Stream, sink::Sink, watch};
-use std::{
-    collections::{HashMap, HashSet},
-    sync::Arc,
-};
+use rpc::proto::{RequestMessage, UsersResponse};
+use std::sync::{Arc, Weak};
 use util::TryFutureExt as _;
 
 #[derive(Debug)]
@@ -19,37 +15,94 @@ pub struct User {
     pub avatar: Option<Arc<ImageData>>,
 }
 
-#[derive(Debug)]
+impl PartialOrd for User {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(&other))
+    }
+}
+
+impl Ord for User {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.github_login.cmp(&other.github_login)
+    }
+}
+
+impl PartialEq for User {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id && self.github_login == other.github_login
+    }
+}
+
+impl Eq for User {}
+
+#[derive(Debug, PartialEq)]
 pub struct Contact {
     pub user: Arc<User>,
+    pub online: bool,
     pub projects: Vec<ProjectMetadata>,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct ProjectMetadata {
     pub id: u64,
-    pub is_shared: bool,
-    pub worktree_root_names: Vec<String>,
-    pub guests: Vec<Arc<User>>,
+    pub visible_worktree_root_names: Vec<String>,
+    pub guests: BTreeSet<Arc<User>>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ContactRequestStatus {
+    None,
+    RequestSent,
+    RequestReceived,
+    RequestAccepted,
 }
 
 pub struct UserStore {
     users: HashMap<u64, Arc<User>>,
-    update_contacts_tx: watch::Sender<Option<proto::UpdateContacts>>,
+    update_contacts_tx: mpsc::UnboundedSender<UpdateContacts>,
     current_user: watch::Receiver<Option<Arc<User>>>,
-    contacts: Arc<[Contact]>,
-    client: Arc<Client>,
+    contacts: Vec<Arc<Contact>>,
+    incoming_contact_requests: Vec<Arc<User>>,
+    outgoing_contact_requests: Vec<Arc<User>>,
+    pending_contact_requests: HashMap<u64, usize>,
+    invite_info: Option<InviteInfo>,
+    client: Weak<Client>,
     http: Arc<dyn HttpClient>,
     _maintain_contacts: Task<()>,
     _maintain_current_user: Task<()>,
 }
 
-pub enum Event {}
+#[derive(Clone)]
+pub struct InviteInfo {
+    pub count: u32,
+    pub url: Arc<str>,
+}
+
+pub enum Event {
+    Contact {
+        user: Arc<User>,
+        kind: ContactEventKind,
+    },
+    ShowContacts,
+}
+
+#[derive(Clone, Copy)]
+pub enum ContactEventKind {
+    Requested,
+    Accepted,
+    Cancelled,
+}
 
 impl Entity for UserStore {
     type Event = Event;
 }
 
+enum UpdateContacts {
+    Update(proto::UpdateContacts),
+    Wait(postage::barrier::Sender),
+    Clear(postage::barrier::Sender),
+}
+
 impl UserStore {
     pub fn new(
         client: Arc<Client>,
@@ -57,21 +110,26 @@ impl UserStore {
         cx: &mut ModelContext<Self>,
     ) -> Self {
         let (mut current_user_tx, current_user_rx) = watch::channel();
-        let (update_contacts_tx, mut update_contacts_rx) =
-            watch::channel::<Option<proto::UpdateContacts>>();
-        let rpc_subscription =
-            client.add_message_handler(cx.handle(), Self::handle_update_contacts);
+        let (update_contacts_tx, mut update_contacts_rx) = mpsc::unbounded();
+        let rpc_subscriptions = vec![
+            client.add_message_handler(cx.handle(), Self::handle_update_contacts),
+            client.add_message_handler(cx.handle(), Self::handle_update_invite_info),
+            client.add_message_handler(cx.handle(), Self::handle_show_contacts),
+        ];
         Self {
             users: Default::default(),
             current_user: current_user_rx,
-            contacts: Arc::from([]),
-            client: client.clone(),
+            contacts: Default::default(),
+            incoming_contact_requests: Default::default(),
+            outgoing_contact_requests: Default::default(),
+            invite_info: None,
+            client: Arc::downgrade(&client),
             update_contacts_tx,
             http,
             _maintain_contacts: cx.spawn_weak(|this, mut cx| async move {
-                let _subscription = rpc_subscription;
-                while let Some(message) = update_contacts_rx.recv().await {
-                    if let Some((message, this)) = message.zip(this.upgrade(&cx)) {
+                let _subscriptions = rpc_subscriptions;
+                while let Some(message) = update_contacts_rx.next().await {
+                    if let Some(this) = this.upgrade(&cx) {
                         this.update(&mut cx, |this, cx| this.update_contacts(message, cx))
                             .log_err()
                             .await;
@@ -93,90 +151,385 @@ impl UserStore {
                         }
                         Status::SignedOut => {
                             current_user_tx.send(None).await.ok();
+                            if let Some(this) = this.upgrade(&cx) {
+                                this.update(&mut cx, |this, _| this.clear_contacts()).await;
+                            }
+                        }
+                        Status::ConnectionLost => {
+                            if let Some(this) = this.upgrade(&cx) {
+                                this.update(&mut cx, |this, _| this.clear_contacts()).await;
+                            }
                         }
                         _ => {}
                     }
                 }
             }),
+            pending_contact_requests: Default::default(),
         }
     }
 
+    async fn handle_update_invite_info(
+        this: ModelHandle<Self>,
+        message: TypedEnvelope<proto::UpdateInviteInfo>,
+        _: Arc<Client>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |this, cx| {
+            this.invite_info = Some(InviteInfo {
+                url: Arc::from(message.payload.url),
+                count: message.payload.count,
+            });
+            cx.notify();
+        });
+        Ok(())
+    }
+
+    async fn handle_show_contacts(
+        this: ModelHandle<Self>,
+        _: TypedEnvelope<proto::ShowContacts>,
+        _: Arc<Client>,
+        mut cx: AsyncAppContext,
+    ) -> Result<()> {
+        this.update(&mut cx, |_, cx| cx.emit(Event::ShowContacts));
+        Ok(())
+    }
+
+    pub fn invite_info(&self) -> Option<&InviteInfo> {
+        self.invite_info.as_ref()
+    }
+
     async fn handle_update_contacts(
         this: ModelHandle<Self>,
-        msg: TypedEnvelope<proto::UpdateContacts>,
+        message: TypedEnvelope<proto::UpdateContacts>,
         _: Arc<Client>,
         mut cx: AsyncAppContext,
     ) -> Result<()> {
         this.update(&mut cx, |this, _| {
-            *this.update_contacts_tx.borrow_mut() = Some(msg.payload);
+            this.update_contacts_tx
+                .unbounded_send(UpdateContacts::Update(message.payload))
+                .unwrap();
         });
         Ok(())
     }
 
     fn update_contacts(
         &mut self,
-        message: proto::UpdateContacts,
+        message: UpdateContacts,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<()>> {
-        let mut user_ids = HashSet::new();
-        for contact in &message.contacts {
-            user_ids.insert(contact.user_id);
-            user_ids.extend(contact.projects.iter().flat_map(|w| &w.guests).copied());
-        }
-
-        let load_users = self.load_users(user_ids.into_iter().collect(), cx);
-        cx.spawn(|this, mut cx| async move {
-            load_users.await?;
-
-            let mut contacts = Vec::new();
-            for contact in message.contacts {
-                contacts.push(Contact::from_proto(contact, &this, &mut cx).await?);
+        match message {
+            UpdateContacts::Wait(barrier) => {
+                drop(barrier);
+                Task::ready(Ok(()))
             }
+            UpdateContacts::Clear(barrier) => {
+                self.contacts.clear();
+                self.incoming_contact_requests.clear();
+                self.outgoing_contact_requests.clear();
+                drop(barrier);
+                Task::ready(Ok(()))
+            }
+            UpdateContacts::Update(message) => {
+                let mut user_ids = HashSet::default();
+                for contact in &message.contacts {
+                    user_ids.insert(contact.user_id);
+                    user_ids.extend(contact.projects.iter().flat_map(|w| &w.guests).copied());
+                }
+                user_ids.extend(message.incoming_requests.iter().map(|req| req.requester_id));
+                user_ids.extend(message.outgoing_requests.iter());
 
-            this.update(&mut cx, |this, cx| {
-                contacts.sort_by(|a, b| a.user.github_login.cmp(&b.user.github_login));
-                this.contacts = contacts.into();
-                cx.notify();
-            });
+                let load_users = self.get_users(user_ids.into_iter().collect(), cx);
+                cx.spawn(|this, mut cx| async move {
+                    load_users.await?;
 
+                    // Users are fetched in parallel above and cached in call to get_users
+                    // No need to paralellize here
+                    let mut updated_contacts = Vec::new();
+                    for contact in message.contacts {
+                        let should_notify = contact.should_notify;
+                        updated_contacts.push((
+                            Arc::new(Contact::from_proto(contact, &this, &mut cx).await?),
+                            should_notify,
+                        ));
+                    }
+
+                    let mut incoming_requests = Vec::new();
+                    for request in message.incoming_requests {
+                        incoming_requests.push({
+                            let user = this
+                                .update(&mut cx, |this, cx| {
+                                    this.fetch_user(request.requester_id, cx)
+                                })
+                                .await?;
+                            (user, request.should_notify)
+                        });
+                    }
+
+                    let mut outgoing_requests = Vec::new();
+                    for requested_user_id in message.outgoing_requests {
+                        outgoing_requests.push(
+                            this.update(&mut cx, |this, cx| this.fetch_user(requested_user_id, cx))
+                                .await?,
+                        );
+                    }
+
+                    let removed_contacts =
+                        HashSet::<u64>::from_iter(message.remove_contacts.iter().copied());
+                    let removed_incoming_requests =
+                        HashSet::<u64>::from_iter(message.remove_incoming_requests.iter().copied());
+                    let removed_outgoing_requests =
+                        HashSet::<u64>::from_iter(message.remove_outgoing_requests.iter().copied());
+
+                    this.update(&mut cx, |this, cx| {
+                        // Remove contacts
+                        this.contacts
+                            .retain(|contact| !removed_contacts.contains(&contact.user.id));
+                        // Update existing contacts and insert new ones
+                        for (updated_contact, should_notify) in updated_contacts {
+                            if should_notify {
+                                cx.emit(Event::Contact {
+                                    user: updated_contact.user.clone(),
+                                    kind: ContactEventKind::Accepted,
+                                });
+                            }
+                            match this.contacts.binary_search_by_key(
+                                &&updated_contact.user.github_login,
+                                |contact| &contact.user.github_login,
+                            ) {
+                                Ok(ix) => this.contacts[ix] = updated_contact,
+                                Err(ix) => this.contacts.insert(ix, updated_contact),
+                            }
+                        }
+
+                        // Remove incoming contact requests
+                        this.incoming_contact_requests.retain(|user| {
+                            if removed_incoming_requests.contains(&user.id) {
+                                cx.emit(Event::Contact {
+                                    user: user.clone(),
+                                    kind: ContactEventKind::Cancelled,
+                                });
+                                false
+                            } else {
+                                true
+                            }
+                        });
+                        // Update existing incoming requests and insert new ones
+                        for (user, should_notify) in incoming_requests {
+                            if should_notify {
+                                cx.emit(Event::Contact {
+                                    user: user.clone(),
+                                    kind: ContactEventKind::Requested,
+                                });
+                            }
+
+                            match this
+                                .incoming_contact_requests
+                                .binary_search_by_key(&&user.github_login, |contact| {
+                                    &contact.github_login
+                                }) {
+                                Ok(ix) => this.incoming_contact_requests[ix] = user,
+                                Err(ix) => this.incoming_contact_requests.insert(ix, user),
+                            }
+                        }
+
+                        // Remove outgoing contact requests
+                        this.outgoing_contact_requests
+                            .retain(|user| !removed_outgoing_requests.contains(&user.id));
+                        // Update existing incoming requests and insert new ones
+                        for request in outgoing_requests {
+                            match this
+                                .outgoing_contact_requests
+                                .binary_search_by_key(&&request.github_login, |contact| {
+                                    &contact.github_login
+                                }) {
+                                Ok(ix) => this.outgoing_contact_requests[ix] = request,
+                                Err(ix) => this.outgoing_contact_requests.insert(ix, request),
+                            }
+                        }
+
+                        cx.notify();
+                    });
+
+                    Ok(())
+                })
+            }
+        }
+    }
+
+    pub fn contacts(&self) -> &[Arc<Contact>] {
+        &self.contacts
+    }
+
+    pub fn has_contact(&self, user: &Arc<User>) -> bool {
+        self.contacts
+            .binary_search_by_key(&&user.github_login, |contact| &contact.user.github_login)
+            .is_ok()
+    }
+
+    pub fn incoming_contact_requests(&self) -> &[Arc<User>] {
+        &self.incoming_contact_requests
+    }
+
+    pub fn outgoing_contact_requests(&self) -> &[Arc<User>] {
+        &self.outgoing_contact_requests
+    }
+
+    pub fn is_contact_request_pending(&self, user: &User) -> bool {
+        self.pending_contact_requests.contains_key(&user.id)
+    }
+
+    pub fn contact_request_status(&self, user: &User) -> ContactRequestStatus {
+        if self
+            .contacts
+            .binary_search_by_key(&&user.github_login, |contact| &contact.user.github_login)
+            .is_ok()
+        {
+            ContactRequestStatus::RequestAccepted
+        } else if self
+            .outgoing_contact_requests
+            .binary_search_by_key(&&user.github_login, |user| &user.github_login)
+            .is_ok()
+        {
+            ContactRequestStatus::RequestSent
+        } else if self
+            .incoming_contact_requests
+            .binary_search_by_key(&&user.github_login, |user| &user.github_login)
+            .is_ok()
+        {
+            ContactRequestStatus::RequestReceived
+        } else {
+            ContactRequestStatus::None
+        }
+    }
+
+    pub fn request_contact(
+        &mut self,
+        responder_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        self.perform_contact_request(responder_id, proto::RequestContact { responder_id }, cx)
+    }
+
+    pub fn remove_contact(
+        &mut self,
+        user_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        self.perform_contact_request(user_id, proto::RemoveContact { user_id }, cx)
+    }
+
+    pub fn respond_to_contact_request(
+        &mut self,
+        requester_id: u64,
+        accept: bool,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        self.perform_contact_request(
+            requester_id,
+            proto::RespondToContactRequest {
+                requester_id,
+                response: if accept {
+                    proto::ContactRequestResponse::Accept
+                } else {
+                    proto::ContactRequestResponse::Decline
+                } as i32,
+            },
+            cx,
+        )
+    }
+
+    pub fn dismiss_contact_request(
+        &mut self,
+        requester_id: u64,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let client = self.client.upgrade();
+        cx.spawn_weak(|_, _| async move {
+            client
+                .ok_or_else(|| anyhow!("can't upgrade client reference"))?
+                .request(proto::RespondToContactRequest {
+                    requester_id,
+                    response: proto::ContactRequestResponse::Dismiss as i32,
+                })
+                .await?;
             Ok(())
         })
     }
 
-    pub fn contacts(&self) -> &Arc<[Contact]> {
-        &self.contacts
+    fn perform_contact_request<T: RequestMessage>(
+        &mut self,
+        user_id: u64,
+        request: T,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<()>> {
+        let client = self.client.upgrade();
+        *self.pending_contact_requests.entry(user_id).or_insert(0) += 1;
+        cx.notify();
+
+        cx.spawn(|this, mut cx| async move {
+            let response = client
+                .ok_or_else(|| anyhow!("can't upgrade client reference"))?
+                .request(request)
+                .await;
+            this.update(&mut cx, |this, cx| {
+                if let Entry::Occupied(mut request_count) =
+                    this.pending_contact_requests.entry(user_id)
+                {
+                    *request_count.get_mut() -= 1;
+                    if *request_count.get() == 0 {
+                        request_count.remove();
+                    }
+                }
+                cx.notify();
+            });
+            response?;
+            Ok(())
+        })
     }
 
-    pub fn load_users(
+    pub fn clear_contacts(&mut self) -> impl Future<Output = ()> {
+        let (tx, mut rx) = postage::barrier::channel();
+        self.update_contacts_tx
+            .unbounded_send(UpdateContacts::Clear(tx))
+            .unwrap();
+        async move {
+            rx.recv().await;
+        }
+    }
+
+    pub fn contact_updates_done(&mut self) -> impl Future<Output = ()> {
+        let (tx, mut rx) = postage::barrier::channel();
+        self.update_contacts_tx
+            .unbounded_send(UpdateContacts::Wait(tx))
+            .unwrap();
+        async move {
+            rx.recv().await;
+        }
+    }
+
+    pub fn get_users(
         &mut self,
         mut user_ids: Vec<u64>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<()>> {
-        let rpc = self.client.clone();
-        let http = self.http.clone();
         user_ids.retain(|id| !self.users.contains_key(id));
-        cx.spawn_weak(|this, mut cx| async move {
-            if !user_ids.is_empty() {
-                let response = rpc.request(proto::GetUsers { user_ids }).await?;
-                let new_users = future::join_all(
-                    response
-                        .users
-                        .into_iter()
-                        .map(|user| User::new(user, http.as_ref())),
-                )
-                .await;
+        if user_ids.is_empty() {
+            Task::ready(Ok(()))
+        } else {
+            let load = self.load_users(proto::GetUsers { user_ids }, cx);
+            cx.foreground().spawn(async move {
+                load.await?;
+                Ok(())
+            })
+        }
+    }
 
-                if let Some(this) = this.upgrade(&cx) {
-                    this.update(&mut cx, |this, _| {
-                        for user in new_users {
-                            this.users.insert(user.id, Arc::new(user));
-                        }
-                    });
-                }
-            }
-
-            Ok(())
-        })
+    pub fn fuzzy_search_users(
+        &mut self,
+        query: String,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<Vec<Arc<User>>>> {
+        self.load_users(proto::FuzzySearchUsers { query }, cx)
     }
 
     pub fn fetch_user(
@@ -185,10 +538,10 @@ impl UserStore {
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<Arc<User>>> {
         if let Some(user) = self.users.get(&user_id).cloned() {
-            return cx.spawn_weak(|_, _| async move { Ok(user) });
+            return cx.foreground().spawn(async move { Ok(user) });
         }
 
-        let load_users = self.load_users(vec![user_id], cx);
+        let load_users = self.get_users(vec![user_id], cx);
         cx.spawn(|this, mut cx| async move {
             load_users.await?;
             this.update(&mut cx, |this, _| {
@@ -207,15 +560,47 @@ impl UserStore {
     pub fn watch_current_user(&self) -> watch::Receiver<Option<Arc<User>>> {
         self.current_user.clone()
     }
+
+    fn load_users(
+        &mut self,
+        request: impl RequestMessage<Response = UsersResponse>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<Vec<Arc<User>>>> {
+        let client = self.client.clone();
+        let http = self.http.clone();
+        cx.spawn_weak(|this, mut cx| async move {
+            if let Some(rpc) = client.upgrade() {
+                let response = rpc.request(request).await.context("error loading users")?;
+                let users = future::join_all(
+                    response
+                        .users
+                        .into_iter()
+                        .map(|user| User::new(user, http.as_ref())),
+                )
+                .await;
+
+                if let Some(this) = this.upgrade(&cx) {
+                    this.update(&mut cx, |this, _| {
+                        for user in &users {
+                            this.users.insert(user.id, user.clone());
+                        }
+                    });
+                }
+                Ok(users)
+            } else {
+                Ok(Vec::new())
+            }
+        })
+    }
 }
 
 impl User {
-    async fn new(message: proto::User, http: &dyn HttpClient) -> Self {
-        User {
+    async fn new(message: proto::User, http: &dyn HttpClient) -> Arc<Self> {
+        Arc::new(User {
             id: message.id,
             github_login: message.github_login,
             avatar: fetch_avatar(http, &message.avatar_url).warn_on_err().await,
-        }
+        })
     }
 }
 
@@ -232,9 +617,9 @@ impl Contact {
             .await?;
         let mut projects = Vec::new();
         for project in contact.projects {
-            let mut guests = Vec::new();
+            let mut guests = BTreeSet::new();
             for participant_id in project.guests {
-                guests.push(
+                guests.insert(
                     user_store
                         .update(cx, |user_store, cx| {
                             user_store.fetch_user(participant_id, cx)
@@ -244,32 +629,41 @@ impl Contact {
             }
             projects.push(ProjectMetadata {
                 id: project.id,
-                worktree_root_names: project.worktree_root_names.clone(),
-                is_shared: project.is_shared,
+                visible_worktree_root_names: project.visible_worktree_root_names.clone(),
                 guests,
             });
         }
-        Ok(Self { user, projects })
+        Ok(Self {
+            user,
+            online: contact.online,
+            projects,
+        })
+    }
+
+    pub fn non_empty_projects(&self) -> impl Iterator<Item = &ProjectMetadata> {
+        self.projects
+            .iter()
+            .filter(|project| !project.visible_worktree_root_names.is_empty())
     }
 }
 
 async fn fetch_avatar(http: &dyn HttpClient, url: &str) -> Result<Arc<ImageData>> {
-    let url = Url::parse(url).with_context(|| format!("failed to parse avatar url {:?}", url))?;
-    let mut request = Request::new(Method::Get, url);
-    request.middleware(surf::middleware::Redirect::default());
-
     let mut response = http
-        .send(request)
+        .get(url, Default::default(), true)
         .await
         .map_err(|e| anyhow!("failed to send user avatar request: {}", e))?;
+
     if !response.status().is_success() {
         return Err(anyhow!("avatar request failed {:?}", response.status()));
     }
-    let bytes = response
-        .body_bytes()
+
+    let mut body = Vec::new();
+    response
+        .body_mut()
+        .read_to_end(&mut body)
         .await
         .map_err(|e| anyhow!("failed to read user avatar response body: {}", e))?;
-    let format = image::guess_format(&bytes)?;
-    let image = image::load_from_memory_with_format(&bytes, format)?.into_bgra8();
+    let format = image::guess_format(&body)?;
+    let image = image::load_from_memory_with_format(&body, format)?.into_bgra8();
     Ok(ImageData::new(image))
 }

crates/clock/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [lib]
 path = "src/clock.rs"
+doctest = false
 
 [dependencies]
 smallvec = { version = "1.6", features = ["union"] }
-rpc = { path = "../rpc" }

crates/clock/src/clock.rs

@@ -69,37 +69,6 @@ impl<'a> AddAssign<&'a Local> for Local {
 #[derive(Clone, Default, Hash, Eq, PartialEq)]
 pub struct Global(SmallVec<[u32; 8]>);
 
-impl From<Vec<rpc::proto::VectorClockEntry>> for Global {
-    fn from(message: Vec<rpc::proto::VectorClockEntry>) -> Self {
-        let mut version = Self::new();
-        for entry in message {
-            version.observe(Local {
-                replica_id: entry.replica_id as ReplicaId,
-                value: entry.timestamp,
-            });
-        }
-        version
-    }
-}
-
-impl<'a> From<&'a Global> for Vec<rpc::proto::VectorClockEntry> {
-    fn from(version: &'a Global) -> Self {
-        version
-            .iter()
-            .map(|entry| rpc::proto::VectorClockEntry {
-                replica_id: entry.replica_id as u32,
-                timestamp: entry.value,
-            })
-            .collect()
-    }
-}
-
-impl From<Global> for Vec<rpc::proto::VectorClockEntry> {
-    fn from(version: Global) -> Self {
-        (&version).into()
-    }
-}
-
 impl Global {
     pub fn new() -> Self {
         Self::default()

crates/collab/.env.template.toml

@@ -0,0 +1,9 @@
+DATABASE_URL = "postgres://postgres@localhost/zed"
+HTTP_PORT = 8080
+API_TOKEN = "secret"
+INVITE_LINK_PREFIX = "http://localhost:3000/invites/"
+
+# HONEYCOMB_API_KEY=
+# HONEYCOMB_DATASET=
+# RUST_LOG=info
+# LOG_JSON=true

crates/collab/Cargo.toml

@@ -0,0 +1,75 @@
+[package]
+authors = ["Nathan Sobo <nathan@warp.dev>"]
+default-run = "collab"
+edition = "2021"
+name = "collab"
+version = "0.1.0"
+
+[[bin]]
+name = "collab"
+
+[[bin]]
+name = "seed"
+required-features = ["seed-support"]
+
+[dependencies]
+collections = { path = "../collections" }
+rpc = { path = "../rpc" }
+util = { path = "../util" }
+
+anyhow = "1.0.40"
+async-trait = "0.1.50"
+async-tungstenite = "0.16"
+axum = { version = "0.5", features = ["json", "headers", "ws"] }
+axum-extra = { version = "0.3", features = ["erased-json"] }
+base64 = "0.13"
+clap = { version = "3.1", features = ["derive"], optional = true }
+envy = "0.4.2"
+futures = "0.3"
+hyper = "0.14"
+lazy_static = "1.4"
+lipsum = { version = "0.8", optional = true }
+nanoid = "0.4"
+parking_lot = "0.11.1"
+prometheus = "0.13"
+rand = "0.8"
+reqwest = { version = "0.11", features = ["json"], optional = true }
+scrypt = "0.7"
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = "1.0"
+sha-1 = "0.9"
+time = { version = "0.3", features = ["serde", "serde-well-known"] }
+tokio = { version = "1", features = ["full"] }
+tokio-tungstenite = "0.17"
+tonic = "0.6"
+tower = "0.4"
+toml = "0.5.8"
+tracing = "0.1.34"
+tracing-log = "0.1.3"
+tracing-subscriber = { version = "0.3.11", features = ["env-filter", "json"] }
+
+[dependencies.sqlx]
+version = "0.6"
+features = ["runtime-tokio-rustls", "postgres", "time", "uuid"]
+
+[dev-dependencies]
+collections = { path = "../collections", features = ["test-support"] }
+gpui = { path = "../gpui", features = ["test-support"] }
+rpc = { path = "../rpc", features = ["test-support"] }
+client = { path = "../client", features = ["test-support"] }
+editor = { path = "../editor", features = ["test-support"] }
+language = { path = "../language", features = ["test-support"] }
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
+lsp = { path = "../lsp", features = ["test-support"] }
+project = { path = "../project", features = ["test-support"] }
+settings = { path = "../settings", features = ["test-support"] }
+theme = { path = "../theme" }
+workspace = { path = "../workspace", features = ["test-support"] }
+ctor = "0.1"
+env_logger = "0.9"
+util = { path = "../util" }
+lazy_static = "1.4"
+serde_json = { version = "1.0", features = ["preserve_order"] }
+
+[features]
+seed-support = ["clap", "lipsum", "reqwest"]

crates/collab/Procfile

@@ -1,2 +1,2 @@
-web: ./target/release/zed-server
+collab: ./target/release/collab
 release: ./target/release/sqlx migrate run

crates/collab/README.md

@@ -0,0 +1,5 @@
+# Zed Server
+
+This crate is what we run at https://collab.zed.dev.
+
+It contains our back-end logic for collaboration, to which we connect from the Zed client via a websocket after authenticating via https://zed.dev, which is a separate repo running on Vercel.

crates/collab/k8s/environments/production.sh

@@ -0,0 +1,3 @@
+ZED_ENVIRONMENT=production
+RUST_LOG=info
+INVITE_LINK_PREFIX=https://zed.dev/invites/

crates/collab/k8s/environments/staging.sh

@@ -0,0 +1,3 @@
+ZED_ENVIRONMENT=staging
+RUST_LOG=info
+INVITE_LINK_PREFIX=https://staging.zed.dev/invites/

crates/collab/k8s/manifest.template.yml

@@ -8,14 +8,14 @@ kind: Service
 apiVersion: v1
 metadata:
   namespace: ${ZED_KUBE_NAMESPACE}
-  name: zed
+  name: collab
   annotations:
     service.beta.kubernetes.io/do-loadbalancer-tls-ports: "443"
-    service.beta.kubernetes.io/do-loadbalancer-certificate-id: "2634d353-1ab4-437f-add2-4ffd8f315233"
+    service.beta.kubernetes.io/do-loadbalancer-certificate-id: "40879815-9a6b-4bbb-8207-8f2c7c0218f9"
 spec:
   type: LoadBalancer
   selector:
-    app: zed
+    app: collab
   ports:
     - name: web
       protocol: TCP
@@ -26,19 +26,33 @@ apiVersion: apps/v1
 kind: Deployment
 metadata:
   namespace: ${ZED_KUBE_NAMESPACE}
-  name: zed
+  name: collab
+
 spec:
   replicas: 1
   selector:
     matchLabels:
-      app: zed
+      app: collab
   template:
     metadata:
       labels:
-        app: zed
+        app: collab
+      annotations:
+        ad.datadoghq.com/collab.check_names: |
+          ["openmetrics"]
+        ad.datadoghq.com/collab.init_configs: |
+          [{}]
+        ad.datadoghq.com/collab.instances: |
+          [
+              {
+              "openmetrics_endpoint": "http://%%host%%:%%port%%/metrics",
+              "namespace": "collab_${ZED_KUBE_NAMESPACE}",
+              "metrics": [".*"]
+              }
+          ]
     spec:
       containers:
-        - name: zed
+        - name: collab
           image: "${ZED_IMAGE_ID}"
           ports:
             - containerPort: 8080
@@ -81,6 +95,19 @@ spec:
                 secretKeyRef:
                   name: api
                   key: token
+            - name: INVITE_LINK_PREFIX
+              value: ${INVITE_LINK_PREFIX}
+            - name: RUST_LOG
+              value: ${RUST_LOG}
+            - name: LOG_JSON
+              value: "true"
+            - name: HONEYCOMB_DATASET
+              value: "collab"
+            - name: HONEYCOMB_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: honeycomb
+                  key: apiKey
           securityContext:
             capabilities:
               # FIXME - Switch to the more restrictive `PERFMON` capability.

crates/collab/migrations/20220421165757_drop_signups.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS "signups";

crates/collab/migrations/20220505144506_add_trigram_index_to_users.sql

@@ -0,0 +1,2 @@
+CREATE EXTENSION IF NOT EXISTS pg_trgm;
+CREATE INDEX trigram_index_users_on_github_login ON users USING GIN(github_login gin_trgm_ops);

crates/collab/migrations/20220506130724_create_contacts.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS "contacts" (
+    "id" SERIAL PRIMARY KEY,
+    "user_id_a" INTEGER REFERENCES users (id) NOT NULL,
+    "user_id_b" INTEGER REFERENCES users (id) NOT NULL,
+    "a_to_b" BOOLEAN NOT NULL,
+    "should_notify" BOOLEAN NOT NULL,
+    "accepted" BOOLEAN NOT NULL
+);
+
+CREATE UNIQUE INDEX "index_contacts_user_ids" ON "contacts" ("user_id_a", "user_id_b");
+CREATE INDEX "index_contacts_user_id_b" ON "contacts" ("user_id_b");

crates/collab/migrations/20220518151305_add_invites_to_users.sql

@@ -0,0 +1,9 @@
+ALTER TABLE users
+ADD email_address VARCHAR(255) DEFAULT NULL,
+ADD invite_code VARCHAR(64),
+ADD invite_count INTEGER NOT NULL DEFAULT 0,
+ADD inviter_id INTEGER REFERENCES users (id),
+ADD connected_once BOOLEAN NOT NULL DEFAULT false,
+ADD created_at TIMESTAMP NOT NULL DEFAULT NOW();
+
+CREATE UNIQUE INDEX "index_invite_code_users" ON "users" ("invite_code");

crates/collab/migrations/20220523232954_allow_user_deletes.sql

@@ -0,0 +1,6 @@
+ALTER TABLE contacts DROP CONSTRAINT contacts_user_id_a_fkey;
+ALTER TABLE contacts DROP CONSTRAINT contacts_user_id_b_fkey;
+ALTER TABLE contacts ADD CONSTRAINT contacts_user_id_a_fkey FOREIGN KEY (user_id_a) REFERENCES users(id) ON DELETE CASCADE;
+ALTER TABLE contacts ADD CONSTRAINT contacts_user_id_b_fkey FOREIGN KEY (user_id_b) REFERENCES users(id) ON DELETE CASCADE;
+ALTER TABLE users DROP CONSTRAINT users_inviter_id_fkey;
+ALTER TABLE users ADD CONSTRAINT users_inviter_id_fkey FOREIGN KEY (inviter_id) REFERENCES users(id) ON DELETE SET NULL;

crates/collab/migrations/20220620211403_create_projects.sql

@@ -0,0 +1,24 @@
+CREATE TABLE IF NOT EXISTS "projects" (
+    "id" SERIAL PRIMARY KEY,
+    "host_user_id" INTEGER REFERENCES users (id) NOT NULL,
+    "unregistered" BOOLEAN NOT NULL DEFAULT false
+);
+
+CREATE TABLE IF NOT EXISTS "worktree_extensions" (
+    "id" SERIAL PRIMARY KEY,
+    "project_id" INTEGER REFERENCES projects (id) NOT NULL,
+    "worktree_id" INTEGER NOT NULL,
+    "extension" VARCHAR(255),
+    "count" INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS "project_activity_periods" (
+    "id" SERIAL PRIMARY KEY,
+    "duration_millis" INTEGER NOT NULL,
+    "ended_at" TIMESTAMP NOT NULL,
+    "user_id" INTEGER REFERENCES users (id) NOT NULL,
+    "project_id" INTEGER REFERENCES projects (id) NOT NULL
+);
+
+CREATE INDEX "index_project_activity_periods_on_ended_at" ON "project_activity_periods" ("ended_at");
+CREATE UNIQUE INDEX "index_worktree_extensions_on_project_id_and_worktree_id_and_extension" ON "worktree_extensions" ("project_id", "worktree_id", "extension");

crates/collab/src/api.rs

@@ -0,0 +1,360 @@
+use crate::{
+    auth,
+    db::{ProjectId, User, UserId},
+    rpc::{self, ResultExt},
+    AppState, Error, Result,
+};
+use anyhow::anyhow;
+use axum::{
+    body::Body,
+    extract::{Path, Query},
+    http::{self, Request, StatusCode},
+    middleware::{self, Next},
+    response::IntoResponse,
+    routing::{get, post, put},
+    Extension, Json, Router,
+};
+use axum_extra::response::ErasedJson;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::sync::Arc;
+use time::OffsetDateTime;
+use tower::ServiceBuilder;
+use tracing::instrument;
+
+pub fn routes(rpc_server: &Arc<rpc::Server>, state: Arc<AppState>) -> Router<Body> {
+    Router::new()
+        .route("/users", get(get_users).post(create_user))
+        .route(
+            "/users/:id",
+            put(update_user).delete(destroy_user).get(get_user),
+        )
+        .route("/users/:id/access_tokens", post(create_access_token))
+        .route("/bulk_users", post(create_users))
+        .route("/users_with_no_invites", get(get_users_with_no_invites))
+        .route("/invite_codes/:code", get(get_user_for_invite_code))
+        .route("/panic", post(trace_panic))
+        .route("/rpc_server_snapshot", get(get_rpc_server_snapshot))
+        .route(
+            "/project_activity_summary",
+            get(get_project_activity_summary),
+        )
+        .route("/project_metadata", get(get_project_metadata))
+        .layer(
+            ServiceBuilder::new()
+                .layer(Extension(state))
+                .layer(Extension(rpc_server.clone()))
+                .layer(middleware::from_fn(validate_api_token)),
+        )
+}
+
+pub async fn validate_api_token<B>(req: Request<B>, next: Next<B>) -> impl IntoResponse {
+    let token = req
+        .headers()
+        .get(http::header::AUTHORIZATION)
+        .and_then(|header| header.to_str().ok())
+        .ok_or_else(|| {
+            Error::Http(
+                StatusCode::BAD_REQUEST,
+                "missing authorization header".to_string(),
+            )
+        })?
+        .strip_prefix("token ")
+        .ok_or_else(|| {
+            Error::Http(
+                StatusCode::BAD_REQUEST,
+                "invalid authorization header".to_string(),
+            )
+        })?;
+
+    let state = req.extensions().get::<Arc<AppState>>().unwrap();
+
+    if token != state.api_token {
+        Err(Error::Http(
+            StatusCode::UNAUTHORIZED,
+            "invalid authorization token".to_string(),
+        ))?
+    }
+
+    Ok::<_, Error>(next.run(req).await)
+}
+
+#[derive(Debug, Deserialize)]
+struct GetUsersQueryParams {
+    query: Option<String>,
+    page: Option<u32>,
+    limit: Option<u32>,
+}
+
+async fn get_users(
+    Query(params): Query<GetUsersQueryParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<Json<Vec<User>>> {
+    let limit = params.limit.unwrap_or(100);
+    let users = if let Some(query) = params.query {
+        app.db.fuzzy_search_users(&query, limit).await?
+    } else {
+        app.db
+            .get_all_users(params.page.unwrap_or(0), limit)
+            .await?
+    };
+    Ok(Json(users))
+}
+
+#[derive(Deserialize, Debug)]
+struct CreateUserParams {
+    github_login: String,
+    invite_code: Option<String>,
+    email_address: Option<String>,
+    admin: bool,
+}
+
+async fn create_user(
+    Json(params): Json<CreateUserParams>,
+    Extension(app): Extension<Arc<AppState>>,
+    Extension(rpc_server): Extension<Arc<rpc::Server>>,
+) -> Result<Json<User>> {
+    let user_id = if let Some(invite_code) = params.invite_code {
+        let invitee_id = app
+            .db
+            .redeem_invite_code(
+                &invite_code,
+                &params.github_login,
+                params.email_address.as_deref(),
+            )
+            .await?;
+        rpc_server
+            .invite_code_redeemed(&invite_code, invitee_id)
+            .await
+            .trace_err();
+        invitee_id
+    } else {
+        app.db
+            .create_user(
+                &params.github_login,
+                params.email_address.as_deref(),
+                params.admin,
+            )
+            .await?
+    };
+
+    let user = app
+        .db
+        .get_user_by_id(user_id)
+        .await?
+        .ok_or_else(|| anyhow!("couldn't find the user we just created"))?;
+
+    Ok(Json(user))
+}
+
+#[derive(Deserialize)]
+struct UpdateUserParams {
+    admin: Option<bool>,
+    invite_count: Option<u32>,
+}
+
+async fn update_user(
+    Path(user_id): Path<i32>,
+    Json(params): Json<UpdateUserParams>,
+    Extension(app): Extension<Arc<AppState>>,
+    Extension(rpc_server): Extension<Arc<rpc::Server>>,
+) -> Result<()> {
+    let user_id = UserId(user_id);
+
+    if let Some(admin) = params.admin {
+        app.db.set_user_is_admin(user_id, admin).await?;
+    }
+
+    if let Some(invite_count) = params.invite_count {
+        app.db.set_invite_count(user_id, invite_count).await?;
+        rpc_server.invite_count_updated(user_id).await.trace_err();
+    }
+
+    Ok(())
+}
+
+async fn destroy_user(
+    Path(user_id): Path<i32>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<()> {
+    app.db.destroy_user(UserId(user_id)).await?;
+    Ok(())
+}
+
+async fn get_user(
+    Path(login): Path<String>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<Json<User>> {
+    let user = app
+        .db
+        .get_user_by_github_login(&login)
+        .await?
+        .ok_or_else(|| Error::Http(StatusCode::NOT_FOUND, "User not found".to_string()))?;
+    Ok(Json(user))
+}
+
+#[derive(Deserialize)]
+struct CreateUsersParams {
+    users: Vec<CreateUsersEntry>,
+}
+
+#[derive(Deserialize)]
+struct CreateUsersEntry {
+    github_login: String,
+    email_address: String,
+    invite_count: usize,
+}
+
+async fn create_users(
+    Json(params): Json<CreateUsersParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<Json<Vec<User>>> {
+    let user_ids = app
+        .db
+        .create_users(
+            params
+                .users
+                .into_iter()
+                .map(|params| {
+                    (
+                        params.github_login,
+                        params.email_address,
+                        params.invite_count,
+                    )
+                })
+                .collect(),
+        )
+        .await?;
+    let users = app.db.get_users_by_ids(user_ids).await?;
+    Ok(Json(users))
+}
+
+#[derive(Debug, Deserialize)]
+struct GetUsersWithNoInvites {
+    invited_by_another_user: bool,
+}
+
+async fn get_users_with_no_invites(
+    Query(params): Query<GetUsersWithNoInvites>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<Json<Vec<User>>> {
+    Ok(Json(
+        app.db
+            .get_users_with_no_invites(params.invited_by_another_user)
+            .await?,
+    ))
+}
+
+#[derive(Debug, Deserialize)]
+struct Panic {
+    version: String,
+    text: String,
+}
+
+#[instrument(skip(panic))]
+async fn trace_panic(panic: Json<Panic>) -> Result<()> {
+    tracing::error!(version = %panic.version, text = %panic.text, "panic report");
+    Ok(())
+}
+
+async fn get_rpc_server_snapshot(
+    Extension(rpc_server): Extension<Arc<rpc::Server>>,
+) -> Result<ErasedJson> {
+    Ok(ErasedJson::pretty(rpc_server.snapshot().await))
+}
+
+#[derive(Deserialize)]
+struct GetProjectActivityParams {
+    #[serde(with = "time::serde::iso8601")]
+    start: OffsetDateTime,
+    #[serde(with = "time::serde::iso8601")]
+    end: OffsetDateTime,
+}
+
+async fn get_project_activity_summary(
+    Query(params): Query<GetProjectActivityParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<ErasedJson> {
+    let summary = app
+        .db
+        .summarize_project_activity(params.start..params.end, 100)
+        .await?;
+    Ok(ErasedJson::pretty(summary))
+}
+
+#[derive(Deserialize)]
+struct GetProjectMetadataParams {
+    project_id: u64,
+}
+
+async fn get_project_metadata(
+    Query(params): Query<GetProjectMetadataParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<ErasedJson> {
+    let extensions = app
+        .db
+        .get_project_extensions(ProjectId::from_proto(params.project_id))
+        .await?;
+    Ok(ErasedJson::pretty(json!({ "extensions": extensions })))
+}
+
+#[derive(Deserialize)]
+struct CreateAccessTokenQueryParams {
+    public_key: String,
+    impersonate: Option<String>,
+}
+
+#[derive(Serialize)]
+struct CreateAccessTokenResponse {
+    user_id: UserId,
+    encrypted_access_token: String,
+}
+
+async fn create_access_token(
+    Path(login): Path<String>,
+    Query(params): Query<CreateAccessTokenQueryParams>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<Json<CreateAccessTokenResponse>> {
+    //     request.require_token().await?;
+
+    let user = app
+        .db
+        .get_user_by_github_login(&login)
+        .await?
+        .ok_or_else(|| anyhow!("user not found"))?;
+
+    let mut user_id = user.id;
+    if let Some(impersonate) = params.impersonate {
+        if user.admin {
+            if let Some(impersonated_user) = app.db.get_user_by_github_login(&impersonate).await? {
+                user_id = impersonated_user.id;
+            } else {
+                return Err(Error::Http(
+                    StatusCode::UNPROCESSABLE_ENTITY,
+                    format!("user {impersonate} does not exist"),
+                ));
+            }
+        } else {
+            return Err(Error::Http(
+                StatusCode::UNAUTHORIZED,
+                format!("you do not have permission to impersonate other users"),
+            ));
+        }
+    }
+
+    let access_token = auth::create_access_token(app.db.as_ref(), user_id).await?;
+    let encrypted_access_token =
+        auth::encrypt_access_token(&access_token, params.public_key.clone())?;
+
+    Ok(Json(CreateAccessTokenResponse {
+        user_id,
+        encrypted_access_token,
+    }))
+}
+
+async fn get_user_for_invite_code(
+    Path(code): Path<String>,
+    Extension(app): Extension<Arc<AppState>>,
+) -> Result<Json<User>> {
+    Ok(Json(app.db.get_user_for_invite_code(&code).await?))
+}

crates/collab/src/auth.rs

@@ -0,0 +1,111 @@
+use std::sync::Arc;
+
+use super::db::{self, UserId};
+use crate::{AppState, Error, Result};
+use anyhow::{anyhow, Context};
+use axum::{
+    http::{self, Request, StatusCode},
+    middleware::Next,
+    response::IntoResponse,
+};
+use rand::thread_rng;
+use scrypt::{
+    password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
+    Scrypt,
+};
+
+pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl IntoResponse {
+    let mut auth_header = req
+        .headers()
+        .get(http::header::AUTHORIZATION)
+        .and_then(|header| header.to_str().ok())
+        .ok_or_else(|| {
+            Error::Http(
+                StatusCode::BAD_REQUEST,
+                "missing authorization header".to_string(),
+            )
+        })?
+        .split_whitespace();
+
+    let user_id = UserId(auth_header.next().unwrap_or("").parse().map_err(|_| {
+        Error::Http(
+            StatusCode::BAD_REQUEST,
+            "missing user id in authorization header".to_string(),
+        )
+    })?);
+
+    let access_token = auth_header.next().ok_or_else(|| {
+        Error::Http(
+            StatusCode::BAD_REQUEST,
+            "missing access token in authorization header".to_string(),
+        )
+    })?;
+
+    let state = req.extensions().get::<Arc<AppState>>().unwrap();
+    let mut credentials_valid = false;
+    for password_hash in state.db.get_access_token_hashes(user_id).await? {
+        if verify_access_token(&access_token, &password_hash)? {
+            credentials_valid = true;
+            break;
+        }
+    }
+
+    if credentials_valid {
+        let user = state
+            .db
+            .get_user_by_id(user_id)
+            .await?
+            .ok_or_else(|| anyhow!("user {} not found", user_id))?;
+        req.extensions_mut().insert(user);
+        Ok::<_, Error>(next.run(req).await)
+    } else {
+        Err(Error::Http(
+            StatusCode::UNAUTHORIZED,
+            "invalid credentials".to_string(),
+        ))
+    }
+}
+
+const MAX_ACCESS_TOKENS_TO_STORE: usize = 8;
+
+pub async fn create_access_token(db: &dyn db::Db, user_id: UserId) -> Result<String> {
+    let access_token = rpc::auth::random_token();
+    let access_token_hash =
+        hash_access_token(&access_token).context("failed to hash access token")?;
+    db.create_access_token_hash(user_id, &access_token_hash, MAX_ACCESS_TOKENS_TO_STORE)
+        .await?;
+    Ok(access_token)
+}
+
+fn hash_access_token(token: &str) -> Result<String> {
+    // Avoid slow hashing in debug mode.
+    let params = if cfg!(debug_assertions) {
+        scrypt::Params::new(1, 1, 1).unwrap()
+    } else {
+        scrypt::Params::recommended()
+    };
+
+    Ok(Scrypt
+        .hash_password(
+            token.as_bytes(),
+            None,
+            params,
+            &SaltString::generate(thread_rng()),
+        )
+        .map_err(anyhow::Error::new)?
+        .to_string())
+}
+
+pub fn encrypt_access_token(access_token: &str, public_key: String) -> Result<String> {
+    let native_app_public_key =
+        rpc::auth::PublicKey::try_from(public_key).context("failed to parse app public key")?;
+    let encrypted_access_token = native_app_public_key
+        .encrypt_string(&access_token)
+        .context("failed to encrypt access token with public key")?;
+    Ok(encrypted_access_token)
+}
+
+pub fn verify_access_token(token: &str, hash: &str) -> Result<bool> {
+    let hash = PasswordHash::new(hash).map_err(anyhow::Error::new)?;
+    Ok(Scrypt.verify_password(token.as_bytes(), &hash).is_ok())
+}

crates/collab/src/bin/seed.rs

@@ -1,31 +1,88 @@
-use db::{Db, UserId};
+use clap::Parser;
+use collab::{Error, Result};
+use db::{Db, PostgresDb, UserId};
 use rand::prelude::*;
+use serde::Deserialize;
+use std::fmt::Write;
 use time::{Duration, OffsetDateTime};
 
 #[allow(unused)]
 #[path = "../db.rs"]
 mod db;
 
-#[async_std::main]
+#[derive(Parser)]
+struct Args {
+    /// Seed users from GitHub.
+    #[clap(short, long)]
+    github_users: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct GitHubUser {
+    id: usize,
+    login: String,
+}
+
+#[tokio::main]
 async fn main() {
+    let args = Args::parse();
     let mut rng = StdRng::from_entropy();
     let database_url = std::env::var("DATABASE_URL").expect("missing DATABASE_URL env var");
-    let db = Db::new(&database_url, 5)
+    let db = PostgresDb::new(&database_url, 5)
         .await
         .expect("failed to connect to postgres database");
 
-    let zed_users = ["nathansobo", "maxbrunsfeld", "as-cii", "iamnbutler"];
+    let mut zed_users = vec![
+        ("nathansobo".to_string(), Some("nathan@zed.dev")),
+        ("maxbrunsfeld".to_string(), Some("max@zed.dev")),
+        ("as-cii".to_string(), Some("antonio@zed.dev")),
+        ("iamnbutler".to_string(), Some("nate@zed.dev")),
+        ("gibusu".to_string(), Some("greg@zed.dev")),
+        ("Kethku".to_string(), Some("keith@zed.dev")),
+    ];
+
+    if args.github_users {
+        let github_token = std::env::var("GITHUB_TOKEN").expect("missing GITHUB_TOKEN env var");
+        let client = reqwest::Client::new();
+        let mut last_user_id = None;
+        for page in 0..20 {
+            println!("Downloading users from GitHub, page {}", page);
+            let mut uri = "https://api.github.com/users?per_page=100".to_string();
+            if let Some(last_user_id) = last_user_id {
+                write!(&mut uri, "&since={}", last_user_id).unwrap();
+            }
+            let response = client
+                .get(uri)
+                .bearer_auth(&github_token)
+                .header("user-agent", "zed")
+                .send()
+                .await
+                .expect("failed to fetch github users");
+            let users = response
+                .json::<Vec<GitHubUser>>()
+                .await
+                .expect("failed to deserialize github user");
+            zed_users.extend(users.iter().map(|user| (user.login.clone(), None)));
+
+            if let Some(last_user) = users.last() {
+                last_user_id = Some(last_user.id);
+            } else {
+                break;
+            }
+        }
+    }
+
     let mut zed_user_ids = Vec::<UserId>::new();
-    for zed_user in zed_users {
+    for (zed_user, email) in zed_users {
         if let Some(user) = db
-            .get_user_by_github_login(zed_user)
+            .get_user_by_github_login(&zed_user)
             .await
             .expect("failed to fetch user")
         {
             zed_user_ids.push(user.id);
         } else {
             zed_user_ids.push(
-                db.create_user(zed_user, true)
+                db.create_user(&zed_user, email, true)
                     .await
                     .expect("failed to insert user"),
             );

crates/collab/src/errors.rs

@@ -0,0 +1,29 @@
+// Allow tide Results to accept context like other Results do when
+// using anyhow.
+pub trait TideResultExt {
+    fn context<C>(self, cx: C) -> Self
+    where
+        C: std::fmt::Display + Send + Sync + 'static;
+
+    fn with_context<C, F>(self, f: F) -> Self
+    where
+        C: std::fmt::Display + Send + Sync + 'static,
+        F: FnOnce() -> C;
+}
+
+impl<T> TideResultExt for tide::Result<T> {
+    fn context<C>(self, cx: C) -> Self
+    where
+        C: std::fmt::Display + Send + Sync + 'static,
+    {
+        self.map_err(|e| tide::Error::new(e.status(), e.into_inner().context(cx)))
+    }
+
+    fn with_context<C, F>(self, f: F) -> Self
+    where
+        C: std::fmt::Display + Send + Sync + 'static,
+        F: FnOnce() -> C,
+    {
+        self.map_err(|e| tide::Error::new(e.status(), e.into_inner().context(f())))
+    }
+}

crates/collab/src/lib.rs

@@ -0,0 +1,69 @@
+use axum::{http::StatusCode, response::IntoResponse};
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+pub enum Error {
+    Http(StatusCode, String),
+    Internal(anyhow::Error),
+}
+
+impl From<anyhow::Error> for Error {
+    fn from(error: anyhow::Error) -> Self {
+        Self::Internal(error)
+    }
+}
+
+impl From<sqlx::Error> for Error {
+    fn from(error: sqlx::Error) -> Self {
+        Self::Internal(error.into())
+    }
+}
+
+impl From<axum::Error> for Error {
+    fn from(error: axum::Error) -> Self {
+        Self::Internal(error.into())
+    }
+}
+
+impl From<hyper::Error> for Error {
+    fn from(error: hyper::Error) -> Self {
+        Self::Internal(error.into())
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(error: serde_json::Error) -> Self {
+        Self::Internal(error.into())
+    }
+}
+
+impl IntoResponse for Error {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+            Error::Http(code, message) => (code, message).into_response(),
+            Error::Internal(error) => {
+                (StatusCode::INTERNAL_SERVER_ERROR, format!("{}", &error)).into_response()
+            }
+        }
+    }
+}
+
+impl std::fmt::Debug for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Http(code, message) => (code, message).fmt(f),
+            Error::Internal(error) => error.fmt(f),
+        }
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::Http(code, message) => write!(f, "{code}: {message}"),
+            Error::Internal(error) => error.fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for Error {}

crates/collab/src/main.rs

@@ -0,0 +1,113 @@
+mod api;
+mod auth;
+mod db;
+mod env;
+mod rpc;
+
+#[cfg(test)]
+mod integration_tests;
+
+use axum::{body::Body, Router};
+use collab::{Error, Result};
+use db::{Db, PostgresDb};
+use serde::Deserialize;
+use std::{
+    net::{SocketAddr, TcpListener},
+    sync::Arc,
+    time::Duration,
+};
+use tracing_log::LogTracer;
+use tracing_subscriber::{filter::EnvFilter, fmt::format::JsonFields, Layer};
+use util::ResultExt;
+
+#[derive(Default, Deserialize)]
+pub struct Config {
+    pub http_port: u16,
+    pub database_url: String,
+    pub api_token: String,
+    pub invite_link_prefix: String,
+    pub honeycomb_api_key: Option<String>,
+    pub honeycomb_dataset: Option<String>,
+    pub rust_log: Option<String>,
+    pub log_json: Option<bool>,
+}
+
+pub struct AppState {
+    db: Arc<dyn Db>,
+    api_token: String,
+    invite_link_prefix: String,
+}
+
+impl AppState {
+    async fn new(config: &Config) -> Result<Arc<Self>> {
+        let db = PostgresDb::new(&config.database_url, 5).await?;
+        let this = Self {
+            db: Arc::new(db),
+            api_token: config.api_token.clone(),
+            invite_link_prefix: config.invite_link_prefix.clone(),
+        };
+        Ok(Arc::new(this))
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    if let Err(error) = env::load_dotenv() {
+        eprintln!(
+            "error loading .env.toml (this is expected in production): {}",
+            error
+        );
+    }
+
+    let config = envy::from_env::<Config>().expect("error loading config");
+    init_tracing(&config);
+    let state = AppState::new(&config).await?;
+
+    let listener = TcpListener::bind(&format!("0.0.0.0:{}", config.http_port))
+        .expect("failed to bind TCP listener");
+    let rpc_server = rpc::Server::new(state.clone(), None);
+
+    rpc_server.start_recording_project_activity(Duration::from_secs(5 * 60), rpc::RealExecutor);
+
+    let app = Router::<Body>::new()
+        .merge(api::routes(&rpc_server, state.clone()))
+        .merge(rpc::routes(rpc_server));
+
+    axum::Server::from_tcp(listener)?
+        .serve(app.into_make_service_with_connect_info::<SocketAddr>())
+        .await?;
+
+    Ok(())
+}
+
+pub fn init_tracing(config: &Config) -> Option<()> {
+    use std::str::FromStr;
+    use tracing_subscriber::layer::SubscriberExt;
+    let rust_log = config.rust_log.clone()?;
+
+    LogTracer::init().log_err()?;
+
+    let subscriber = tracing_subscriber::Registry::default()
+        .with(if config.log_json.unwrap_or(false) {
+            Box::new(
+                tracing_subscriber::fmt::layer()
+                    .fmt_fields(JsonFields::default())
+                    .event_format(
+                        tracing_subscriber::fmt::format()
+                            .json()
+                            .flatten_event(true)
+                            .with_span_list(true),
+                    ),
+            ) as Box<dyn Layer<_> + Send + Sync>
+        } else {
+            Box::new(
+                tracing_subscriber::fmt::layer()
+                    .event_format(tracing_subscriber::fmt::format().pretty()),
+            )
+        })
+        .with(EnvFilter::from_str(rust_log.as_str()).log_err()?);
+
+    tracing::subscriber::set_global_default(subscriber).unwrap();
+
+    None
+}

crates/collab/src/rpc/store.rs

@@ -0,0 +1,860 @@
+use crate::db::{self, ChannelId, ProjectId, UserId};
+use anyhow::{anyhow, Result};
+use collections::{btree_map, hash_map::Entry, BTreeMap, BTreeSet, HashMap, HashSet};
+use rpc::{proto, ConnectionId, Receipt};
+use serde::Serialize;
+use std::{
+    mem,
+    path::{Path, PathBuf},
+    str,
+    time::Duration,
+};
+use time::OffsetDateTime;
+use tracing::instrument;
+
+#[derive(Default, Serialize)]
+pub struct Store {
+    connections: BTreeMap<ConnectionId, ConnectionState>,
+    connections_by_user_id: BTreeMap<UserId, HashSet<ConnectionId>>,
+    projects: BTreeMap<ProjectId, Project>,
+    #[serde(skip)]
+    channels: BTreeMap<ChannelId, Channel>,
+}
+
+#[derive(Serialize)]
+struct ConnectionState {
+    user_id: UserId,
+    admin: bool,
+    projects: BTreeSet<ProjectId>,
+    requested_projects: HashSet<ProjectId>,
+    channels: HashSet<ChannelId>,
+}
+
+#[derive(Serialize)]
+pub struct Project {
+    pub host_connection_id: ConnectionId,
+    pub host: Collaborator,
+    pub guests: HashMap<ConnectionId, Collaborator>,
+    #[serde(skip)]
+    pub join_requests: HashMap<UserId, Vec<Receipt<proto::JoinProject>>>,
+    pub active_replica_ids: HashSet<ReplicaId>,
+    pub worktrees: BTreeMap<u64, Worktree>,
+    pub language_servers: Vec<proto::LanguageServer>,
+}
+
+#[derive(Serialize)]
+pub struct Collaborator {
+    pub replica_id: ReplicaId,
+    pub user_id: UserId,
+    #[serde(skip)]
+    pub last_activity: Option<OffsetDateTime>,
+    pub admin: bool,
+}
+
+#[derive(Default, Serialize)]
+pub struct Worktree {
+    pub root_name: String,
+    pub visible: bool,
+    #[serde(skip)]
+    pub entries: BTreeMap<u64, proto::Entry>,
+    #[serde(skip)]
+    pub extension_counts: HashMap<String, usize>,
+    #[serde(skip)]
+    pub diagnostic_summaries: BTreeMap<PathBuf, proto::DiagnosticSummary>,
+    pub scan_id: u64,
+}
+
+#[derive(Default)]
+pub struct Channel {
+    pub connection_ids: HashSet<ConnectionId>,
+}
+
+pub type ReplicaId = u16;
+
+#[derive(Default)]
+pub struct RemovedConnectionState {
+    pub user_id: UserId,
+    pub hosted_projects: HashMap<ProjectId, Project>,
+    pub guest_project_ids: HashSet<ProjectId>,
+    pub contact_ids: HashSet<UserId>,
+}
+
+pub struct LeftProject {
+    pub host_user_id: UserId,
+    pub host_connection_id: ConnectionId,
+    pub connection_ids: Vec<ConnectionId>,
+    pub remove_collaborator: bool,
+    pub cancel_request: Option<UserId>,
+    pub unshare: bool,
+}
+
+#[derive(Copy, Clone)]
+pub struct Metrics {
+    pub connections: usize,
+    pub registered_projects: usize,
+    pub active_projects: usize,
+    pub shared_projects: usize,
+}
+
+impl Store {
+    pub fn metrics(&self) -> Metrics {
+        const ACTIVE_PROJECT_TIMEOUT: Duration = Duration::from_secs(60);
+        let active_window_start = OffsetDateTime::now_utc() - ACTIVE_PROJECT_TIMEOUT;
+
+        let connections = self.connections.values().filter(|c| !c.admin).count();
+        let mut registered_projects = 0;
+        let mut active_projects = 0;
+        let mut shared_projects = 0;
+        for project in self.projects.values() {
+            if let Some(connection) = self.connections.get(&project.host_connection_id) {
+                if !connection.admin {
+                    registered_projects += 1;
+                    if project.is_active_since(active_window_start) {
+                        active_projects += 1;
+                        if !project.guests.is_empty() {
+                            shared_projects += 1;
+                        }
+                    }
+                }
+            }
+        }
+
+        Metrics {
+            connections,
+            registered_projects,
+            active_projects,
+            shared_projects,
+        }
+    }
+
+    #[instrument(skip(self))]
+    pub fn add_connection(&mut self, connection_id: ConnectionId, user_id: UserId, admin: bool) {
+        self.connections.insert(
+            connection_id,
+            ConnectionState {
+                user_id,
+                admin,
+                projects: Default::default(),
+                requested_projects: Default::default(),
+                channels: Default::default(),
+            },
+        );
+        self.connections_by_user_id
+            .entry(user_id)
+            .or_default()
+            .insert(connection_id);
+    }
+
+    #[instrument(skip(self))]
+    pub fn remove_connection(
+        &mut self,
+        connection_id: ConnectionId,
+    ) -> Result<RemovedConnectionState> {
+        let connection = self
+            .connections
+            .get_mut(&connection_id)
+            .ok_or_else(|| anyhow!("no such connection"))?;
+
+        let user_id = connection.user_id;
+        let connection_projects = mem::take(&mut connection.projects);
+        let connection_channels = mem::take(&mut connection.channels);
+
+        let mut result = RemovedConnectionState::default();
+        result.user_id = user_id;
+
+        // Leave all channels.
+        for channel_id in connection_channels {
+            self.leave_channel(connection_id, channel_id);
+        }
+
+        // Unregister and leave all projects.
+        for project_id in connection_projects {
+            if let Ok(project) = self.unregister_project(project_id, connection_id) {
+                result.hosted_projects.insert(project_id, project);
+            } else if self.leave_project(connection_id, project_id).is_ok() {
+                result.guest_project_ids.insert(project_id);
+            }
+        }
+
+        let user_connections = self.connections_by_user_id.get_mut(&user_id).unwrap();
+        user_connections.remove(&connection_id);
+        if user_connections.is_empty() {
+            self.connections_by_user_id.remove(&user_id);
+        }
+
+        self.connections.remove(&connection_id).unwrap();
+
+        Ok(result)
+    }
+
+    #[cfg(test)]
+    pub fn channel(&self, id: ChannelId) -> Option<&Channel> {
+        self.channels.get(&id)
+    }
+
+    pub fn join_channel(&mut self, connection_id: ConnectionId, channel_id: ChannelId) {
+        if let Some(connection) = self.connections.get_mut(&connection_id) {
+            connection.channels.insert(channel_id);
+            self.channels
+                .entry(channel_id)
+                .or_default()
+                .connection_ids
+                .insert(connection_id);
+        }
+    }
+
+    pub fn leave_channel(&mut self, connection_id: ConnectionId, channel_id: ChannelId) {
+        if let Some(connection) = self.connections.get_mut(&connection_id) {
+            connection.channels.remove(&channel_id);
+            if let btree_map::Entry::Occupied(mut entry) = self.channels.entry(channel_id) {
+                entry.get_mut().connection_ids.remove(&connection_id);
+                if entry.get_mut().connection_ids.is_empty() {
+                    entry.remove();
+                }
+            }
+        }
+    }
+
+    pub fn user_id_for_connection(&self, connection_id: ConnectionId) -> Result<UserId> {
+        Ok(self
+            .connections
+            .get(&connection_id)
+            .ok_or_else(|| anyhow!("unknown connection"))?
+            .user_id)
+    }
+
+    pub fn connection_ids_for_user<'a>(
+        &'a self,
+        user_id: UserId,
+    ) -> impl 'a + Iterator<Item = ConnectionId> {
+        self.connections_by_user_id
+            .get(&user_id)
+            .into_iter()
+            .flatten()
+            .copied()
+    }
+
+    pub fn is_user_online(&self, user_id: UserId) -> bool {
+        !self
+            .connections_by_user_id
+            .get(&user_id)
+            .unwrap_or(&Default::default())
+            .is_empty()
+    }
+
+    pub fn build_initial_contacts_update(
+        &self,
+        contacts: Vec<db::Contact>,
+    ) -> proto::UpdateContacts {
+        let mut update = proto::UpdateContacts::default();
+
+        for contact in contacts {
+            match contact {
+                db::Contact::Accepted {
+                    user_id,
+                    should_notify,
+                } => {
+                    update
+                        .contacts
+                        .push(self.contact_for_user(user_id, should_notify));
+                }
+                db::Contact::Outgoing { user_id } => {
+                    update.outgoing_requests.push(user_id.to_proto())
+                }
+                db::Contact::Incoming {
+                    user_id,
+                    should_notify,
+                } => update
+                    .incoming_requests
+                    .push(proto::IncomingContactRequest {
+                        requester_id: user_id.to_proto(),
+                        should_notify,
+                    }),
+            }
+        }
+
+        update
+    }
+
+    pub fn contact_for_user(&self, user_id: UserId, should_notify: bool) -> proto::Contact {
+        proto::Contact {
+            user_id: user_id.to_proto(),
+            projects: self.project_metadata_for_user(user_id),
+            online: self.is_user_online(user_id),
+            should_notify,
+        }
+    }
+
+    pub fn project_metadata_for_user(&self, user_id: UserId) -> Vec<proto::ProjectMetadata> {
+        let connection_ids = self.connections_by_user_id.get(&user_id);
+        let project_ids = connection_ids.iter().flat_map(|connection_ids| {
+            connection_ids
+                .iter()
+                .filter_map(|connection_id| self.connections.get(connection_id))
+                .flat_map(|connection| connection.projects.iter().copied())
+        });
+
+        let mut metadata = Vec::new();
+        for project_id in project_ids {
+            if let Some(project) = self.projects.get(&project_id) {
+                if project.host.user_id == user_id {
+                    metadata.push(proto::ProjectMetadata {
+                        id: project_id.to_proto(),
+                        visible_worktree_root_names: project
+                            .worktrees
+                            .values()
+                            .filter(|worktree| worktree.visible)
+                            .map(|worktree| worktree.root_name.clone())
+                            .collect(),
+                        guests: project
+                            .guests
+                            .values()
+                            .map(|guest| guest.user_id.to_proto())
+                            .collect(),
+                    });
+                }
+            }
+        }
+
+        metadata
+    }
+
+    pub fn register_project(
+        &mut self,
+        host_connection_id: ConnectionId,
+        project_id: ProjectId,
+    ) -> Result<()> {
+        let connection = self
+            .connections
+            .get_mut(&host_connection_id)
+            .ok_or_else(|| anyhow!("no such connection"))?;
+        connection.projects.insert(project_id);
+        self.projects.insert(
+            project_id,
+            Project {
+                host_connection_id,
+                host: Collaborator {
+                    user_id: connection.user_id,
+                    replica_id: 0,
+                    last_activity: None,
+                    admin: connection.admin,
+                },
+                guests: Default::default(),
+                join_requests: Default::default(),
+                active_replica_ids: Default::default(),
+                worktrees: Default::default(),
+                language_servers: Default::default(),
+            },
+        );
+        Ok(())
+    }
+
+    pub fn update_project(
+        &mut self,
+        project_id: ProjectId,
+        worktrees: &[proto::WorktreeMetadata],
+        connection_id: ConnectionId,
+    ) -> Result<()> {
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        if project.host_connection_id == connection_id {
+            let mut old_worktrees = mem::take(&mut project.worktrees);
+            for worktree in worktrees {
+                if let Some(old_worktree) = old_worktrees.remove(&worktree.id) {
+                    project.worktrees.insert(worktree.id, old_worktree);
+                } else {
+                    project.worktrees.insert(
+                        worktree.id,
+                        Worktree {
+                            root_name: worktree.root_name.clone(),
+                            visible: worktree.visible,
+                            ..Default::default()
+                        },
+                    );
+                }
+            }
+            Ok(())
+        } else {
+            Err(anyhow!("no such project"))?
+        }
+    }
+
+    pub fn unregister_project(
+        &mut self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+    ) -> Result<Project> {
+        match self.projects.entry(project_id) {
+            btree_map::Entry::Occupied(e) => {
+                if e.get().host_connection_id == connection_id {
+                    let project = e.remove();
+
+                    if let Some(host_connection) = self.connections.get_mut(&connection_id) {
+                        host_connection.projects.remove(&project_id);
+                    }
+
+                    for guest_connection in project.guests.keys() {
+                        if let Some(connection) = self.connections.get_mut(&guest_connection) {
+                            connection.projects.remove(&project_id);
+                        }
+                    }
+
+                    for requester_user_id in project.join_requests.keys() {
+                        if let Some(requester_connection_ids) =
+                            self.connections_by_user_id.get_mut(&requester_user_id)
+                        {
+                            for requester_connection_id in requester_connection_ids.iter() {
+                                if let Some(requester_connection) =
+                                    self.connections.get_mut(requester_connection_id)
+                                {
+                                    requester_connection.requested_projects.remove(&project_id);
+                                }
+                            }
+                        }
+                    }
+
+                    Ok(project)
+                } else {
+                    Err(anyhow!("no such project"))?
+                }
+            }
+            btree_map::Entry::Vacant(_) => Err(anyhow!("no such project"))?,
+        }
+    }
+
+    pub fn update_diagnostic_summary(
+        &mut self,
+        project_id: ProjectId,
+        worktree_id: u64,
+        connection_id: ConnectionId,
+        summary: proto::DiagnosticSummary,
+    ) -> Result<Vec<ConnectionId>> {
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        if project.host_connection_id == connection_id {
+            let worktree = project
+                .worktrees
+                .get_mut(&worktree_id)
+                .ok_or_else(|| anyhow!("no such worktree"))?;
+            worktree
+                .diagnostic_summaries
+                .insert(summary.path.clone().into(), summary);
+            return Ok(project.connection_ids());
+        }
+
+        Err(anyhow!("no such worktree"))?
+    }
+
+    pub fn start_language_server(
+        &mut self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+        language_server: proto::LanguageServer,
+    ) -> Result<Vec<ConnectionId>> {
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        if project.host_connection_id == connection_id {
+            project.language_servers.push(language_server);
+            return Ok(project.connection_ids());
+        }
+
+        Err(anyhow!("no such project"))?
+    }
+
+    pub fn request_join_project(
+        &mut self,
+        requester_id: UserId,
+        project_id: ProjectId,
+        receipt: Receipt<proto::JoinProject>,
+    ) -> Result<()> {
+        let connection = self
+            .connections
+            .get_mut(&receipt.sender_id)
+            .ok_or_else(|| anyhow!("no such connection"))?;
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        connection.requested_projects.insert(project_id);
+        project
+            .join_requests
+            .entry(requester_id)
+            .or_default()
+            .push(receipt);
+        Ok(())
+    }
+
+    pub fn deny_join_project_request(
+        &mut self,
+        responder_connection_id: ConnectionId,
+        requester_id: UserId,
+        project_id: ProjectId,
+    ) -> Option<Vec<Receipt<proto::JoinProject>>> {
+        let project = self.projects.get_mut(&project_id)?;
+        if responder_connection_id != project.host_connection_id {
+            return None;
+        }
+
+        let receipts = project.join_requests.remove(&requester_id)?;
+        for receipt in &receipts {
+            let requester_connection = self.connections.get_mut(&receipt.sender_id)?;
+            requester_connection.requested_projects.remove(&project_id);
+        }
+        project.host.last_activity = Some(OffsetDateTime::now_utc());
+
+        Some(receipts)
+    }
+
+    pub fn accept_join_project_request(
+        &mut self,
+        responder_connection_id: ConnectionId,
+        requester_id: UserId,
+        project_id: ProjectId,
+    ) -> Option<(Vec<(Receipt<proto::JoinProject>, ReplicaId)>, &Project)> {
+        let project = self.projects.get_mut(&project_id)?;
+        if responder_connection_id != project.host_connection_id {
+            return None;
+        }
+
+        let receipts = project.join_requests.remove(&requester_id)?;
+        let mut receipts_with_replica_ids = Vec::new();
+        for receipt in receipts {
+            let requester_connection = self.connections.get_mut(&receipt.sender_id)?;
+            requester_connection.requested_projects.remove(&project_id);
+            requester_connection.projects.insert(project_id);
+            let mut replica_id = 1;
+            while project.active_replica_ids.contains(&replica_id) {
+                replica_id += 1;
+            }
+            project.active_replica_ids.insert(replica_id);
+            project.guests.insert(
+                receipt.sender_id,
+                Collaborator {
+                    replica_id,
+                    user_id: requester_id,
+                    last_activity: Some(OffsetDateTime::now_utc()),
+                    admin: requester_connection.admin,
+                },
+            );
+            receipts_with_replica_ids.push((receipt, replica_id));
+        }
+
+        project.host.last_activity = Some(OffsetDateTime::now_utc());
+        Some((receipts_with_replica_ids, project))
+    }
+
+    pub fn leave_project(
+        &mut self,
+        connection_id: ConnectionId,
+        project_id: ProjectId,
+    ) -> Result<LeftProject> {
+        let user_id = self.user_id_for_connection(connection_id)?;
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+
+        // If the connection leaving the project is a collaborator, remove it.
+        let remove_collaborator = if let Some(guest) = project.guests.remove(&connection_id) {
+            project.active_replica_ids.remove(&guest.replica_id);
+            true
+        } else {
+            false
+        };
+
+        // If the connection leaving the project has a pending request, remove it.
+        // If that user has no other pending requests on other connections, indicate that the request should be cancelled.
+        let mut cancel_request = None;
+        if let Entry::Occupied(mut entry) = project.join_requests.entry(user_id) {
+            entry
+                .get_mut()
+                .retain(|receipt| receipt.sender_id != connection_id);
+            if entry.get().is_empty() {
+                entry.remove();
+                cancel_request = Some(user_id);
+            }
+        }
+
+        if let Some(connection) = self.connections.get_mut(&connection_id) {
+            connection.projects.remove(&project_id);
+        }
+
+        let connection_ids = project.connection_ids();
+        let unshare = connection_ids.len() <= 1 && project.join_requests.is_empty();
+        if unshare {
+            project.language_servers.clear();
+            for worktree in project.worktrees.values_mut() {
+                worktree.diagnostic_summaries.clear();
+                worktree.entries.clear();
+                worktree.extension_counts.clear();
+            }
+        }
+
+        Ok(LeftProject {
+            host_connection_id: project.host_connection_id,
+            host_user_id: project.host.user_id,
+            connection_ids,
+            cancel_request,
+            unshare,
+            remove_collaborator,
+        })
+    }
+
+    pub fn update_worktree(
+        &mut self,
+        connection_id: ConnectionId,
+        project_id: ProjectId,
+        worktree_id: u64,
+        worktree_root_name: &str,
+        removed_entries: &[u64],
+        updated_entries: &[proto::Entry],
+        scan_id: u64,
+    ) -> Result<(Vec<ConnectionId>, bool, HashMap<String, usize>)> {
+        let project = self.write_project(project_id, connection_id)?;
+        let connection_ids = project.connection_ids();
+        let mut worktree = project.worktrees.entry(worktree_id).or_default();
+        let metadata_changed = worktree_root_name != worktree.root_name;
+        worktree.root_name = worktree_root_name.to_string();
+
+        for entry_id in removed_entries {
+            if let Some(entry) = worktree.entries.remove(&entry_id) {
+                if !entry.is_ignored {
+                    if let Some(extension) = extension_for_entry(&entry) {
+                        if let Some(count) = worktree.extension_counts.get_mut(extension) {
+                            *count = count.saturating_sub(1);
+                        }
+                    }
+                }
+            }
+        }
+
+        for entry in updated_entries {
+            if let Some(old_entry) = worktree.entries.insert(entry.id, entry.clone()) {
+                if !old_entry.is_ignored {
+                    if let Some(extension) = extension_for_entry(&old_entry) {
+                        if let Some(count) = worktree.extension_counts.get_mut(extension) {
+                            *count = count.saturating_sub(1);
+                        }
+                    }
+                }
+            }
+
+            if !entry.is_ignored {
+                if let Some(extension) = extension_for_entry(&entry) {
+                    if let Some(count) = worktree.extension_counts.get_mut(extension) {
+                        *count += 1;
+                    } else {
+                        worktree.extension_counts.insert(extension.into(), 1);
+                    }
+                }
+            }
+        }
+
+        worktree.scan_id = scan_id;
+        Ok((
+            connection_ids,
+            metadata_changed,
+            worktree.extension_counts.clone(),
+        ))
+    }
+
+    pub fn project_connection_ids(
+        &self,
+        project_id: ProjectId,
+        acting_connection_id: ConnectionId,
+    ) -> Result<Vec<ConnectionId>> {
+        Ok(self
+            .read_project(project_id, acting_connection_id)?
+            .connection_ids())
+    }
+
+    pub fn channel_connection_ids(&self, channel_id: ChannelId) -> Result<Vec<ConnectionId>> {
+        Ok(self
+            .channels
+            .get(&channel_id)
+            .ok_or_else(|| anyhow!("no such channel"))?
+            .connection_ids())
+    }
+
+    pub fn project(&self, project_id: ProjectId) -> Result<&Project> {
+        self.projects
+            .get(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))
+    }
+
+    pub fn register_project_activity(
+        &mut self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+    ) -> Result<()> {
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        let collaborator = if connection_id == project.host_connection_id {
+            &mut project.host
+        } else if let Some(guest) = project.guests.get_mut(&connection_id) {
+            guest
+        } else {
+            return Err(anyhow!("no such project"))?;
+        };
+        collaborator.last_activity = Some(OffsetDateTime::now_utc());
+        Ok(())
+    }
+
+    pub fn projects(&self) -> impl Iterator<Item = (&ProjectId, &Project)> {
+        self.projects.iter()
+    }
+
+    pub fn read_project(
+        &self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+    ) -> Result<&Project> {
+        let project = self
+            .projects
+            .get(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        if project.host_connection_id == connection_id
+            || project.guests.contains_key(&connection_id)
+        {
+            Ok(project)
+        } else {
+            Err(anyhow!("no such project"))?
+        }
+    }
+
+    fn write_project(
+        &mut self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+    ) -> Result<&mut Project> {
+        let project = self
+            .projects
+            .get_mut(&project_id)
+            .ok_or_else(|| anyhow!("no such project"))?;
+        if project.host_connection_id == connection_id
+            || project.guests.contains_key(&connection_id)
+        {
+            Ok(project)
+        } else {
+            Err(anyhow!("no such project"))?
+        }
+    }
+
+    #[cfg(test)]
+    pub fn check_invariants(&self) {
+        for (connection_id, connection) in &self.connections {
+            for project_id in &connection.projects {
+                let project = &self.projects.get(&project_id).unwrap();
+                if project.host_connection_id != *connection_id {
+                    assert!(project.guests.contains_key(connection_id));
+                }
+
+                for (worktree_id, worktree) in project.worktrees.iter() {
+                    let mut paths = HashMap::default();
+                    for entry in worktree.entries.values() {
+                        let prev_entry = paths.insert(&entry.path, entry);
+                        assert_eq!(
+                            prev_entry,
+                            None,
+                            "worktree {:?}, duplicate path for entries {:?} and {:?}",
+                            worktree_id,
+                            prev_entry.unwrap(),
+                            entry
+                        );
+                    }
+                }
+            }
+            for channel_id in &connection.channels {
+                let channel = self.channels.get(channel_id).unwrap();
+                assert!(channel.connection_ids.contains(connection_id));
+            }
+            assert!(self
+                .connections_by_user_id
+                .get(&connection.user_id)
+                .unwrap()
+                .contains(connection_id));
+        }
+
+        for (user_id, connection_ids) in &self.connections_by_user_id {
+            for connection_id in connection_ids {
+                assert_eq!(
+                    self.connections.get(connection_id).unwrap().user_id,
+                    *user_id
+                );
+            }
+        }
+
+        for (project_id, project) in &self.projects {
+            let host_connection = self.connections.get(&project.host_connection_id).unwrap();
+            assert!(host_connection.projects.contains(project_id));
+
+            for guest_connection_id in project.guests.keys() {
+                let guest_connection = self.connections.get(guest_connection_id).unwrap();
+                assert!(guest_connection.projects.contains(project_id));
+            }
+            assert_eq!(project.active_replica_ids.len(), project.guests.len(),);
+            assert_eq!(
+                project.active_replica_ids,
+                project
+                    .guests
+                    .values()
+                    .map(|guest| guest.replica_id)
+                    .collect::<HashSet<_>>(),
+            );
+        }
+
+        for (channel_id, channel) in &self.channels {
+            for connection_id in &channel.connection_ids {
+                let connection = self.connections.get(connection_id).unwrap();
+                assert!(connection.channels.contains(channel_id));
+            }
+        }
+    }
+}
+
+impl Project {
+    fn is_active_since(&self, start_time: OffsetDateTime) -> bool {
+        self.guests
+            .values()
+            .chain([&self.host])
+            .any(|collaborator| {
+                collaborator
+                    .last_activity
+                    .map_or(false, |active_time| active_time > start_time)
+            })
+    }
+
+    pub fn guest_connection_ids(&self) -> Vec<ConnectionId> {
+        self.guests.keys().copied().collect()
+    }
+
+    pub fn connection_ids(&self) -> Vec<ConnectionId> {
+        self.guests
+            .keys()
+            .copied()
+            .chain(Some(self.host_connection_id))
+            .collect()
+    }
+}
+
+impl Channel {
+    fn connection_ids(&self) -> Vec<ConnectionId> {
+        self.connection_ids.iter().copied().collect()
+    }
+}
+
+fn extension_for_entry(entry: &proto::Entry) -> Option<&str> {
+    str::from_utf8(&entry.path)
+        .ok()
+        .map(Path::new)
+        .and_then(|p| p.extension())
+        .and_then(|e| e.to_str())
+}

crates/collections/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [lib]
 path = "src/collections.rs"
+doctest = false
 
 [features]
 test-support = ["seahash"]

crates/command_palette/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "command_palette"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/command_palette.rs"
+doctest = false
+
+[dependencies]
+collections = { path = "../collections" }
+editor = { path = "../editor" }
+fuzzy = { path = "../fuzzy" }
+gpui = { path = "../gpui" }
+picker = { path = "../picker" }
+project = { path = "../project" }
+settings = { path = "../settings" }
+util = { path = "../util" }
+theme = { path = "../theme" }
+workspace = { path = "../workspace" }
+
+[dev-dependencies]
+gpui = { path = "../gpui", features = ["test-support"] }
+editor = { path = "../editor", features = ["test-support"] }
+project = { path = "../project", features = ["test-support"] }
+serde_json = { version = "1.0", features = ["preserve_order"] }
+workspace = { path = "../workspace", features = ["test-support"] }
+ctor = "0.1"
+env_logger = "0.9"

crates/command_palette/src/command_palette.rs

@@ -0,0 +1,417 @@
+use collections::HashSet;
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::{
+    actions,
+    elements::{ChildView, Flex, Label, ParentElement},
+    keymap::Keystroke,
+    Action, Element, Entity, MouseState, MutableAppContext, View, ViewContext, ViewHandle,
+};
+use picker::{Picker, PickerDelegate};
+use settings::Settings;
+use std::cmp;
+use workspace::Workspace;
+
+#[derive(Default)]
+pub struct CommandPaletteFilter {
+    pub filtered_namespaces: HashSet<&'static str>,
+}
+
+pub fn init(cx: &mut MutableAppContext) {
+    cx.add_action(CommandPalette::toggle);
+    Picker::<CommandPalette>::init(cx);
+}
+
+actions!(command_palette, [Toggle]);
+
+pub struct CommandPalette {
+    picker: ViewHandle<Picker<Self>>,
+    actions: Vec<Command>,
+    matches: Vec<StringMatch>,
+    selected_ix: usize,
+    focused_view_id: usize,
+}
+
+pub enum Event {
+    Dismissed,
+    Confirmed {
+        window_id: usize,
+        focused_view_id: usize,
+        action: Box<dyn Action>,
+    },
+}
+
+struct Command {
+    name: String,
+    action: Box<dyn Action>,
+    keystrokes: Vec<Keystroke>,
+}
+
+impl CommandPalette {
+    pub fn new(focused_view_id: usize, cx: &mut ViewContext<Self>) -> Self {
+        let this = cx.weak_handle();
+        let actions = cx
+            .available_actions(cx.window_id(), focused_view_id)
+            .filter_map(|(name, action, bindings)| {
+                if cx.has_global::<CommandPaletteFilter>() {
+                    let filter = cx.global::<CommandPaletteFilter>();
+                    if filter.filtered_namespaces.contains(action.namespace()) {
+                        return None;
+                    }
+                }
+
+                Some(Command {
+                    name: humanize_action_name(name),
+                    action,
+                    keystrokes: bindings
+                        .last()
+                        .map_or(Vec::new(), |binding| binding.keystrokes().to_vec()),
+                })
+            })
+            .collect();
+
+        let picker = cx.add_view(|cx| Picker::new(this, cx));
+        Self {
+            picker,
+            actions,
+            matches: vec![],
+            selected_ix: 0,
+            focused_view_id,
+        }
+    }
+
+    fn toggle(_: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
+        let workspace = cx.handle();
+        let window_id = cx.window_id();
+        let focused_view_id = cx.focused_view_id(window_id).unwrap_or(workspace.id());
+
+        cx.as_mut().defer(move |cx| {
+            let this = cx.add_view(window_id, |cx| Self::new(focused_view_id, cx));
+            workspace.update(cx, |workspace, cx| {
+                workspace.toggle_modal(cx, |_, cx| {
+                    cx.subscribe(&this, Self::on_event).detach();
+                    this
+                });
+            });
+        });
+    }
+
+    fn on_event(
+        workspace: &mut Workspace,
+        _: ViewHandle<Self>,
+        event: &Event,
+        cx: &mut ViewContext<Workspace>,
+    ) {
+        match event {
+            Event::Dismissed => workspace.dismiss_modal(cx),
+            Event::Confirmed {
+                window_id,
+                focused_view_id,
+                action,
+            } => {
+                let window_id = *window_id;
+                let focused_view_id = *focused_view_id;
+                let action = (*action).boxed_clone();
+                workspace.dismiss_modal(cx);
+                cx.as_mut()
+                    .defer(move |cx| cx.dispatch_action_at(window_id, focused_view_id, &*action))
+            }
+        }
+    }
+}
+
+impl Entity for CommandPalette {
+    type Event = Event;
+}
+
+impl View for CommandPalette {
+    fn ui_name() -> &'static str {
+        "CommandPalette"
+    }
+
+    fn render(&mut self, _: &mut gpui::RenderContext<'_, Self>) -> gpui::ElementBox {
+        ChildView::new(self.picker.clone()).boxed()
+    }
+
+    fn on_focus(&mut self, cx: &mut ViewContext<Self>) {
+        cx.focus(&self.picker);
+    }
+}
+
+impl PickerDelegate for CommandPalette {
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_ix
+    }
+
+    fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Self>) {
+        self.selected_ix = ix;
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        cx: &mut gpui::ViewContext<Self>,
+    ) -> gpui::Task<()> {
+        let candidates = self
+            .actions
+            .iter()
+            .enumerate()
+            .map(|(ix, command)| StringMatchCandidate {
+                id: ix,
+                string: command.name.to_string(),
+                char_bag: command.name.chars().collect(),
+            })
+            .collect::<Vec<_>>();
+        cx.spawn(move |this, mut cx| async move {
+            let matches = if query.is_empty() {
+                candidates
+                    .into_iter()
+                    .enumerate()
+                    .map(|(index, candidate)| StringMatch {
+                        candidate_id: index,
+                        string: candidate.string,
+                        positions: Vec::new(),
+                        score: 0.0,
+                    })
+                    .collect()
+            } else {
+                fuzzy::match_strings(
+                    &candidates,
+                    &query,
+                    true,
+                    10000,
+                    &Default::default(),
+                    cx.background(),
+                )
+                .await
+            };
+            this.update(&mut cx, |this, _| {
+                this.matches = matches;
+                if this.matches.is_empty() {
+                    this.selected_ix = 0;
+                } else {
+                    this.selected_ix = cmp::min(this.selected_ix, this.matches.len() - 1);
+                }
+            });
+        })
+    }
+
+    fn dismiss(&mut self, cx: &mut ViewContext<Self>) {
+        cx.emit(Event::Dismissed);
+    }
+
+    fn confirm(&mut self, cx: &mut ViewContext<Self>) {
+        if !self.matches.is_empty() {
+            let action_ix = self.matches[self.selected_ix].candidate_id;
+            cx.emit(Event::Confirmed {
+                window_id: cx.window_id(),
+                focused_view_id: self.focused_view_id,
+                action: self.actions.remove(action_ix).action,
+            });
+        } else {
+            cx.emit(Event::Dismissed);
+        }
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        mouse_state: MouseState,
+        selected: bool,
+        cx: &gpui::AppContext,
+    ) -> gpui::ElementBox {
+        let mat = &self.matches[ix];
+        let command = &self.actions[mat.candidate_id];
+        let settings = cx.global::<Settings>();
+        let theme = &settings.theme;
+        let style = theme.picker.item.style_for(mouse_state, selected);
+        let key_style = &theme.command_palette.key.style_for(mouse_state, selected);
+        let keystroke_spacing = theme.command_palette.keystroke_spacing;
+
+        Flex::row()
+            .with_child(
+                Label::new(mat.string.clone(), style.label.clone())
+                    .with_highlights(mat.positions.clone())
+                    .boxed(),
+            )
+            .with_children(command.keystrokes.iter().map(|keystroke| {
+                Flex::row()
+                    .with_children(
+                        [
+                            (keystroke.ctrl, "^"),
+                            (keystroke.alt, "⎇"),
+                            (keystroke.cmd, "⌘"),
+                            (keystroke.shift, "⇧"),
+                        ]
+                        .into_iter()
+                        .filter_map(|(modifier, label)| {
+                            if modifier {
+                                Some(
+                                    Label::new(label.into(), key_style.label.clone())
+                                        .contained()
+                                        .with_style(key_style.container)
+                                        .boxed(),
+                                )
+                            } else {
+                                None
+                            }
+                        }),
+                    )
+                    .with_child(
+                        Label::new(keystroke.key.clone(), key_style.label.clone())
+                            .contained()
+                            .with_style(key_style.container)
+                            .boxed(),
+                    )
+                    .contained()
+                    .with_margin_left(keystroke_spacing)
+                    .flex_float()
+                    .boxed()
+            }))
+            .contained()
+            .with_style(style.container)
+            .boxed()
+    }
+}
+
+fn humanize_action_name(name: &str) -> String {
+    let capacity = name.len() + name.chars().filter(|c| c.is_uppercase()).count();
+    let mut result = String::with_capacity(capacity);
+    for char in name.chars() {
+        if char == ':' {
+            if result.ends_with(':') {
+                result.push(' ');
+            } else {
+                result.push(':');
+            }
+        } else if char == '_' {
+            result.push(' ');
+        } else if char.is_uppercase() {
+            if !result.ends_with(' ') {
+                result.push(' ');
+            }
+            result.extend(char.to_lowercase());
+        } else {
+            result.push(char);
+        }
+    }
+    result
+}
+
+impl std::fmt::Debug for Command {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Command")
+            .field("name", &self.name)
+            .field("keystrokes", &self.keystrokes)
+            .finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use editor::Editor;
+    use gpui::TestAppContext;
+    use project::Project;
+    use workspace::{AppState, Workspace};
+
+    #[test]
+    fn test_humanize_action_name() {
+        assert_eq!(
+            humanize_action_name("editor::GoToDefinition"),
+            "editor: go to definition"
+        );
+        assert_eq!(
+            humanize_action_name("editor::Backspace"),
+            "editor: backspace"
+        );
+        assert_eq!(
+            humanize_action_name("go_to_line::Deploy"),
+            "go to line: deploy"
+        );
+    }
+
+    #[gpui::test]
+    async fn test_command_palette(cx: &mut TestAppContext) {
+        let app_state = cx.update(AppState::test);
+
+        cx.update(|cx| {
+            editor::init(cx);
+            workspace::init(app_state.clone(), cx);
+            init(cx);
+        });
+
+        let project = Project::test(app_state.fs.clone(), [], cx).await;
+        let (window_id, workspace) = cx.add_window(|cx| Workspace::new(project, cx));
+        let editor = cx.add_view(window_id, |cx| {
+            let mut editor = Editor::single_line(None, cx);
+            editor.set_text("abc", cx);
+            editor
+        });
+
+        workspace.update(cx, |workspace, cx| {
+            cx.focus(editor.clone());
+            workspace.add_item(Box::new(editor.clone()), cx)
+        });
+
+        workspace.update(cx, |workspace, cx| {
+            CommandPalette::toggle(workspace, &Toggle, cx)
+        });
+
+        let palette = workspace.read_with(cx, |workspace, _| {
+            workspace
+                .modal()
+                .unwrap()
+                .clone()
+                .downcast::<CommandPalette>()
+                .unwrap()
+        });
+
+        palette
+            .update(cx, |palette, cx| {
+                palette.update_matches("bcksp".to_string(), cx)
+            })
+            .await;
+
+        palette.update(cx, |palette, cx| {
+            assert_eq!(palette.matches[0].string, "editor: backspace");
+            palette.confirm(cx);
+        });
+
+        editor.read_with(cx, |editor, cx| {
+            assert_eq!(editor.text(cx), "ab");
+        });
+
+        // Add namespace filter, and redeploy the palette
+        cx.update(|cx| {
+            cx.update_default_global::<CommandPaletteFilter, _, _>(|filter, _| {
+                filter.filtered_namespaces.insert("editor");
+            })
+        });
+
+        workspace.update(cx, |workspace, cx| {
+            CommandPalette::toggle(workspace, &Toggle, cx);
+        });
+
+        // Assert editor command not present
+        let palette = workspace.read_with(cx, |workspace, _| {
+            workspace
+                .modal()
+                .unwrap()
+                .clone()
+                .downcast::<CommandPalette>()
+                .unwrap()
+        });
+
+        palette
+            .update(cx, |palette, cx| {
+                palette.update_matches("bcksp".to_string(), cx)
+            })
+            .await;
+
+        palette.update(cx, |palette, _| assert!(palette.matches.is_empty()));
+    }
+}