Merge branch 'debugger' into variable-list-tear-down

Breakpoint store teardown

.mailmap

@@ -21,8 +21,6 @@ Andrei Zvonimir Crnković <andrei@0x7f.dev>
 Andrei Zvonimir Crnković <andrei@0x7f.dev> <andreicek@0x7f.dev>
 Antonio Scandurra <me@as-cii.com>
 Antonio Scandurra <me@as-cii.com> <antonio@zed.dev>
-Ben Kunkle <ben@zed.dev>
-Ben Kunkle <ben@zed.dev> <ben.kunkle@gmail.com>
 Bennet Bo Fenner <bennet@zed.dev>
 Bennet Bo Fenner <bennet@zed.dev> <53836821+bennetbo@users.noreply.github.com>
 Bennet Bo Fenner <bennet@zed.dev> <bennetbo@gmx.de>
@@ -114,8 +112,6 @@ Sebastijan Kelnerič <sebastijan.kelneric@sebba.dev> <sebastijan.kelneric@vichav
 Sergey Onufrienko <sergey@onufrienko.com>
 Shish <webmaster@shishnet.org>
 Shish <webmaster@shishnet.org> <shish@shishnet.org>
-Smit Barmase <0xtimsb@gmail.com>
-Smit Barmase <0xtimsb@gmail.com> <smit@zed.dev>
 Thorben Kröger <dev@thorben.net>
 Thorben Kröger <dev@thorben.net> <thorben.kroeger@hexagon.com>
 Thorsten Ball <thorsten@zed.dev>

.zed/debug.json

@@ -0,0 +1,19 @@
+[
+  {
+    "label": "Debug Zed with LLDB",
+    "adapter": "lldb",
+    "program": "$ZED_WORKTREE_ROOT/target/debug/zed",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "Debug Zed with GDB",
+    "adapter": "gdb",
+    "program": "$ZED_WORKTREE_ROOT/target/debug/zed",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "initialize_args": {
+      "stopAtBeginningOfMainSubprogram": true
+    }
+  }
+]

.zed/settings.json

@@ -14,12 +14,12 @@
     },
     "JSON": {
       "tab_size": 2,
-      "preferred_line_length": 120,
+      "preferred_line_length": 100,
       "formatter": "prettier"
     },
     "JSONC": {
       "tab_size": 2,
-      "preferred_line_length": 120,
+      "preferred_line_length": 100,
       "formatter": "prettier"
     },
     "JavaScript": {

Cargo.lock

@@ -13,7 +13,6 @@ dependencies = [
  "futures 0.3.31",
  "gpui",
  "language",
- "lsp",
  "project",
  "smallvec",
  "ui",
@@ -2820,9 +2819,12 @@ dependencies = [
  "clock",
  "collab_ui",
  "collections",
+ "command_palette_hooks",
  "context_server",
  "ctor",
+ "dap",
  "dashmap 6.1.0",
+ "debugger_ui",
  "derive_more",
  "editor",
  "env_logger 0.11.6",
@@ -2833,7 +2835,6 @@ dependencies = [
  "futures 0.3.31",
  "git",
  "git_hosting_providers",
- "git_ui",
  "google_ai",
  "gpui",
  "hex",
@@ -3101,7 +3102,6 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "assistant_tool",
- "async-trait",
  "collections",
  "command_palette_hooks",
  "context_server_settings",
@@ -3752,6 +3752,67 @@ dependencies = [
  "syn 2.0.90",
 ]
 
+[[package]]
+name = "dap"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-compression",
+ "async-pipe",
+ "async-tar",
+ "async-trait",
+ "client",
+ "collections",
+ "dap-types",
+ "env_logger 0.11.6",
+ "fs",
+ "futures 0.3.31",
+ "gpui",
+ "http_client",
+ "language",
+ "log",
+ "node_runtime",
+ "parking_lot",
+ "paths",
+ "schemars",
+ "serde",
+ "serde_json",
+ "settings",
+ "smallvec",
+ "smol",
+ "sysinfo",
+ "task",
+ "util",
+]
+
+[[package]]
+name = "dap-types"
+version = "0.0.1"
+source = "git+https://github.com/zed-industries/dap-types?rev=bf5632dc19f806e8a435c9f04a4bfe7322badea2#bf5632dc19f806e8a435c9f04a4bfe7322badea2"
+dependencies = [
+ "schemars",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "dap_adapters"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "dap",
+ "gpui",
+ "language",
+ "paths",
+ "regex",
+ "serde",
+ "serde_json",
+ "sysinfo",
+ "task",
+ "util",
+]
+
 [[package]]
 name = "dashmap"
 version = "5.5.3"
@@ -3825,6 +3886,59 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "debugger_tools"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "dap",
+ "editor",
+ "futures 0.3.31",
+ "gpui",
+ "project",
+ "serde_json",
+ "settings",
+ "smol",
+ "util",
+ "workspace",
+]
+
+[[package]]
+name = "debugger_ui"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "client",
+ "collections",
+ "command_palette_hooks",
+ "dap",
+ "editor",
+ "env_logger 0.11.6",
+ "feature_flags",
+ "fuzzy",
+ "gpui",
+ "language",
+ "log",
+ "menu",
+ "picker",
+ "pretty_assertions",
+ "project",
+ "rpc",
+ "serde",
+ "serde_json",
+ "settings",
+ "sum_tree",
+ "sysinfo",
+ "task",
+ "tasks_ui",
+ "terminal_view",
+ "theme",
+ "ui",
+ "unindent",
+ "util",
+ "workspace",
+]
+
 [[package]]
 name = "deepseek"
 version = "0.1.0"
@@ -4125,6 +4239,7 @@ dependencies = [
  "log",
  "lsp",
  "markdown",
+ "menu",
  "multi_buffer",
  "ordered-float 2.10.1",
  "parking_lot",
@@ -10180,6 +10295,8 @@ dependencies = [
  "client",
  "clock",
  "collections",
+ "dap",
+ "dap_adapters",
  "env_logger 0.11.6",
  "fancy-regex 0.14.0",
  "fs",
@@ -10191,6 +10308,7 @@ dependencies = [
  "gpui",
  "http_client",
  "image",
+ "indexmap",
  "itertools 0.14.0",
  "language",
  "log",
@@ -10839,6 +10957,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "auto_update",
+ "dap",
  "editor",
  "extension_host",
  "file_finder",
@@ -13358,6 +13477,7 @@ dependencies = [
  "parking_lot",
  "schemars",
  "serde",
+ "serde_json",
  "serde_json_lenient",
  "sha2",
  "shellexpand 2.1.2",
@@ -16732,7 +16852,7 @@ dependencies = [
 
 [[package]]
 name = "zed"
-version = "0.176.2"
+version = "0.176.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
@@ -16762,6 +16882,8 @@ dependencies = [
  "component_preview",
  "copilot",
  "db",
+ "debugger_tools",
+ "debugger_ui",
  "diagnostics",
  "editor",
  "env_logger 0.11.6",

Cargo.toml

@@ -35,6 +35,10 @@ members = [
     "crates/context_server_settings",
     "crates/copilot",
     "crates/credentials_provider",
+    "crates/dap",
+    "crates/dap_adapters",
+    "crates/debugger_tools",
+    "crates/debugger_ui",
     "crates/db",
     "crates/deepseek",
     "crates/diagnostics",
@@ -239,7 +243,11 @@ context_server = { path = "crates/context_server" }
 context_server_settings = { path = "crates/context_server_settings" }
 copilot = { path = "crates/copilot" }
 credentials_provider = { path = "crates/credentials_provider" }
+dap = { path = "crates/dap" }
+dap_adapters = { path = "crates/dap_adapters" }
 db = { path = "crates/db" }
+debugger_ui = { path = "crates/debugger_ui" }
+debugger_tools = { path = "crates/debugger_tools" }
 deepseek = { path = "crates/deepseek" }
 diagnostics = { path = "crates/diagnostics" }
 buffer_diff = { path = "crates/buffer_diff" }

assets/icons/debug.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-bug"><path d="m8 2 1.88 1.88"/><path d="M14.12 3.88 16 2"/><path d="M9 7.13v-1a3.003 3.003 0 1 1 6 0v1"/><path d="M12 20c-3.3 0-6-2.7-6-6v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 4v3c0 3.3-2.7 6-6 6"/><path d="M12 20v-9"/><path d="M6.53 9C4.6 8.8 3 7.1 3 5"/><path d="M6 13H2"/><path d="M3 21c0-2.1 1.7-3.9 3.8-4"/><path d="M20.97 5c0 2.1-1.6 3.8-3.5 4"/><path d="M22 13h-4"/><path d="M17.2 17c2.1.1 3.8 1.9 3.8 4"/></svg>

assets/icons/debug_breakpoint.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="currentColor" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle"><circle cx="12" cy="12" r="10"/></svg>

assets/icons/debug_continue.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-step-forward"><line x1="6" x2="6" y1="4" y2="20"/><polygon points="10,4 20,12 10,20"/></svg>

assets/icons/debug_disconnect.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-unplug"><path d="m19 5 3-3"/><path d="m2 22 3-3"/><path d="M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z"/><path d="M7.5 13.5 10 11"/><path d="M10.5 16.5 13 14"/><path d="m12 6 6 6 2.3-2.3a2.4 2.4 0 0 0 0-3.4l-2.6-2.6a2.4 2.4 0 0 0-3.4 0Z"/></svg>

assets/icons/debug_ignore_breakpoints.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-circle-off"><path d="m2 2 20 20"/><path d="M8.35 2.69A10 10 0 0 1 21.3 15.65"/><path d="M19.08 19.08A10 10 0 1 1 4.92 4.92"/></svg>

assets/icons/debug_log_breakpoint.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="currentColor" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-message-circle"><path d="M7.9 20A9 9 0 1 0 4 16.1L2 22Z"/></svg>

assets/icons/debug_pause.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-pause"><rect x="14" y="4" width="4" height="16" rx="1"/><rect x="6" y="4" width="4" height="16" rx="1"/></svg>

assets/icons/debug_restart.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-rotate-ccw"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>

assets/icons/debug_step_back.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-undo-dot"><path d="M21 17a9 9 0 0 0-15-6.7L3 13"/><path d="M3 7v6h6"/><circle cx="12" cy="17" r="1"/></svg>

assets/icons/debug_step_into.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-arrow-up-from-dot">
+  <path d="m5 15 7 7 7-7"/>
+  <path d="M12 8v14"/>
+  <circle cx="12" cy="3" r="1"/>
+</svg>

assets/icons/debug_step_out.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-arrow-up-from-dot">
+  <path d="m3 10 9-8 9 8"/>
+  <path d="M12 17V2"/>
+  <circle cx="12" cy="21" r="1"/>
+</svg>

assets/icons/debug_step_over.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-redo-dot">
+  <circle cx="12" cy="17" r="1"/>
+  <path d="M21 7v6h-6"/>
+  <path d="M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7"/>
+</svg>

assets/icons/debug_stop.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square"><rect width="18" height="18" x="3" y="3" rx="2"/></svg>

assets/keymaps/default-linux.json

@@ -10,49 +10,24 @@
       "pagedown": "menu::SelectLast",
       "ctrl-n": "menu::SelectNext",
       "tab": "menu::SelectNext",
-      "ctrl-p": "menu::SelectPrevious",
-      "shift-tab": "menu::SelectPrevious",
+      "ctrl-p": "menu::SelectPrev",
+      "shift-tab": "menu::SelectPrev",
       "enter": "menu::Confirm",
       "ctrl-enter": "menu::SecondaryConfirm",
       "ctrl-escape": "menu::Cancel",
       "ctrl-c": "menu::Cancel",
       "escape": "menu::Cancel",
       "alt-shift-enter": "menu::Restart",
-      "alt-enter": [
-        "picker::ConfirmInput",
-        {
-          "secondary": false
-        }
-      ],
-      "ctrl-alt-enter": [
-        "picker::ConfirmInput",
-        {
-          "secondary": true
-        }
-      ],
+      "alt-enter": ["picker::ConfirmInput", { "secondary": false }],
+      "ctrl-alt-enter": ["picker::ConfirmInput", { "secondary": true }],
       "ctrl-shift-w": "workspace::CloseWindow",
       "shift-escape": "workspace::ToggleZoom",
       "open": "workspace::Open",
       "ctrl-o": "workspace::Open",
       "ctrl-=": ["zed::IncreaseBufferFontSize", { "persist": false }],
-      "ctrl-+": [
-        "zed::IncreaseBufferFontSize",
-        {
-          "persist": false
-        }
-      ],
-      "ctrl--": [
-        "zed::DecreaseBufferFontSize",
-        {
-          "persist": false
-        }
-      ],
-      "ctrl-0": [
-        "zed::ResetBufferFontSize",
-        {
-          "persist": false
-        }
-      ],
+      "ctrl-+": ["zed::IncreaseBufferFontSize", { "persist": false }],
+      "ctrl--": ["zed::DecreaseBufferFontSize", { "persist": false }],
+      "ctrl-0": ["zed::ResetBufferFontSize", { "persist": false }],
       "ctrl-,": "zed::OpenSettings",
       "ctrl-q": "zed::Quit",
       "f11": "zed::ToggleFullScreen",
@@ -63,14 +38,14 @@
   {
     "context": "Picker || menu",
     "bindings": {
-      "up": "menu::SelectPrevious",
+      "up": "menu::SelectPrev",
       "down": "menu::SelectNext"
     }
   },
   {
     "context": "Prompt",
     "bindings": {
-      "left": "menu::SelectPrevious",
+      "left": "menu::SelectPrev",
       "right": "menu::SelectNext"
     }
   },
@@ -82,7 +57,7 @@
       "backspace": "editor::Backspace",
       "delete": "editor::Delete",
       "tab": "editor::Tab",
-      "shift-tab": "editor::Backtab",
+      "shift-tab": "editor::TabPrev",
       "ctrl-k": "editor::CutToEndOfLine",
       // "ctrl-t": "editor::Transpose",
       "ctrl-k ctrl-q": "editor::Rewrap",
@@ -109,23 +84,12 @@
       "pageup": "editor::MovePageUp",
       "alt-pageup": "editor::PageUp",
       "shift-pageup": "editor::SelectPageUp",
-      "home": [
-        "editor::MoveToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true,
-          "stop_at_indent": true
-        }
-      ],
+      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": true }],
       "down": "editor::MoveDown",
       "pagedown": "editor::MovePageDown",
       "alt-pagedown": "editor::PageDown",
       "shift-pagedown": "editor::SelectPageDown",
-      "end": [
-        "editor::MoveToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
+      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": true }],
       "left": "editor::MoveLeft",
       "right": "editor::MoveRight",
       "ctrl-left": "editor::MoveToPreviousWordStart",
@@ -143,23 +107,12 @@
       "ctrl-a": "editor::SelectAll",
       "ctrl-l": "editor::SelectLine",
       "ctrl-shift-i": "editor::Format",
-      // "cmd-shift-left": ["editor::SelectToBeginningOfLine", {"stop_at_soft_wraps": true, "stop_at_indent": true }],
-      // "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true, "stop_at_indent": true }],
-      "shift-home": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true,
-          "stop_at_indent": true
-        }
-      ],
+      // "cmd-shift-left": ["editor::SelectToBeginningOfLine", {"stop_at_soft_wraps": true }],
+      // "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      "shift-home": ["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 }],
-      "shift-end": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
+      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
       // "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
       "ctrl-alt-space": "editor::ShowCharacterPalette",
       "ctrl-;": "editor::ToggleLineNumbers",
@@ -227,7 +180,7 @@
       "ctrl-k c": "assistant::CopyCode",
       "ctrl-shift-e": "project_panel::ToggleFocus",
       "ctrl-g": "search::SelectNextMatch",
-      "ctrl-shift-g": "search::SelectPreviousMatch",
+      "ctrl-shift-g": "search::SelectPrevMatch",
       "ctrl-alt-/": "assistant::ToggleModelSelector",
       "ctrl-k h": "assistant::DeployHistory",
       "ctrl-k l": "assistant::DeployPromptLibrary",
@@ -250,7 +203,7 @@
       "escape": "buffer_search::Dismiss",
       "tab": "buffer_search::FocusEditor",
       "enter": "search::SelectNextMatch",
-      "shift-enter": "search::SelectPreviousMatch",
+      "shift-enter": "search::SelectPrevMatch",
       "alt-enter": "search::SelectAllMatches",
       "find": "search::FocusSearch",
       "ctrl-f": "search::FocusSearch",
@@ -319,61 +272,26 @@
       "alt-8": ["pane::ActivateItem", 7],
       "alt-9": ["pane::ActivateItem", 8],
       "alt-0": "pane::ActivateLastItem",
-      "ctrl-pageup": "pane::ActivatePreviousItem",
+      "ctrl-pageup": "pane::ActivatePrevItem",
       "ctrl-pagedown": "pane::ActivateNextItem",
       "ctrl-shift-pageup": "pane::SwapItemLeft",
       "ctrl-shift-pagedown": "pane::SwapItemRight",
-      "ctrl-f4": [
-        "pane::CloseActiveItem",
-        {
-          "close_pinned": false
-        }
-      ],
-      "ctrl-w": [
-        "pane::CloseActiveItem",
-        {
-          "close_pinned": false
-        }
-      ],
-      "alt-ctrl-t": [
-        "pane::CloseInactiveItems",
-        {
-          "close_pinned": false
-        }
-      ],
+      "ctrl-f4": ["pane::CloseActiveItem", { "close_pinned": false }],
+      "ctrl-w": ["pane::CloseActiveItem", { "close_pinned": false }],
+      "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
       "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
-      "ctrl-k e": [
-        "pane::CloseItemsToTheLeft",
-        {
-          "close_pinned": false
-        }
-      ],
-      "ctrl-k t": [
-        "pane::CloseItemsToTheRight",
-        {
-          "close_pinned": false
-        }
-      ],
-      "ctrl-k u": [
-        "pane::CloseCleanItems",
-        {
-          "close_pinned": false
-        }
-      ],
-      "ctrl-k w": [
-        "pane::CloseAllItems",
-        {
-          "close_pinned": false
-        }
-      ],
+      "ctrl-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
+      "ctrl-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
+      "ctrl-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
+      "ctrl-k w": ["pane::CloseAllItems", { "close_pinned": false }],
       "back": "pane::GoBack",
       "ctrl-alt--": "pane::GoBack",
       "ctrl-alt-_": "pane::GoForward",
       "forward": "pane::GoForward",
       "ctrl-alt-g": "search::SelectNextMatch",
       "f3": "search::SelectNextMatch",
-      "ctrl-alt-shift-g": "search::SelectPreviousMatch",
-      "shift-f3": "search::SelectPreviousMatch",
+      "ctrl-alt-shift-g": "search::SelectPrevMatch",
+      "shift-f3": "search::SelectPrevMatch",
       "shift-find": "project_search::ToggleFocus",
       "ctrl-shift-f": "project_search::ToggleFocus",
       "ctrl-alt-shift-h": "search::ToggleReplace",
@@ -406,47 +324,17 @@
       "alt-shift-left": "editor::SelectSmallerSyntaxNode", // Shrink Selection
       "ctrl-shift-l": "editor::SelectAllMatches", // Select all occurrences of current selection
       "ctrl-f2": "editor::SelectAllMatches", // Select all occurrences of current word
-      "ctrl-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ],
-      "ctrl-shift-down": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ], // Add selection to Next Find Match
-      "ctrl-shift-up": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": false
-        }
-      ],
-      "ctrl-k ctrl-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": true
-        }
-      ],
-      "ctrl-k ctrl-shift-d": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": true
-        }
-      ],
+      "ctrl-d": ["editor::SelectNext", { "replace_newest": false }],
+      "ctrl-shift-down": ["editor::SelectNext", { "replace_newest": false }], // Add selection to Next Find Match
+      "ctrl-shift-up": ["editor::SelectPrevious", { "replace_newest": false }],
+      "ctrl-k ctrl-d": ["editor::SelectNext", { "replace_newest": true }],
+      "ctrl-k ctrl-shift-d": ["editor::SelectPrevious", { "replace_newest": true }],
       "ctrl-k ctrl-i": "editor::Hover",
-      "ctrl-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": false
-        }
-      ],
+      "ctrl-/": ["editor::ToggleComments", { "advance_downwards": false }],
       "ctrl-u": "editor::UndoSelection",
       "ctrl-shift-u": "editor::RedoSelection",
       "f8": "editor::GoToDiagnostic",
-      "shift-f8": "editor::GoToPreviousDiagnostic",
+      "shift-f8": "editor::GoToPrevDiagnostic",
       "f2": "editor::Rename",
       "f12": "editor::GoToDefinition",
       "alt-f12": "editor::GoToDefinitionSplit",
@@ -485,7 +373,7 @@
       "alt-y": "git::StageAndNext",
       "alt-shift-y": "git::UnstageAndNext",
       "alt-.": "editor::GoToHunk",
-      "alt-,": "editor::GoToPreviousHunk"
+      "alt-,": "editor::GoToPrevHunk"
     }
   },
   {
@@ -531,24 +419,14 @@
       "ctrl-alt-y": "workspace::CloseAllDocks",
       "shift-find": "pane::DeploySearch",
       "ctrl-shift-f": "pane::DeploySearch",
-      "ctrl-shift-h": [
-        "pane::DeploySearch",
-        {
-          "replace_enabled": true
-        }
-      ],
+      "ctrl-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
       "ctrl-shift-t": "pane::ReopenClosedItem",
       "ctrl-k ctrl-s": "zed::OpenKeymap",
       "ctrl-k ctrl-t": "theme_selector::Toggle",
       "ctrl-t": "project_symbols::Toggle",
       "ctrl-p": "file_finder::Toggle",
       "ctrl-tab": "tab_switcher::Toggle",
-      "ctrl-shift-tab": [
-        "tab_switcher::Toggle",
-        {
-          "select_last": true
-        }
-      ],
+      "ctrl-shift-tab": ["tab_switcher::Toggle", { "select_last": true }],
       "ctrl-e": "file_finder::Toggle",
       "f1": "command_palette::Toggle",
       "ctrl-shift-p": "command_palette::Toggle",
@@ -574,12 +452,7 @@
       "ctrl-alt-r": "task::Rerun",
       "alt-t": "task::Rerun",
       "alt-shift-t": "task::Spawn",
-      "alt-shift-r": [
-        "task::Spawn",
-        {
-          "reveal_target": "center"
-        }
-      ]
+      "alt-shift-r": ["task::Spawn", { "reveal_target": "center" }]
       // also possible to spawn tasks by name:
       // "foo-bar": ["task::Spawn", { "task_name": "MyTask", "reveal_target": "dock" }]
     }
@@ -663,8 +536,8 @@
   {
     "context": "Editor && (showing_code_actions || showing_completions)",
     "bindings": {
-      "ctrl-p": "editor::ContextMenuPrevious",
-      "up": "editor::ContextMenuPrevious",
+      "ctrl-p": "editor::ContextMenuPrev",
+      "up": "editor::ContextMenuPrev",
       "ctrl-n": "editor::ContextMenuNext",
       "down": "editor::ContextMenuNext",
       "pageup": "editor::ContextMenuFirst",
@@ -692,7 +565,7 @@
       "ctrl-alt-enter": "editor::OpenExcerptsSplit",
       "ctrl-shift-e": "pane::RevealInProjectPanel",
       "ctrl-f8": "editor::GoToHunk",
-      "ctrl-shift-f8": "editor::GoToPreviousHunk",
+      "ctrl-shift-f8": "editor::GoToPrevHunk",
       "ctrl-enter": "assistant::InlineAssist",
       "ctrl-:": "editor::ToggleInlayHints"
     }
@@ -789,7 +662,7 @@
       "alt-ctrl-r": "outline_panel::RevealInFileManager",
       "space": "outline_panel::Open",
       "shift-down": "menu::SelectNext",
-      "shift-up": "menu::SelectPrevious",
+      "shift-up": "menu::SelectPrev",
       "alt-enter": "editor::OpenExcerpts",
       "ctrl-alt-enter": "editor::OpenExcerptsSplit"
     }
@@ -817,42 +690,17 @@
       "alt-ctrl-shift-c": "workspace::CopyRelativePath",
       "enter": "project_panel::Rename",
       "f2": "project_panel::Rename",
-      "backspace": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "delete": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "shift-delete": [
-        "project_panel::Delete",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "ctrl-backspace": [
-        "project_panel::Delete",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "ctrl-delete": [
-        "project_panel::Delete",
-        {
-          "skip_prompt": false
-        }
-      ],
+      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
+      "delete": ["project_panel::Trash", { "skip_prompt": false }],
+      "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
+      "ctrl-backspace": ["project_panel::Delete", { "skip_prompt": false }],
+      "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "alt-ctrl-r": "project_panel::RevealInFileManager",
       "ctrl-shift-enter": "project_panel::OpenWithSystem",
       "shift-find": "project_panel::NewSearchInDirectory",
       "ctrl-shift-f": "project_panel::NewSearchInDirectory",
       "shift-down": "menu::SelectNext",
-      "shift-up": "menu::SelectPrevious",
+      "shift-up": "menu::SelectPrev",
       "escape": "menu::Cancel"
     }
   },
@@ -865,7 +713,7 @@
   {
     "context": "GitPanel && ChangesList",
     "bindings": {
-      "up": "menu::SelectPrevious",
+      "up": "menu::SelectPrev",
       "down": "menu::SelectNext",
       "enter": "menu::Confirm",
       "space": "git::ToggleStaged",
@@ -885,12 +733,6 @@
       "ctrl-enter": "git::Commit"
     }
   },
-  {
-    "context": "GitDiff > Editor",
-    "bindings": {
-      "ctrl-enter": "git::Commit"
-    }
-  },
   {
     "context": "GitPanel > Editor",
     "bindings": {
@@ -932,12 +774,7 @@
     "context": "Picker > Editor",
     "bindings": {
       "tab": "picker::ConfirmCompletion",
-      "alt-enter": [
-        "picker::ConfirmInput",
-        {
-          "secondary": false
-        }
-      ]
+      "alt-enter": ["picker::ConfirmInput", { "secondary": false }]
     }
   },
   {
@@ -949,7 +786,7 @@
   {
     "context": "FileFinder || (FileFinder > Picker > Editor) || (FileFinder > Picker > menu)",
     "bindings": {
-      "ctrl-shift-p": "file_finder::SelectPrevious",
+      "ctrl-shift-p": "file_finder::SelectPrev",
       "ctrl-j": "pane::SplitDown",
       "ctrl-k": "pane::SplitUp",
       "ctrl-h": "pane::SplitLeft",
@@ -959,8 +796,8 @@
   {
     "context": "TabSwitcher",
     "bindings": {
-      "ctrl-shift-tab": "menu::SelectPrevious",
-      "ctrl-up": "menu::SelectPrevious",
+      "ctrl-shift-tab": "menu::SelectPrev",
+      "ctrl-up": "menu::SelectPrev",
       "ctrl-down": "menu::SelectNext",
       "ctrl-backspace": "tab_switcher::CloseSelectedItem"
     }

assets/keymaps/default-macos.json

@@ -14,9 +14,9 @@
       "tab": "menu::SelectNext",
       "ctrl-n": "menu::SelectNext",
       "down": "menu::SelectNext",
-      "shift-tab": "menu::SelectPrevious",
-      "ctrl-p": "menu::SelectPrevious",
-      "up": "menu::SelectPrevious",
+      "shift-tab": "menu::SelectPrev",
+      "ctrl-p": "menu::SelectPrev",
+      "up": "menu::SelectPrev",
       "enter": "menu::Confirm",
       "ctrl-enter": "menu::SecondaryConfirm",
       "cmd-enter": "menu::SecondaryConfirm",
@@ -28,30 +28,10 @@
       "cmd-shift-w": "workspace::CloseWindow",
       "shift-escape": "workspace::ToggleZoom",
       "cmd-o": "workspace::Open",
-      "cmd-=": [
-        "zed::IncreaseBufferFontSize",
-        {
-          "persist": false
-        }
-      ],
-      "cmd-+": [
-        "zed::IncreaseBufferFontSize",
-        {
-          "persist": false
-        }
-      ],
-      "cmd--": [
-        "zed::DecreaseBufferFontSize",
-        {
-          "persist": false
-        }
-      ],
-      "cmd-0": [
-        "zed::ResetBufferFontSize",
-        {
-          "persist": false
-        }
-      ],
+      "cmd-=": ["zed::IncreaseBufferFontSize", { "persist": false }],
+      "cmd-+": ["zed::IncreaseBufferFontSize", { "persist": false }],
+      "cmd--": ["zed::DecreaseBufferFontSize", { "persist": false }],
+      "cmd-0": ["zed::ResetBufferFontSize", { "persist": false }],
       "cmd-,": "zed::OpenSettings",
       "cmd-q": "zed::Quit",
       "cmd-h": "zed::Hide",
@@ -74,7 +54,7 @@
       "ctrl-d": "editor::Delete",
       "delete": "editor::Delete",
       "tab": "editor::Tab",
-      "shift-tab": "editor::Backtab",
+      "shift-tab": "editor::TabPrev",
       "ctrl-t": "editor::Transpose",
       "ctrl-k": "editor::KillRingCut",
       "ctrl-y": "editor::KillRingYank",
@@ -111,45 +91,12 @@
       "ctrl-l": "editor::ScrollCursorCenter",
       "alt-left": "editor::MoveToPreviousWordStart",
       "alt-right": "editor::MoveToNextWordEnd",
-      "cmd-left": [
-        "editor::MoveToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true,
-          "stop_at_indent": true
-        }
-      ],
-      "ctrl-a": [
-        "editor::MoveToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": false,
-          "stop_at_indent": true
-        }
-      ],
-      "home": [
-        "editor::MoveToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true,
-          "stop_at_indent": true
-        }
-      ],
-      "cmd-right": [
-        "editor::MoveToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-e": [
-        "editor::MoveToEndOfLine",
-        {
-          "stop_at_soft_wraps": false
-        }
-      ],
-      "end": [
-        "editor::MoveToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
+      "cmd-left": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      "ctrl-a": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
+      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      "cmd-right": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": true }],
+      "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
+      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": true }],
       "cmd-up": "editor::MoveToStartOfExcerpt",
       "cmd-down": "editor::MoveToEndOfExcerpt",
       "cmd-home": "editor::MoveToBeginning", // Typed via `cmd-fn-left`
@@ -171,57 +118,14 @@
       "cmd-a": "editor::SelectAll",
       "cmd-l": "editor::SelectLine",
       "cmd-shift-i": "editor::Format",
-      "cmd-shift-left": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true,
-          "stop_at_indent": true
-        }
-      ],
-      "shift-home": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true,
-          "stop_at_indent": true
-        }
-      ],
-      "ctrl-shift-a": [
-        "editor::SelectToBeginningOfLine",
-        {
-          "stop_at_soft_wraps": true,
-          "stop_at_indent": true
-        }
-      ],
-      "cmd-shift-right": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "shift-end": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-shift-e": [
-        "editor::SelectToEndOfLine",
-        {
-          "stop_at_soft_wraps": true
-        }
-      ],
-      "ctrl-v": [
-        "editor::MovePageDown",
-        {
-          "center_cursor": true
-        }
-      ],
-      "ctrl-shift-v": [
-        "editor::MovePageUp",
-        {
-          "center_cursor": true
-        }
-      ],
+      "cmd-shift-left": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true }],
+      "shift-home": ["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 }],
+      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
+      "ctrl-v": ["editor::MovePageDown", { "center_cursor": true }],
+      "ctrl-shift-v": ["editor::MovePageUp", { "center_cursor": true }],
       "ctrl-cmd-space": "editor::ShowCharacterPalette",
       "cmd-;": "editor::ToggleLineNumbers",
       "cmd-alt-z": "git::Restore",
@@ -248,18 +152,8 @@
       "cmd-k z": "editor::ToggleSoftWrap",
       "cmd-f": "buffer_search::Deploy",
       "cmd-alt-f": "buffer_search::DeployReplace",
-      "cmd-alt-l": [
-        "buffer_search::Deploy",
-        {
-          "selection_search_enabled": true
-        }
-      ],
-      "cmd-e": [
-        "buffer_search::Deploy",
-        {
-          "focus": false
-        }
-      ],
+      "cmd-alt-l": ["buffer_search::Deploy", { "selection_search_enabled": true }],
+      "cmd-e": ["buffer_search::Deploy", { "focus": false }],
       "cmd->": "assistant::QuoteSelection",
       "cmd-<": "assistant::InsertIntoEditor",
       "cmd-alt-e": "editor::SelectEnclosingSymbol",
@@ -313,7 +207,7 @@
       "cmd-k c": "assistant::CopyCode",
       "cmd-shift-e": "project_panel::ToggleFocus",
       "cmd-g": "search::SelectNextMatch",
-      "cmd-shift-g": "search::SelectPreviousMatch",
+      "cmd-shift-g": "search::SelectPrevMatch",
       "cmd-alt-/": "assistant::ToggleModelSelector",
       "cmd-k h": "assistant::DeployHistory",
       "cmd-k l": "assistant::DeployPromptLibrary",
@@ -391,7 +285,7 @@
       "escape": "buffer_search::Dismiss",
       "tab": "buffer_search::FocusEditor",
       "enter": "search::SelectNextMatch",
-      "shift-enter": "search::SelectPreviousMatch",
+      "shift-enter": "search::SelectPrevMatch",
       "alt-enter": "search::SelectAllMatches",
       "cmd-f": "search::FocusSearch",
       "cmd-alt-f": "search::ToggleReplace",
@@ -458,52 +352,22 @@
     "context": "Pane",
     "use_key_equivalents": true,
     "bindings": {
-      "alt-cmd-left": "pane::ActivatePreviousItem",
-      "cmd-{": "pane::ActivatePreviousItem",
+      "alt-cmd-left": "pane::ActivatePrevItem",
+      "cmd-{": "pane::ActivatePrevItem",
       "alt-cmd-right": "pane::ActivateNextItem",
       "cmd-}": "pane::ActivateNextItem",
       "ctrl-shift-pageup": "pane::SwapItemLeft",
       "ctrl-shift-pagedown": "pane::SwapItemRight",
-      "cmd-w": [
-        "pane::CloseActiveItem",
-        {
-          "close_pinned": false
-        }
-      ],
-      "alt-cmd-t": [
-        "pane::CloseInactiveItems",
-        {
-          "close_pinned": false
-        }
-      ],
+      "cmd-w": ["pane::CloseActiveItem", { "close_pinned": false }],
+      "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
       "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
-      "cmd-k e": [
-        "pane::CloseItemsToTheLeft",
-        {
-          "close_pinned": false
-        }
-      ],
-      "cmd-k t": [
-        "pane::CloseItemsToTheRight",
-        {
-          "close_pinned": false
-        }
-      ],
-      "cmd-k u": [
-        "pane::CloseCleanItems",
-        {
-          "close_pinned": false
-        }
-      ],
-      "cmd-k cmd-w": [
-        "pane::CloseAllItems",
-        {
-          "close_pinned": false
-        }
-      ],
+      "cmd-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
+      "cmd-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
+      "cmd-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
+      "cmd-k cmd-w": ["pane::CloseAllItems", { "close_pinned": false }],
       "cmd-f": "project_search::ToggleFocus",
       "cmd-g": "search::SelectNextMatch",
-      "cmd-shift-g": "search::SelectPreviousMatch",
+      "cmd-shift-g": "search::SelectPrevMatch",
       "cmd-shift-h": "search::ToggleReplace",
       "cmd-alt-l": "search::ToggleSelection",
       "alt-enter": "search::SelectAllMatches",
@@ -532,43 +396,18 @@
       "alt-shift-down": "editor::DuplicateLineDown",
       "ctrl-shift-right": "editor::SelectLargerSyntaxNode", // Expand Selection
       "ctrl-shift-left": "editor::SelectSmallerSyntaxNode", // Shrink Selection
-      "cmd-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ], // Add selection to Next Find Match
+      "cmd-d": ["editor::SelectNext", { "replace_newest": false }], // Add selection to Next Find Match
       "cmd-shift-l": "editor::SelectAllMatches", // Select all occurrences of current selection
       "cmd-f2": "editor::SelectAllMatches", // Select all occurrences of current word
-      "ctrl-cmd-d": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": false
-        }
-      ],
-      "cmd-k cmd-d": [
-        "editor::SelectNext",
-        {
-          "replace_newest": true
-        }
-      ],
-      "cmd-k ctrl-cmd-d": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": true
-        }
-      ],
+      "ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": false }],
+      "cmd-k cmd-d": ["editor::SelectNext", { "replace_newest": true }],
+      "cmd-k ctrl-cmd-d": ["editor::SelectPrevious", { "replace_newest": true }],
       "cmd-k cmd-i": "editor::Hover",
-      "cmd-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": false
-        }
-      ],
+      "cmd-/": ["editor::ToggleComments", { "advance_downwards": false }],
       "cmd-u": "editor::UndoSelection",
       "cmd-shift-u": "editor::RedoSelection",
       "f8": "editor::GoToDiagnostic",
-      "shift-f8": "editor::GoToPreviousDiagnostic",
+      "shift-f8": "editor::GoToPrevDiagnostic",
       "f2": "editor::Rename",
       "f12": "editor::GoToDefinition",
       "alt-f12": "editor::GoToDefinitionSplit",
@@ -583,42 +422,15 @@
       "cmd-k cmd-l": "editor::ToggleFold",
       "cmd-k cmd-[": "editor::FoldRecursive",
       "cmd-k cmd-]": "editor::UnfoldRecursive",
-      "cmd-k cmd-1": [
-        "editor::FoldAtLevel",
-        1
-      ],
-      "cmd-k cmd-2": [
-        "editor::FoldAtLevel",
-        2
-      ],
-      "cmd-k cmd-3": [
-        "editor::FoldAtLevel",
-        3
-      ],
-      "cmd-k cmd-4": [
-        "editor::FoldAtLevel",
-        4
-      ],
-      "cmd-k cmd-5": [
-        "editor::FoldAtLevel",
-        5
-      ],
-      "cmd-k cmd-6": [
-        "editor::FoldAtLevel",
-        6
-      ],
-      "cmd-k cmd-7": [
-        "editor::FoldAtLevel",
-        7
-      ],
-      "cmd-k cmd-8": [
-        "editor::FoldAtLevel",
-        8
-      ],
-      "cmd-k cmd-9": [
-        "editor::FoldAtLevel",
-        9
-      ],
+      "cmd-k cmd-1": ["editor::FoldAtLevel", 1],
+      "cmd-k cmd-2": ["editor::FoldAtLevel", 2],
+      "cmd-k cmd-3": ["editor::FoldAtLevel", 3],
+      "cmd-k cmd-4": ["editor::FoldAtLevel", 4],
+      "cmd-k cmd-5": ["editor::FoldAtLevel", 5],
+      "cmd-k cmd-6": ["editor::FoldAtLevel", 6],
+      "cmd-k cmd-7": ["editor::FoldAtLevel", 7],
+      "cmd-k cmd-8": ["editor::FoldAtLevel", 8],
+      "cmd-k cmd-9": ["editor::FoldAtLevel", 9],
       "cmd-k cmd-0": "editor::FoldAll",
       "cmd-k cmd-j": "editor::UnfoldAll",
       // Using `ctrl-space` in Zed requires disabling the macOS global shortcut.
@@ -645,42 +457,15 @@
     "context": "Pane",
     "use_key_equivalents": true,
     "bindings": {
-      "ctrl-1": [
-        "pane::ActivateItem",
-        0
-      ],
-      "ctrl-2": [
-        "pane::ActivateItem",
-        1
-      ],
-      "ctrl-3": [
-        "pane::ActivateItem",
-        2
-      ],
-      "ctrl-4": [
-        "pane::ActivateItem",
-        3
-      ],
-      "ctrl-5": [
-        "pane::ActivateItem",
-        4
-      ],
-      "ctrl-6": [
-        "pane::ActivateItem",
-        5
-      ],
-      "ctrl-7": [
-        "pane::ActivateItem",
-        6
-      ],
-      "ctrl-8": [
-        "pane::ActivateItem",
-        7
-      ],
-      "ctrl-9": [
-        "pane::ActivateItem",
-        8
-      ],
+      "ctrl-1": ["pane::ActivateItem", 0],
+      "ctrl-2": ["pane::ActivateItem", 1],
+      "ctrl-3": ["pane::ActivateItem", 2],
+      "ctrl-4": ["pane::ActivateItem", 3],
+      "ctrl-5": ["pane::ActivateItem", 4],
+      "ctrl-6": ["pane::ActivateItem", 5],
+      "ctrl-7": ["pane::ActivateItem", 6],
+      "ctrl-8": ["pane::ActivateItem", 7],
+      "ctrl-9": ["pane::ActivateItem", 8],
       "ctrl-0": "pane::ActivateLastItem",
       "ctrl--": "pane::GoBack",
       "ctrl-_": "pane::GoForward",
@@ -702,65 +487,28 @@
       "cmd-shift-s": "workspace::SaveAs",
       "cmd-shift-n": "workspace::NewWindow",
       "ctrl-`": "terminal_panel::ToggleFocus",
-      "cmd-1": [
-        "workspace::ActivatePane",
-        0
-      ],
-      "cmd-2": [
-        "workspace::ActivatePane",
-        1
-      ],
-      "cmd-3": [
-        "workspace::ActivatePane",
-        2
-      ],
-      "cmd-4": [
-        "workspace::ActivatePane",
-        3
-      ],
-      "cmd-5": [
-        "workspace::ActivatePane",
-        4
-      ],
-      "cmd-6": [
-        "workspace::ActivatePane",
-        5
-      ],
-      "cmd-7": [
-        "workspace::ActivatePane",
-        6
-      ],
-      "cmd-8": [
-        "workspace::ActivatePane",
-        7
-      ],
-      "cmd-9": [
-        "workspace::ActivatePane",
-        8
-      ],
+      "cmd-1": ["workspace::ActivatePane", 0],
+      "cmd-2": ["workspace::ActivatePane", 1],
+      "cmd-3": ["workspace::ActivatePane", 2],
+      "cmd-4": ["workspace::ActivatePane", 3],
+      "cmd-5": ["workspace::ActivatePane", 4],
+      "cmd-6": ["workspace::ActivatePane", 5],
+      "cmd-7": ["workspace::ActivatePane", 6],
+      "cmd-8": ["workspace::ActivatePane", 7],
+      "cmd-9": ["workspace::ActivatePane", 8],
       "cmd-b": "workspace::ToggleLeftDock",
       "cmd-r": "workspace::ToggleRightDock",
       "cmd-j": "workspace::ToggleBottomDock",
       "alt-cmd-y": "workspace::CloseAllDocks",
       "cmd-shift-f": "pane::DeploySearch",
-      "cmd-shift-h": [
-        "pane::DeploySearch",
-        {
-          "replace_enabled": true
-        }
-      ],
+      "cmd-shift-h": ["pane::DeploySearch", { "replace_enabled": true }],
       "cmd-shift-t": "pane::ReopenClosedItem",
       "cmd-k cmd-s": "zed::OpenKeymap",
       "cmd-k cmd-t": "theme_selector::Toggle",
       "cmd-t": "project_symbols::Toggle",
       "cmd-p": "file_finder::Toggle",
       "ctrl-tab": "tab_switcher::Toggle",
-      "ctrl-shift-tab": [
-        "tab_switcher::Toggle",
-        {
-          "select_last": true
-        }
-      ],
+      "ctrl-shift-tab": ["tab_switcher::Toggle", { "select_last": true }],
       "cmd-shift-p": "command_palette::Toggle",
       "cmd-shift-m": "diagnostics::Deploy",
       "cmd-shift-e": "project_panel::ToggleFocus",
@@ -788,12 +536,7 @@
       "cmd-n": "workspace::NewFile",
       "cmd-shift-r": "task::Spawn",
       "cmd-alt-r": "task::Rerun",
-      "ctrl-alt-shift-r": [
-        "task::Spawn",
-        {
-          "reveal_target": "center"
-        }
-      ]
+      "ctrl-alt-shift-r": ["task::Spawn", { "reveal_target": "center" }]
       // also possible to spawn tasks by name:
       // "foo-bar": ["task::Spawn", { "task_name": "MyTask", "reveal_target": "dock" }]
     }
@@ -870,8 +613,8 @@
     "context": "Editor && (showing_code_actions || showing_completions)",
     "use_key_equivalents": true,
     "bindings": {
-      "up": "editor::ContextMenuPrevious",
-      "ctrl-p": "editor::ContextMenuPrevious",
+      "up": "editor::ContextMenuPrev",
+      "ctrl-p": "editor::ContextMenuPrev",
       "down": "editor::ContextMenuNext",
       "ctrl-n": "editor::ContextMenuNext",
       "pageup": "editor::ContextMenuFirst",
@@ -897,7 +640,7 @@
       "cmd-alt-enter": "editor::OpenExcerptsSplit",
       "cmd-shift-e": "pane::RevealInProjectPanel",
       "cmd-f8": "editor::GoToHunk",
-      "cmd-shift-f8": "editor::GoToPreviousHunk",
+      "cmd-shift-f8": "editor::GoToPrevHunk",
       "ctrl-enter": "assistant::InlineAssist",
       "ctrl-:": "editor::ToggleInlayHints"
     }
@@ -940,7 +683,7 @@
       "alt-cmd-r": "outline_panel::RevealInFileManager",
       "space": "outline_panel::Open",
       "shift-down": "menu::SelectNext",
-      "shift-up": "menu::SelectPrevious",
+      "shift-up": "menu::SelectPrev",
       "alt-enter": "editor::OpenExcerpts",
       "cmd-alt-enter": "editor::OpenExcerptsSplit"
     }
@@ -961,41 +704,16 @@
       "alt-cmd-shift-c": "workspace::CopyRelativePath",
       "enter": "project_panel::Rename",
       "f2": "project_panel::Rename",
-      "backspace": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "delete": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "cmd-backspace": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": true
-        }
-      ],
-      "cmd-delete": [
-        "project_panel::Delete",
-        {
-          "skip_prompt": false
-        }
-      ],
+      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
+      "delete": ["project_panel::Trash", { "skip_prompt": false }],
+      "cmd-backspace": ["project_panel::Trash", { "skip_prompt": true }],
+      "cmd-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "alt-cmd-r": "project_panel::RevealInFileManager",
       "ctrl-shift-enter": "project_panel::OpenWithSystem",
-      "cmd-alt-backspace": [
-        "project_panel::Delete",
-        {
-          "skip_prompt": false
-        }
-      ],
+      "cmd-alt-backspace": ["project_panel::Delete", { "skip_prompt": false }],
       "cmd-shift-f": "project_panel::NewSearchInDirectory",
       "shift-down": "menu::SelectNext",
-      "shift-up": "menu::SelectPrevious",
+      "shift-up": "menu::SelectPrev",
       "escape": "menu::Cancel"
     }
   },
@@ -1006,11 +724,19 @@
       "space": "project_panel::Open"
     }
   },
+  {
+    "context": "VariableList",
+    "use_key_equivalents": true,
+    "bindings": {
+      "left": "variable_list::CollapseSelectedEntry",
+      "right": "variable_list::ExpandSelectedEntry"
+    }
+  },
   {
     "context": "GitPanel && ChangesList",
     "use_key_equivalents": true,
     "bindings": {
-      "up": "menu::SelectPrevious",
+      "up": "menu::SelectPrev",
       "down": "menu::SelectNext",
       "cmd-up": "menu::SelectFirst",
       "cmd-down": "menu::SelectLast",
@@ -1021,15 +747,7 @@
       "alt-down": "git_panel::FocusEditor",
       "tab": "git_panel::FocusEditor",
       "shift-tab": "git_panel::FocusEditor",
-      "escape": "git_panel::ToggleFocus",
-      "cmd-enter": "git::Commit"
-    }
-  },
-  {
-    "context": "GitDiff > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "cmd-enter": "git::Commit"
+      "escape": "git_panel::ToggleFocus"
     }
   },
   {
@@ -1078,18 +796,8 @@
     "use_key_equivalents": true,
     "bindings": {
       "tab": "picker::ConfirmCompletion",
-      "alt-enter": [
-        "picker::ConfirmInput",
-        {
-          "secondary": false
-        }
-      ],
-      "cmd-alt-enter": [
-        "picker::ConfirmInput",
-        {
-          "secondary": true
-        }
-      ]
+      "alt-enter": ["picker::ConfirmInput", { "secondary": false }],
+      "cmd-alt-enter": ["picker::ConfirmInput", { "secondary": true }]
     }
   },
   {
@@ -1103,7 +811,7 @@
     "context": "FileFinder || (FileFinder > Picker > Editor) || (FileFinder > Picker > menu)",
     "use_key_equivalents": true,
     "bindings": {
-      "cmd-shift-p": "file_finder::SelectPrevious",
+      "cmd-shift-p": "file_finder::SelectPrev",
       "cmd-j": "pane::SplitDown",
       "cmd-k": "pane::SplitUp",
       "cmd-h": "pane::SplitLeft",
@@ -1114,8 +822,8 @@
     "context": "TabSwitcher",
     "use_key_equivalents": true,
     "bindings": {
-      "ctrl-shift-tab": "menu::SelectPrevious",
-      "ctrl-up": "menu::SelectPrevious",
+      "ctrl-shift-tab": "menu::SelectPrev",
+      "ctrl-up": "menu::SelectPrev",
       "ctrl-down": "menu::SelectNext",
       "ctrl-backspace": "tab_switcher::CloseSelectedItem"
     }
@@ -1131,67 +839,24 @@
       "cmd-k": "terminal::Clear",
       "cmd-n": "workspace::NewTerminal",
       "ctrl-enter": "assistant::InlineAssist",
-      "ctrl-_": null, // emacs undo
       // Some nice conveniences
-      "cmd-backspace": [
-        "terminal::SendText",
-        "\u0015"
-      ],
-      "cmd-right": [
-        "terminal::SendText",
-        "\u0005"
-      ],
-      "cmd-left": [
-        "terminal::SendText",
-        "\u0001"
-      ],
+      "cmd-backspace": ["terminal::SendText", "\u0015"],
+      "cmd-right": ["terminal::SendText", "\u0005"],
+      "cmd-left": ["terminal::SendText", "\u0001"],
       // Terminal.app compatibility
-      "alt-left": [
-        "terminal::SendText",
-        "\u001bb"
-      ],
-      "alt-right": [
-        "terminal::SendText",
-        "\u001bf"
-      ],
-      "alt-b": [
-        "terminal::SendText",
-        "\u001bb"
-      ],
-      "alt-f": [
-        "terminal::SendText",
-        "\u001bf"
-      ],
+      "alt-left": ["terminal::SendText", "\u001bb"],
+      "alt-right": ["terminal::SendText", "\u001bf"],
+      "alt-b": ["terminal::SendText", "\u001bb"],
+      "alt-f": ["terminal::SendText", "\u001bf"],
       // There are conflicting bindings for these keys in the global context.
       // these bindings override them, remove at your own risk:
-      "up": [
-        "terminal::SendKeystroke",
-        "up"
-      ],
-      "pageup": [
-        "terminal::SendKeystroke",
-        "pageup"
-      ],
-      "down": [
-        "terminal::SendKeystroke",
-        "down"
-      ],
-      "pagedown": [
-        "terminal::SendKeystroke",
-        "pagedown"
-      ],
-      "escape": [
-        "terminal::SendKeystroke",
-        "escape"
-      ],
-      "enter": [
-        "terminal::SendKeystroke",
-        "enter"
-      ],
-      "ctrl-c": [
-        "terminal::SendKeystroke",
-        "ctrl-c"
-      ],
+      "up": ["terminal::SendKeystroke", "up"],
+      "pageup": ["terminal::SendKeystroke", "pageup"],
+      "down": ["terminal::SendKeystroke", "down"],
+      "pagedown": ["terminal::SendKeystroke", "pagedown"],
+      "escape": ["terminal::SendKeystroke", "escape"],
+      "enter": ["terminal::SendKeystroke", "enter"],
+      "ctrl-c": ["terminal::SendKeystroke", "ctrl-c"],
       "shift-pageup": "terminal::ScrollPageUp",
       "cmd-up": "terminal::ScrollPageUp",
       "shift-pagedown": "terminal::ScrollPageDown",
@@ -1236,4 +901,4 @@
       "escape": "menu::Cancel"
     }
   }
-]
+]

assets/keymaps/linux/atom.json

@@ -39,7 +39,7 @@
     "context": "BufferSearchBar",
     "bindings": {
       "ctrl-f3": "search::SelectNextMatch", // find-and-replace:find-next-selected
-      "ctrl-shift-f3": "search::SelectPreviousMatch" // find-and-replace:find-previous-selected
+      "ctrl-shift-f3": "search::SelectPrevMatch" // find-and-replace:find-previous-selected
     }
   },
   {

assets/keymaps/linux/emacs.json

@@ -28,7 +28,6 @@
       "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
       "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": false }], // move-beginning-of-line
       "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
-      "alt-m": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false, "stop_at_indent": true }], // back-to-indentation
       "alt-f": "editor::MoveToNextSubwordEnd", // forward-word
       "alt-b": "editor::MoveToPreviousSubwordStart", // backward-word
       "alt-u": "editor::ConvertToUpperCase", // upcase-word
@@ -122,7 +121,7 @@
     "context": "BufferSearchBar > Editor",
     "bindings": {
       "ctrl-s": "search::SelectNextMatch",
-      "ctrl-r": "search::SelectPreviousMatch",
+      "ctrl-r": "search::SelectPrevMatch",
       "ctrl-g": "buffer_search::Dismiss"
     }
   },

assets/keymaps/linux/jetbrains.json

@@ -2,25 +2,15 @@
   {
     "bindings": {
       "ctrl-alt-s": "zed::OpenSettings",
-      "ctrl-{": "pane::ActivatePreviousItem",
+      "ctrl-{": "pane::ActivatePrevItem",
       "ctrl-}": "pane::ActivateNextItem"
     }
   },
   {
     "context": "Editor",
     "bindings": {
-      "ctrl->": [
-        "zed::IncreaseBufferFontSize",
-        {
-          "persist": true
-        }
-      ],
-      "ctrl-<": [
-        "zed::DecreaseBufferFontSize",
-        {
-          "persist": true
-        }
-      ],
+      "ctrl->": ["zed::IncreaseBufferFontSize", { "persist": true }],
+      "ctrl-<": ["zed::DecreaseBufferFontSize", { "persist": true }],
       "ctrl-shift-j": "editor::JoinLines",
       "ctrl-d": "editor::DuplicateSelection",
       "ctrl-y": "editor::DeleteLine",
@@ -33,24 +23,9 @@
       // "ctrl--": "editor::Fold", // TODO: `ctrl-numpad--` (numpad not implemented)
       // "ctrl-+": "editor::UnfoldLines", // TODO: `ctrl-numpad+` (numpad not implemented)
       "alt-shift-g": "editor::SplitSelectionIntoLines",
-      "alt-j": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ],
-      "alt-shift-j": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": false
-        }
-      ],
-      "ctrl-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": true
-        }
-      ],
+      "alt-j": ["editor::SelectNext", { "replace_newest": false }],
+      "alt-shift-j": ["editor::SelectPrevious", { "replace_newest": false }],
+      "ctrl-/": ["editor::ToggleComments", { "advance_downwards": true }],
       "ctrl-w": "editor::SelectLargerSyntaxNode",
       "ctrl-shift-w": "editor::SelectSmallerSyntaxNode",
       "shift-alt-up": "editor::MoveLineUp",
@@ -66,9 +41,9 @@
       "ctrl-shift-b": "editor::GoToTypeDefinition",
       "ctrl-alt-shift-b": "editor::GoToTypeDefinitionSplit",
       "f2": "editor::GoToDiagnostic",
-      "shift-f2": "editor::GoToPreviousDiagnostic",
+      "shift-f2": "editor::GoToPrevDiagnostic",
       "ctrl-alt-shift-down": "editor::GoToHunk",
-      "ctrl-alt-shift-up": "editor::GoToPreviousHunk",
+      "ctrl-alt-shift-up": "editor::GoToPrevHunk",
       "ctrl-alt-z": "git::Restore",
       "ctrl-home": "editor::MoveToBeginning",
       "ctrl-end": "editor::MoveToEnd",
@@ -109,25 +84,10 @@
     "context": "ProjectPanel",
     "bindings": {
       "enter": "project_panel::Open",
-      "backspace": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "delete": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "shift-delete": [
-        "project_panel::Delete",
-        {
-          "skip_prompt": false
-        }
-      ],
+      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
+      "delete": ["project_panel::Trash", { "skip_prompt": false }],
+      "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "shift-f6": "project_panel::Rename"
     }
   }
-]
+]

assets/keymaps/linux/sublime_text.json

@@ -1,101 +1,28 @@
 [
   {
     "bindings": {
-      "ctrl-{": "pane::ActivatePreviousItem",
+      "ctrl-{": "pane::ActivatePrevItem",
       "ctrl-}": "pane::ActivateNextItem",
-      "ctrl-pageup": "pane::ActivatePreviousItem",
+      "ctrl-pageup": "pane::ActivatePrevItem",
       "ctrl-pagedown": "pane::ActivateNextItem",
-      "ctrl-1": [
-        "workspace::ActivatePane",
-        0
-      ],
-      "ctrl-2": [
-        "workspace::ActivatePane",
-        1
-      ],
-      "ctrl-3": [
-        "workspace::ActivatePane",
-        2
-      ],
-      "ctrl-4": [
-        "workspace::ActivatePane",
-        3
-      ],
-      "ctrl-5": [
-        "workspace::ActivatePane",
-        4
-      ],
-      "ctrl-6": [
-        "workspace::ActivatePane",
-        5
-      ],
-      "ctrl-7": [
-        "workspace::ActivatePane",
-        6
-      ],
-      "ctrl-8": [
-        "workspace::ActivatePane",
-        7
-      ],
-      "ctrl-9": [
-        "workspace::ActivatePane",
-        8
-      ],
-      "ctrl-!": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 0,
-          "focus": true
-        }
-      ],
-      "ctrl-@": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 1
-        }
-      ],
-      "ctrl-#": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 2
-        }
-      ],
-      "ctrl-$": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 3
-        }
-      ],
-      "ctrl-%": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 4
-        }
-      ],
-      "ctrl-^": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 5
-        }
-      ],
-      "ctrl-&": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 6
-        }
-      ],
-      "ctrl-*": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 7
-        }
-      ],
-      "ctrl-(": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 8
-        }
-      ]
+      "ctrl-1": ["workspace::ActivatePane", 0],
+      "ctrl-2": ["workspace::ActivatePane", 1],
+      "ctrl-3": ["workspace::ActivatePane", 2],
+      "ctrl-4": ["workspace::ActivatePane", 3],
+      "ctrl-5": ["workspace::ActivatePane", 4],
+      "ctrl-6": ["workspace::ActivatePane", 5],
+      "ctrl-7": ["workspace::ActivatePane", 6],
+      "ctrl-8": ["workspace::ActivatePane", 7],
+      "ctrl-9": ["workspace::ActivatePane", 8],
+      "ctrl-!": ["workspace::MoveItemToPane", { "destination": 0, "focus": true }],
+      "ctrl-@": ["workspace::MoveItemToPane", { "destination": 1 }],
+      "ctrl-#": ["workspace::MoveItemToPane", { "destination": 2 }],
+      "ctrl-$": ["workspace::MoveItemToPane", { "destination": 3 }],
+      "ctrl-%": ["workspace::MoveItemToPane", { "destination": 4 }],
+      "ctrl-^": ["workspace::MoveItemToPane", { "destination": 5 }],
+      "ctrl-&": ["workspace::MoveItemToPane", { "destination": 6 }],
+      "ctrl-*": ["workspace::MoveItemToPane", { "destination": 7 }],
+      "ctrl-(": ["workspace::MoveItemToPane", { "destination": 8 }]
     }
   },
   {
@@ -117,7 +44,7 @@
       "shift-f12": "editor::FindAllReferences",
       "ctrl-shift-f12": "editor::FindAllReferences",
       "ctrl-.": "editor::GoToHunk",
-      "ctrl-,": "editor::GoToPreviousHunk",
+      "ctrl-,": "editor::GoToPrevHunk",
       "ctrl-k ctrl-u": "editor::ConvertToUpperCase",
       "ctrl-k ctrl-l": "editor::ConvertToLowerCase",
       "shift-alt-m": "markdown::OpenPreviewToTheSide",
@@ -135,39 +62,15 @@
     "context": "Pane",
     "bindings": {
       "f4": "search::SelectNextMatch",
-      "shift-f4": "search::SelectPreviousMatch",
-      "alt-1": [
-        "pane::ActivateItem",
-        0
-      ],
-      "alt-2": [
-        "pane::ActivateItem",
-        1
-      ],
-      "alt-3": [
-        "pane::ActivateItem",
-        2
-      ],
-      "alt-4": [
-        "pane::ActivateItem",
-        3
-      ],
-      "alt-5": [
-        "pane::ActivateItem",
-        4
-      ],
-      "alt-6": [
-        "pane::ActivateItem",
-        5
-      ],
-      "alt-7": [
-        "pane::ActivateItem",
-        6
-      ],
-      "alt-8": [
-        "pane::ActivateItem",
-        7
-      ],
+      "shift-f4": "search::SelectPrevMatch",
+      "alt-1": ["pane::ActivateItem", 0],
+      "alt-2": ["pane::ActivateItem", 1],
+      "alt-3": ["pane::ActivateItem", 2],
+      "alt-4": ["pane::ActivateItem", 3],
+      "alt-5": ["pane::ActivateItem", 4],
+      "alt-6": ["pane::ActivateItem", 5],
+      "alt-7": ["pane::ActivateItem", 6],
+      "alt-8": ["pane::ActivateItem", 7],
       "alt-9": "pane::ActivateLastItem"
     }
   },
@@ -179,4 +82,4 @@
       "shift-ctrl-r": "project_symbols::Toggle"
     }
   }
-]
+]

assets/keymaps/macos/atom.json

@@ -40,7 +40,7 @@
     "context": "BufferSearchBar",
     "bindings": {
       "cmd-f3": "search::SelectNextMatch",
-      "cmd-shift-f3": "search::SelectPreviousMatch"
+      "cmd-shift-f3": "search::SelectPrevMatch"
     }
   },
   {

assets/keymaps/macos/emacs.json

@@ -28,7 +28,6 @@
       "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
       "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": false }], // move-beginning-of-line
       "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
-      "alt-m": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false, "stop_at_indent": true }], // back-to-indentation
       "alt-f": "editor::MoveToNextSubwordEnd", // forward-word
       "alt-b": "editor::MoveToPreviousSubwordStart", // backward-word
       "alt-u": "editor::ConvertToUpperCase", // upcase-word
@@ -122,7 +121,7 @@
     "context": "BufferSearchBar > Editor",
     "bindings": {
       "ctrl-s": "search::SelectNextMatch",
-      "ctrl-r": "search::SelectPreviousMatch",
+      "ctrl-r": "search::SelectPrevMatch",
       "ctrl-g": "buffer_search::Dismiss"
     }
   },

assets/keymaps/macos/jetbrains.json

@@ -1,25 +1,15 @@
 [
   {
     "bindings": {
-      "cmd-{": "pane::ActivatePreviousItem",
+      "cmd-{": "pane::ActivatePrevItem",
       "cmd-}": "pane::ActivateNextItem"
     }
   },
   {
     "context": "Editor",
     "bindings": {
-      "ctrl->": [
-        "zed::IncreaseBufferFontSize",
-        {
-          "persist": true
-        }
-      ],
-      "ctrl-<": [
-        "zed::DecreaseBufferFontSize",
-        {
-          "persist": true
-        }
-      ],
+      "ctrl->": ["zed::IncreaseBufferFontSize", { "persist": true }],
+      "ctrl-<": ["zed::DecreaseBufferFontSize", { "persist": true }],
       "ctrl-shift-j": "editor::JoinLines",
       "cmd-d": "editor::DuplicateSelection",
       "cmd-backspace": "editor::DeleteLine",
@@ -31,24 +21,9 @@
       "cmd--": "editor::Fold",
       "cmd-+": "editor::UnfoldLines",
       "alt-shift-g": "editor::SplitSelectionIntoLines",
-      "ctrl-g": [
-        "editor::SelectNext",
-        {
-          "replace_newest": false
-        }
-      ],
-      "ctrl-cmd-g": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": false
-        }
-      ],
-      "cmd-/": [
-        "editor::ToggleComments",
-        {
-          "advance_downwards": true
-        }
-      ],
+      "ctrl-g": ["editor::SelectNext", { "replace_newest": false }],
+      "ctrl-cmd-g": ["editor::SelectPrevious", { "replace_newest": false }],
+      "cmd-/": ["editor::ToggleComments", { "advance_downwards": true }],
       "alt-up": "editor::SelectLargerSyntaxNode",
       "alt-down": "editor::SelectSmallerSyntaxNode",
       "shift-alt-up": "editor::MoveLineUp",
@@ -64,9 +39,9 @@
       "cmd-shift-b": "editor::GoToTypeDefinition",
       "cmd-alt-shift-b": "editor::GoToTypeDefinitionSplit",
       "f2": "editor::GoToDiagnostic",
-      "shift-f2": "editor::GoToPreviousDiagnostic",
+      "shift-f2": "editor::GoToPrevDiagnostic",
       "ctrl-alt-shift-down": "editor::GoToHunk",
-      "ctrl-alt-shift-up": "editor::GoToPreviousHunk",
+      "ctrl-alt-shift-up": "editor::GoToPrevHunk",
       "cmd-home": "editor::MoveToBeginning",
       "cmd-end": "editor::MoveToEnd",
       "cmd-shift-home": "editor::SelectToBeginning",
@@ -86,7 +61,7 @@
   {
     "context": "BufferSearchBar > Editor",
     "bindings": {
-      "shift-enter": "search::SelectPreviousMatch"
+      "shift-enter": "search::SelectPrevMatch"
     }
   },
   {
@@ -112,30 +87,10 @@
     "context": "ProjectPanel",
     "bindings": {
       "enter": "project_panel::Open",
-      "cmd-backspace": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "backspace": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "delete": [
-        "project_panel::Trash",
-        {
-          "skip_prompt": false
-        }
-      ],
-      "shift-delete": [
-        "project_panel::Delete",
-        {
-          "skip_prompt": false
-        }
-      ],
+      "cmd-backspace": ["project_panel::Trash", { "skip_prompt": false }],
+      "backspace": ["project_panel::Trash", { "skip_prompt": false }],
+      "delete": ["project_panel::Trash", { "skip_prompt": false }],
+      "shift-delete": ["project_panel::Delete", { "skip_prompt": false }],
       "shift-f6": "project_panel::Rename"
     }
   }

assets/keymaps/macos/sublime_text.json

@@ -1,101 +1,28 @@
 [
   {
     "bindings": {
-      "cmd-{": "pane::ActivatePreviousItem",
+      "cmd-{": "pane::ActivatePrevItem",
       "cmd-}": "pane::ActivateNextItem",
-      "ctrl-pageup": "pane::ActivatePreviousItem",
+      "ctrl-pageup": "pane::ActivatePrevItem",
       "ctrl-pagedown": "pane::ActivateNextItem",
-      "ctrl-1": [
-        "workspace::ActivatePane",
-        0
-      ],
-      "ctrl-2": [
-        "workspace::ActivatePane",
-        1
-      ],
-      "ctrl-3": [
-        "workspace::ActivatePane",
-        2
-      ],
-      "ctrl-4": [
-        "workspace::ActivatePane",
-        3
-      ],
-      "ctrl-5": [
-        "workspace::ActivatePane",
-        4
-      ],
-      "ctrl-6": [
-        "workspace::ActivatePane",
-        5
-      ],
-      "ctrl-7": [
-        "workspace::ActivatePane",
-        6
-      ],
-      "ctrl-8": [
-        "workspace::ActivatePane",
-        7
-      ],
-      "ctrl-9": [
-        "workspace::ActivatePane",
-        8
-      ],
-      "ctrl-!": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 0,
-          "focus": true
-        }
-      ],
-      "ctrl-@": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 1
-        }
-      ],
-      "ctrl-#": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 2
-        }
-      ],
-      "ctrl-$": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 3
-        }
-      ],
-      "ctrl-%": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 4
-        }
-      ],
-      "ctrl-^": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 5
-        }
-      ],
-      "ctrl-&": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 6
-        }
-      ],
-      "ctrl-*": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 7
-        }
-      ],
-      "ctrl-(": [
-        "workspace::MoveItemToPane",
-        {
-          "destination": 8
-        }
-      ]
+      "ctrl-1": ["workspace::ActivatePane", 0],
+      "ctrl-2": ["workspace::ActivatePane", 1],
+      "ctrl-3": ["workspace::ActivatePane", 2],
+      "ctrl-4": ["workspace::ActivatePane", 3],
+      "ctrl-5": ["workspace::ActivatePane", 4],
+      "ctrl-6": ["workspace::ActivatePane", 5],
+      "ctrl-7": ["workspace::ActivatePane", 6],
+      "ctrl-8": ["workspace::ActivatePane", 7],
+      "ctrl-9": ["workspace::ActivatePane", 8],
+      "ctrl-!": ["workspace::MoveItemToPane", { "destination": 0, "focus": true }],
+      "ctrl-@": ["workspace::MoveItemToPane", { "destination": 1 }],
+      "ctrl-#": ["workspace::MoveItemToPane", { "destination": 2 }],
+      "ctrl-$": ["workspace::MoveItemToPane", { "destination": 3 }],
+      "ctrl-%": ["workspace::MoveItemToPane", { "destination": 4 }],
+      "ctrl-^": ["workspace::MoveItemToPane", { "destination": 5 }],
+      "ctrl-&": ["workspace::MoveItemToPane", { "destination": 6 }],
+      "ctrl-*": ["workspace::MoveItemToPane", { "destination": 7 }],
+      "ctrl-(": ["workspace::MoveItemToPane", { "destination": 8 }]
     }
   },
   {
@@ -118,7 +45,7 @@
       "ctrl-alt-cmd-down": "editor::GoToDefinitionSplit",
       "alt-shift-cmd-down": "editor::FindAllReferences",
       "ctrl-.": "editor::GoToHunk",
-      "ctrl-,": "editor::GoToPreviousHunk",
+      "ctrl-,": "editor::GoToPrevHunk",
       "cmd-k cmd-u": "editor::ConvertToUpperCase",
       "cmd-k cmd-l": "editor::ConvertToLowerCase",
       "cmd-shift-j": "editor::JoinLines",
@@ -137,39 +64,15 @@
     "context": "Pane",
     "bindings": {
       "f4": "search::SelectNextMatch",
-      "shift-f4": "search::SelectPreviousMatch",
-      "cmd-1": [
-        "pane::ActivateItem",
-        0
-      ],
-      "cmd-2": [
-        "pane::ActivateItem",
-        1
-      ],
-      "cmd-3": [
-        "pane::ActivateItem",
-        2
-      ],
-      "cmd-4": [
-        "pane::ActivateItem",
-        3
-      ],
-      "cmd-5": [
-        "pane::ActivateItem",
-        4
-      ],
-      "cmd-6": [
-        "pane::ActivateItem",
-        5
-      ],
-      "cmd-7": [
-        "pane::ActivateItem",
-        6
-      ],
-      "cmd-8": [
-        "pane::ActivateItem",
-        7
-      ],
+      "shift-f4": "search::SelectPrevMatch",
+      "cmd-1": ["pane::ActivateItem", 0],
+      "cmd-2": ["pane::ActivateItem", 1],
+      "cmd-3": ["pane::ActivateItem", 2],
+      "cmd-4": ["pane::ActivateItem", 3],
+      "cmd-5": ["pane::ActivateItem", 4],
+      "cmd-6": ["pane::ActivateItem", 5],
+      "cmd-7": ["pane::ActivateItem", 6],
+      "cmd-8": ["pane::ActivateItem", 7],
       "cmd-9": "pane::ActivateLastItem"
     }
   },
@@ -183,4 +86,4 @@
       "ctrl-0": "project_panel::ToggleFocus"
     }
   }
-]
+]

assets/keymaps/macos/textmate.json

@@ -47,7 +47,7 @@
     "context": "BufferSearchBar",
     "bindings": {
       "ctrl-s": "search::SelectNextMatch",
-      "ctrl-shift-s": "search::SelectPreviousMatch"
+      "ctrl-shift-s": "search::SelectPrevMatch"
     }
   },
   {

assets/keymaps/storybook.json

@@ -13,9 +13,9 @@
       "tab": "menu::SelectNext",
       "ctrl-n": "menu::SelectNext",
       "down": "menu::SelectNext",
-      "shift-tab": "menu::SelectPrevious",
-      "ctrl-p": "menu::SelectPrevious",
-      "up": "menu::SelectPrevious",
+      "shift-tab": "menu::SelectPrev",
+      "ctrl-p": "menu::SelectPrev",
+      "up": "menu::SelectPrev",
       "enter": "menu::Confirm",
       "ctrl-enter": "menu::SecondaryConfirm",
       "cmd-enter": "menu::SecondaryConfirm",

assets/keymaps/vim.json

@@ -2,18 +2,8 @@
   {
     "context": "VimControl && !menu",
     "bindings": {
-      "i": [
-        "vim::PushObject",
-        {
-          "around": false
-        }
-      ],
-      "a": [
-        "vim::PushObject",
-        {
-          "around": true
-        }
-      ],
+      "i": ["vim::PushObject", { "around": false }],
+      "a": ["vim::PushObject", { "around": true }],
       "left": "vim::Left",
       "h": "vim::Left",
       "backspace": "vim::Backspace",
@@ -64,104 +54,29 @@
       // "b": "vim::PreviousSubwordStart",
       // "e": "vim::NextSubwordEnd",
       // "g e": "vim::PreviousSubwordEnd",
-      "shift-w": [
-        "vim::NextWordStart",
-        {
-          "ignore_punctuation": true
-        }
-      ],
-      "shift-e": [
-        "vim::NextWordEnd",
-        {
-          "ignore_punctuation": true
-        }
-      ],
-      "shift-b": [
-        "vim::PreviousWordStart",
-        {
-          "ignore_punctuation": true
-        }
-      ],
-      "g shift-e": [
-        "vim::PreviousWordEnd",
-        {
-          "ignore_punctuation": true
-        }
-      ],
+      "shift-w": ["vim::NextWordStart", { "ignore_punctuation": true }],
+      "shift-e": ["vim::NextWordEnd", { "ignore_punctuation": true }],
+      "shift-b": ["vim::PreviousWordStart", { "ignore_punctuation": true }],
+      "g shift-e": ["vim::PreviousWordEnd", { "ignore_punctuation": true }],
       "/": "vim::Search",
       "g /": "pane::DeploySearch",
-      "?": [
-        "vim::Search",
-        {
-          "backwards": true
-        }
-      ],
+      "?": ["vim::Search", { "backwards": true }],
       "*": "vim::MoveToNext",
-      "#": "vim::MoveToPrevious",
+      "#": "vim::MoveToPrev",
       "n": "vim::MoveToNextMatch",
-      "shift-n": "vim::MoveToPreviousMatch",
+      "shift-n": "vim::MoveToPrevMatch",
       "%": "vim::Matching",
-      "] }": [
-        "vim::UnmatchedForward",
-        {
-          "char": "}"
-        }
-      ],
-      "[ {": [
-        "vim::UnmatchedBackward",
-        {
-          "char": "{"
-        }
-      ],
-      "] )": [
-        "vim::UnmatchedForward",
-        {
-          "char": ")"
-        }
-      ],
-      "[ (": [
-        "vim::UnmatchedBackward",
-        {
-          "char": "("
-        }
-      ],
-      "f": [
-        "vim::PushFindForward",
-        {
-          "before": false
-        }
-      ],
-      "t": [
-        "vim::PushFindForward",
-        {
-          "before": true
-        }
-      ],
-      "shift-f": [
-        "vim::PushFindBackward",
-        {
-          "after": false
-        }
-      ],
-      "shift-t": [
-        "vim::PushFindBackward",
-        {
-          "after": true
-        }
-      ],
+      "] }": ["vim::UnmatchedForward", { "char": "}" }],
+      "[ {": ["vim::UnmatchedBackward", { "char": "{" }],
+      "] )": ["vim::UnmatchedForward", { "char": ")" }],
+      "[ (": ["vim::UnmatchedBackward", { "char": "(" }],
+      "f": ["vim::PushFindForward", { "before": false }],
+      "t": ["vim::PushFindForward", { "before": true }],
+      "shift-f": ["vim::PushFindBackward", { "after": false }],
+      "shift-t": ["vim::PushFindBackward", { "after": true }],
       "m": "vim::PushMark",
-      "'": [
-        "vim::PushJump",
-        {
-          "line": true
-        }
-      ],
-      "`": [
-        "vim::PushJump",
-        {
-          "line": false
-        }
-      ],
+      "'": ["vim::PushJump", { "line": true }],
+      "`": ["vim::PushJump", { "line": false }],
       ";": "vim::RepeatFind",
       ",": "vim::RepeatFindReversed",
       "ctrl-o": "pane::GoBack",
@@ -191,7 +106,7 @@
       "g g": "vim::StartOfDocument",
       "g h": "editor::Hover",
       "g t": "pane::ActivateNextItem",
-      "g shift-t": "pane::ActivatePreviousItem",
+      "g shift-t": "pane::ActivatePrevItem",
       "g d": "editor::GoToDefinition",
       "g shift-d": "editor::GoToDeclaration",
       "g y": "editor::GoToTypeDefinition",
@@ -202,93 +117,28 @@
       "g shift-n": "vim::SelectPreviousMatch",
       "g l": "vim::SelectNext",
       "g shift-l": "vim::SelectPrevious",
-      "g >": [
-        "editor::SelectNext",
-        {
-          "replace_newest": true
-        }
-      ],
-      "g <": [
-        "editor::SelectPrevious",
-        {
-          "replace_newest": true
-        }
-      ],
+      "g >": ["editor::SelectNext", { "replace_newest": true }],
+      "g <": ["editor::SelectPrevious", { "replace_newest": true }],
       "g a": "editor::SelectAllMatches",
       "g s": "outline::Toggle",
       "g shift-s": "project_symbols::Toggle",
       "g .": "editor::ToggleCodeActions", // zed specific
       "g shift-a": "editor::FindAllReferences", // zed specific
       "g space": "editor::OpenExcerpts", // zed specific
-      "g *": [
-        "vim::MoveToNext",
-        {
-          "partial_word": true
-        }
-      ],
-      "g #": [
-        "vim::MoveToPrevious",
-        {
-          "partial_word": true
-        }
-      ],
-      "g j": [
-        "vim::Down",
-        {
-          "display_lines": true
-        }
-      ],
-      "g down": [
-        "vim::Down",
-        {
-          "display_lines": true
-        }
-      ],
-      "g k": [
-        "vim::Up",
-        {
-          "display_lines": true
-        }
-      ],
-      "g up": [
-        "vim::Up",
-        {
-          "display_lines": true
-        }
-      ],
-      "g $": [
-        "vim::EndOfLine",
-        {
-          "display_lines": true
-        }
-      ],
-      "g end": [
-        "vim::EndOfLine",
-        {
-          "display_lines": true
-        }
-      ],
-      "g 0": [
-        "vim::StartOfLine",
-        {
-          "display_lines": true
-        }
-      ],
-      "g home": [
-        "vim::StartOfLine",
-        {
-          "display_lines": true
-        }
-      ],
-      "g ^": [
-        "vim::FirstNonWhitespace",
-        {
-          "display_lines": true
-        }
-      ],
+      "g *": ["vim::MoveToNext", { "partial_word": true }],
+      "g #": ["vim::MoveToPrev", { "partial_word": true }],
+      "g j": ["vim::Down", { "display_lines": true }],
+      "g down": ["vim::Down", { "display_lines": true }],
+      "g k": ["vim::Up", { "display_lines": true }],
+      "g up": ["vim::Up", { "display_lines": true }],
+      "g $": ["vim::EndOfLine", { "display_lines": true }],
+      "g end": ["vim::EndOfLine", { "display_lines": true }],
+      "g 0": ["vim::StartOfLine", { "display_lines": true }],
+      "g home": ["vim::StartOfLine", { "display_lines": true }],
+      "g ^": ["vim::FirstNonWhitespace", { "display_lines": true }],
       "g v": "vim::RestoreVisualSelection",
       "g ]": "editor::GoToDiagnostic",
-      "g [": "editor::GoToPreviousDiagnostic",
+      "g [": "editor::GoToPrevDiagnostic",
       "g i": "vim::InsertAtPrevious",
       "g ,": "vim::ChangeListNewer",
       "g ;": "vim::ChangeListOlder",
@@ -299,28 +149,13 @@
       "shift-q": "vim::ReplayLastRecording",
       "@": "vim::PushReplayRegister",
       // z commands
-      "z enter": [
-        "workspace::SendKeystrokes",
-        "z t ^"
-      ],
-      "z -": [
-        "workspace::SendKeystrokes",
-        "z b ^"
-      ],
-      "z ^": [
-        "workspace::SendKeystrokes",
-        "shift-h k z b ^"
-      ],
-      "z +": [
-        "workspace::SendKeystrokes",
-        "shift-l j z t ^"
-      ],
+      "z enter": ["workspace::SendKeystrokes", "z t ^"],
+      "z -": ["workspace::SendKeystrokes", "z b ^"],
+      "z ^": ["workspace::SendKeystrokes", "shift-h k z b ^"],
+      "z +": ["workspace::SendKeystrokes", "shift-l j z t ^"],
       "z t": "editor::ScrollCursorTop",
       "z z": "editor::ScrollCursorCenter",
-      "z .": [
-        "workspace::SendKeystrokes",
-        "z z ^"
-      ],
+      "z .": ["workspace::SendKeystrokes", "z z ^"],
       "z b": "editor::ScrollCursorBottom",
       "z a": "editor::ToggleFold",
       "z shift-a": "editor::ToggleFoldRecursive",
@@ -331,55 +166,18 @@
       "z f": "editor::FoldSelectedRanges",
       "z shift-m": "editor::FoldAll",
       "z shift-r": "editor::UnfoldAll",
-      "shift-z shift-q": [
-        "pane::CloseActiveItem",
-        {
-          "save_intent": "skip"
-        }
-      ],
-      "shift-z shift-z": [
-        "pane::CloseActiveItem",
-        {
-          "save_intent": "save_all"
-        }
-      ],
+      "shift-z shift-q": ["pane::CloseActiveItem", { "save_intent": "skip" }],
+      "shift-z shift-z": ["pane::CloseActiveItem", { "save_intent": "save_all" }],
       // Count support
-      "1": [
-        "vim::Number",
-        1
-      ],
-      "2": [
-        "vim::Number",
-        2
-      ],
-      "3": [
-        "vim::Number",
-        3
-      ],
-      "4": [
-        "vim::Number",
-        4
-      ],
-      "5": [
-        "vim::Number",
-        5
-      ],
-      "6": [
-        "vim::Number",
-        6
-      ],
-      "7": [
-        "vim::Number",
-        7
-      ],
-      "8": [
-        "vim::Number",
-        8
-      ],
-      "9": [
-        "vim::Number",
-        9
-      ],
+      "1": ["vim::Number", 1],
+      "2": ["vim::Number", 2],
+      "3": ["vim::Number", 3],
+      "4": ["vim::Number", 4],
+      "5": ["vim::Number", 5],
+      "6": ["vim::Number", 6],
+      "7": ["vim::Number", 7],
+      "8": ["vim::Number", 8],
+      "9": ["vim::Number", 9],
       "ctrl-w d": "editor::GoToDefinitionSplit",
       "ctrl-w g d": "editor::GoToDefinitionSplit",
       "ctrl-w shift-d": "editor::GoToTypeDefinitionSplit",
@@ -416,12 +214,7 @@
       "ctrl-a": "vim::Increment",
       "ctrl-x": "vim::Decrement",
       "p": "vim::Paste",
-      "shift-p": [
-        "vim::Paste",
-        {
-          "before": true
-        }
-      ],
+      "shift-p": ["vim::Paste", { "before": true }],
       "u": "vim::Undo",
       "ctrl-r": "vim::Redo",
       "r": "vim::PushReplace",
@@ -438,25 +231,22 @@
       "g w": "vim::PushRewrap",
       "g q": "vim::PushRewrap",
       "ctrl-pagedown": "pane::ActivateNextItem",
-      "ctrl-pageup": "pane::ActivatePreviousItem",
+      "ctrl-pageup": "pane::ActivatePrevItem",
       "insert": "vim::InsertBefore",
       // tree-sitter related commands
       "[ x": "vim::SelectLargerSyntaxNode",
       "] x": "vim::SelectSmallerSyntaxNode",
       "] d": "editor::GoToDiagnostic",
-      "[ d": "editor::GoToPreviousDiagnostic",
+      "[ d": "editor::GoToPrevDiagnostic",
       "] c": "editor::GoToHunk",
-      "[ c": "editor::GoToPreviousHunk",
+      "[ c": "editor::GoToPrevHunk",
       "g c": "vim::PushToggleComments"
     }
   },
   {
     "context": "VimControl && VimCount",
     "bindings": {
-      "0": [
-        "vim::Number",
-        0
-      ],
+      "0": ["vim::Number", 0],
       ":": "vim::CountCommand"
     }
   },
@@ -475,43 +265,18 @@
       "y": "vim::VisualYank",
       "shift-y": "vim::VisualYankLine",
       "p": "vim::Paste",
-      "shift-p": [
-        "vim::Paste",
-        {
-          "preserve_clipboard": true
-        }
-      ],
+      "shift-p": ["vim::Paste", { "preserve_clipboard": true }],
       "c": "vim::Substitute",
       "s": "vim::Substitute",
       "shift-r": "vim::SubstituteLine",
       "shift-s": "vim::SubstituteLine",
       "~": "vim::ChangeCase",
-      "*": [
-        "vim::MoveToNext",
-        {
-          "partial_word": true
-        }
-      ],
-      "#": [
-        "vim::MoveToPrevious",
-        {
-          "partial_word": true
-        }
-      ],
+      "*": ["vim::MoveToNext", { "partial_word": true }],
+      "#": ["vim::MoveToPrev", { "partial_word": true }],
       "ctrl-a": "vim::Increment",
       "ctrl-x": "vim::Decrement",
-      "g ctrl-a": [
-        "vim::Increment",
-        {
-          "step": true
-        }
-      ],
-      "g ctrl-x": [
-        "vim::Decrement",
-        {
-          "step": true
-        }
-      ],
+      "g ctrl-a": ["vim::Increment", { "step": true }],
+      "g ctrl-x": ["vim::Decrement", { "step": true }],
       "shift-i": "vim::InsertBefore",
       "shift-a": "vim::InsertAfter",
       "g shift-i": "vim::VisualInsertFirstNonWhiteSpace",
@@ -526,24 +291,9 @@
       "<": "vim::Outdent",
       "=": "vim::AutoIndent",
       "!": "vim::ShellCommand",
-      "i": [
-        "vim::PushObject",
-        {
-          "around": false
-        }
-      ],
-      "a": [
-        "vim::PushObject",
-        {
-          "around": true
-        }
-      ],
-      "g r": [
-        "vim::Paste",
-        {
-          "preserve_clipboard": true
-        }
-      ],
+      "i": ["vim::PushObject", { "around": false }],
+      "a": ["vim::PushObject", { "around": true }],
+      "g r": ["vim::Paste", { "preserve_clipboard": true }],
       "g c": "vim::ToggleComments",
       "g q": "vim::Rewrap",
       "\"": "vim::PushRegister",
@@ -568,23 +318,11 @@
       "ctrl-u": "editor::DeleteToBeginningOfLine",
       "ctrl-t": "vim::Indent",
       "ctrl-d": "vim::Outdent",
-      "ctrl-k": [
-        "vim::PushDigraph",
-        {}
-      ],
-      "ctrl-v": [
-        "vim::PushLiteral",
-        {}
-      ],
+      "ctrl-k": ["vim::PushDigraph", {}],
+      "ctrl-v": ["vim::PushLiteral", {}],
       "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": [
-        "vim::PushLiteral",
-        {}
-      ],
-      "ctrl-shift-q": [
-        "vim::PushLiteral",
-        {}
-      ],
+      "ctrl-q": ["vim::PushLiteral", {}],
+      "ctrl-shift-q": ["vim::PushLiteral", {}],
       "ctrl-r": "vim::PushRegister",
       "insert": "vim::ToggleReplace",
       "ctrl-o": "vim::TemporaryNormal"
@@ -599,12 +337,14 @@
       "w": "vim::NextWordStart",
       "e": "vim::NextWordEnd",
       "b": "vim::PreviousWordStart",
+
       "h": "vim::Left",
       "j": "vim::Down",
       "k": "vim::Up",
       "l": "vim::Right"
     }
   },
+
   {
     "context": "vim_mode == insert && !(showing_code_actions || showing_completions)",
     "bindings": {
@@ -618,23 +358,11 @@
       "ctrl-c": "vim::NormalBefore",
       "ctrl-[": "vim::NormalBefore",
       "escape": "vim::NormalBefore",
-      "ctrl-k": [
-        "vim::PushDigraph",
-        {}
-      ],
-      "ctrl-v": [
-        "vim::PushLiteral",
-        {}
-      ],
+      "ctrl-k": ["vim::PushDigraph", {}],
+      "ctrl-v": ["vim::PushLiteral", {}],
       "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": [
-        "vim::PushLiteral",
-        {}
-      ],
-      "ctrl-shift-q": [
-        "vim::PushLiteral",
-        {}
-      ],
+      "ctrl-q": ["vim::PushLiteral", {}],
+      "ctrl-shift-q": ["vim::PushLiteral", {}],
       "backspace": "vim::UndoReplace",
       "tab": "vim::Tab",
       "enter": "vim::Enter",
@@ -649,18 +377,9 @@
       "ctrl-c": "vim::ClearOperators",
       "ctrl-[": "vim::ClearOperators",
       "escape": "vim::ClearOperators",
-      "ctrl-k": [
-        "vim::PushDigraph",
-        {}
-      ],
-      "ctrl-v": [
-        "vim::PushLiteral",
-        {}
-      ],
-      "ctrl-q": [
-        "vim::PushLiteral",
-        {}
-      ]
+      "ctrl-k": ["vim::PushDigraph", {}],
+      "ctrl-v": ["vim::PushLiteral", {}],
+      "ctrl-q": ["vim::PushLiteral", {}]
     }
   },
   {
@@ -682,12 +401,7 @@
     "context": "vim_operator == a || vim_operator == i || vim_operator == cs",
     "bindings": {
       "w": "vim::Word",
-      "shift-w": [
-        "vim::Word",
-        {
-          "ignore_punctuation": true
-        }
-      ],
+      "shift-w": ["vim::Word", { "ignore_punctuation": true }],
       // Subword TextObject
       // "w": "vim::Subword",
       // "shift-w": ["vim::Subword", { "ignore_punctuation": true }],
@@ -713,12 +427,7 @@
       ">": "vim::AngleBrackets",
       "a": "vim::Argument",
       "i": "vim::IndentObj",
-      "shift-i": [
-        "vim::IndentObj",
-        {
-          "include_below": true
-        }
-      ],
+      "shift-i": ["vim::IndentObj", { "include_below": true }],
       "f": "vim::Method",
       "c": "vim::Class",
       "e": "vim::EntireFile"
@@ -730,10 +439,7 @@
       "c": "vim::CurrentLine",
       "x": "vim::Exchange",
       "d": "editor::Rename", // zed specific
-      "s": [
-        "vim::PushChangeSurrounds",
-        {}
-      ]
+      "s": ["vim::PushChangeSurrounds", {}]
     }
   },
   {
@@ -779,10 +485,7 @@
     "context": "vim_operator == y",
     "bindings": {
       "y": "vim::CurrentLine",
-      "s": [
-        "vim::PushAddSurrounds",
-        {}
-      ]
+      "s": ["vim::PushAddSurrounds", {}]
     }
   },
   {
@@ -837,266 +540,44 @@
   {
     "context": "vim_mode == literal",
     "bindings": {
-      "ctrl-@": [
-        "vim::Literal",
-        [
-          "ctrl-@",
-          "\u0000"
-        ]
-      ],
-      "ctrl-a": [
-        "vim::Literal",
-        [
-          "ctrl-a",
-          "\u0001"
-        ]
-      ],
-      "ctrl-b": [
-        "vim::Literal",
-        [
-          "ctrl-b",
-          "\u0002"
-        ]
-      ],
-      "ctrl-c": [
-        "vim::Literal",
-        [
-          "ctrl-c",
-          "\u0003"
-        ]
-      ],
-      "ctrl-d": [
-        "vim::Literal",
-        [
-          "ctrl-d",
-          "\u0004"
-        ]
-      ],
-      "ctrl-e": [
-        "vim::Literal",
-        [
-          "ctrl-e",
-          "\u0005"
-        ]
-      ],
-      "ctrl-f": [
-        "vim::Literal",
-        [
-          "ctrl-f",
-          "\u0006"
-        ]
-      ],
-      "ctrl-g": [
-        "vim::Literal",
-        [
-          "ctrl-g",
-          "\u0007"
-        ]
-      ],
-      "ctrl-h": [
-        "vim::Literal",
-        [
-          "ctrl-h",
-          "\u0008"
-        ]
-      ],
-      "ctrl-i": [
-        "vim::Literal",
-        [
-          "ctrl-i",
-          "\u0009"
-        ]
-      ],
-      "ctrl-j": [
-        "vim::Literal",
-        [
-          "ctrl-j",
-          "\u000A"
-        ]
-      ],
-      "ctrl-k": [
-        "vim::Literal",
-        [
-          "ctrl-k",
-          "\u000B"
-        ]
-      ],
-      "ctrl-l": [
-        "vim::Literal",
-        [
-          "ctrl-l",
-          "\u000C"
-        ]
-      ],
-      "ctrl-m": [
-        "vim::Literal",
-        [
-          "ctrl-m",
-          "\u000D"
-        ]
-      ],
-      "ctrl-n": [
-        "vim::Literal",
-        [
-          "ctrl-n",
-          "\u000E"
-        ]
-      ],
-      "ctrl-o": [
-        "vim::Literal",
-        [
-          "ctrl-o",
-          "\u000F"
-        ]
-      ],
-      "ctrl-p": [
-        "vim::Literal",
-        [
-          "ctrl-p",
-          "\u0010"
-        ]
-      ],
-      "ctrl-q": [
-        "vim::Literal",
-        [
-          "ctrl-q",
-          "\u0011"
-        ]
-      ],
-      "ctrl-r": [
-        "vim::Literal",
-        [
-          "ctrl-r",
-          "\u0012"
-        ]
-      ],
-      "ctrl-s": [
-        "vim::Literal",
-        [
-          "ctrl-s",
-          "\u0013"
-        ]
-      ],
-      "ctrl-t": [
-        "vim::Literal",
-        [
-          "ctrl-t",
-          "\u0014"
-        ]
-      ],
-      "ctrl-u": [
-        "vim::Literal",
-        [
-          "ctrl-u",
-          "\u0015"
-        ]
-      ],
-      "ctrl-v": [
-        "vim::Literal",
-        [
-          "ctrl-v",
-          "\u0016"
-        ]
-      ],
-      "ctrl-w": [
-        "vim::Literal",
-        [
-          "ctrl-w",
-          "\u0017"
-        ]
-      ],
-      "ctrl-x": [
-        "vim::Literal",
-        [
-          "ctrl-x",
-          "\u0018"
-        ]
-      ],
-      "ctrl-y": [
-        "vim::Literal",
-        [
-          "ctrl-y",
-          "\u0019"
-        ]
-      ],
-      "ctrl-z": [
-        "vim::Literal",
-        [
-          "ctrl-z",
-          "\u001A"
-        ]
-      ],
-      "ctrl-[": [
-        "vim::Literal",
-        [
-          "ctrl-[",
-          "\u001B"
-        ]
-      ],
-      "ctrl-\\": [
-        "vim::Literal",
-        [
-          "ctrl-\\",
-          "\u001C"
-        ]
-      ],
-      "ctrl-]": [
-        "vim::Literal",
-        [
-          "ctrl-]",
-          "\u001D"
-        ]
-      ],
-      "ctrl-^": [
-        "vim::Literal",
-        [
-          "ctrl-^",
-          "\u001E"
-        ]
-      ],
-      "ctrl-_": [
-        "vim::Literal",
-        [
-          "ctrl-_",
-          "\u001F"
-        ]
-      ],
-      "escape": [
-        "vim::Literal",
-        [
-          "escape",
-          "\u001B"
-        ]
-      ],
-      "enter": [
-        "vim::Literal",
-        [
-          "enter",
-          "\u000D"
-        ]
-      ],
-      "tab": [
-        "vim::Literal",
-        [
-          "tab",
-          "\u0009"
-        ]
-      ],
+      "ctrl-@": ["vim::Literal", ["ctrl-@", "\u0000"]],
+      "ctrl-a": ["vim::Literal", ["ctrl-a", "\u0001"]],
+      "ctrl-b": ["vim::Literal", ["ctrl-b", "\u0002"]],
+      "ctrl-c": ["vim::Literal", ["ctrl-c", "\u0003"]],
+      "ctrl-d": ["vim::Literal", ["ctrl-d", "\u0004"]],
+      "ctrl-e": ["vim::Literal", ["ctrl-e", "\u0005"]],
+      "ctrl-f": ["vim::Literal", ["ctrl-f", "\u0006"]],
+      "ctrl-g": ["vim::Literal", ["ctrl-g", "\u0007"]],
+      "ctrl-h": ["vim::Literal", ["ctrl-h", "\u0008"]],
+      "ctrl-i": ["vim::Literal", ["ctrl-i", "\u0009"]],
+      "ctrl-j": ["vim::Literal", ["ctrl-j", "\u000A"]],
+      "ctrl-k": ["vim::Literal", ["ctrl-k", "\u000B"]],
+      "ctrl-l": ["vim::Literal", ["ctrl-l", "\u000C"]],
+      "ctrl-m": ["vim::Literal", ["ctrl-m", "\u000D"]],
+      "ctrl-n": ["vim::Literal", ["ctrl-n", "\u000E"]],
+      "ctrl-o": ["vim::Literal", ["ctrl-o", "\u000F"]],
+      "ctrl-p": ["vim::Literal", ["ctrl-p", "\u0010"]],
+      "ctrl-q": ["vim::Literal", ["ctrl-q", "\u0011"]],
+      "ctrl-r": ["vim::Literal", ["ctrl-r", "\u0012"]],
+      "ctrl-s": ["vim::Literal", ["ctrl-s", "\u0013"]],
+      "ctrl-t": ["vim::Literal", ["ctrl-t", "\u0014"]],
+      "ctrl-u": ["vim::Literal", ["ctrl-u", "\u0015"]],
+      "ctrl-v": ["vim::Literal", ["ctrl-v", "\u0016"]],
+      "ctrl-w": ["vim::Literal", ["ctrl-w", "\u0017"]],
+      "ctrl-x": ["vim::Literal", ["ctrl-x", "\u0018"]],
+      "ctrl-y": ["vim::Literal", ["ctrl-y", "\u0019"]],
+      "ctrl-z": ["vim::Literal", ["ctrl-z", "\u001A"]],
+      "ctrl-[": ["vim::Literal", ["ctrl-[", "\u001B"]],
+      "ctrl-\\": ["vim::Literal", ["ctrl-\\", "\u001C"]],
+      "ctrl-]": ["vim::Literal", ["ctrl-]", "\u001D"]],
+      "ctrl-^": ["vim::Literal", ["ctrl-^", "\u001E"]],
+      "ctrl-_": ["vim::Literal", ["ctrl-_", "\u001F"]],
+      "escape": ["vim::Literal", ["escape", "\u001B"]],
+      "enter": ["vim::Literal", ["enter", "\u000D"]],
+      "tab": ["vim::Literal", ["tab", "\u0009"]],
       // zed extensions:
-      "backspace": [
-        "vim::Literal",
-        [
-          "backspace",
-          "\u0008"
-        ]
-      ],
-      "delete": [
-        "vim::Literal",
-        [
-          "delete",
-          "\u007F"
-        ]
-      ]
+      "backspace": ["vim::Literal", ["backspace", "\u0008"]],
+      "delete": ["vim::Literal", ["delete", "\u007F"]]
     }
   },
   {
@@ -1139,8 +620,8 @@
       "ctrl-w =": "vim::ResetPaneSizes",
       "ctrl-w g t": "pane::ActivateNextItem",
       "ctrl-w ctrl-g t": "pane::ActivateNextItem",
-      "ctrl-w g shift-t": "pane::ActivatePreviousItem",
-      "ctrl-w ctrl-g shift-t": "pane::ActivatePreviousItem",
+      "ctrl-w g shift-t": "pane::ActivatePrevItem",
+      "ctrl-w ctrl-g shift-t": "pane::ActivatePrevItem",
       "ctrl-w w": "workspace::ActivateNextPane",
       "ctrl-w ctrl-w": "workspace::ActivateNextPane",
       "ctrl-w p": "workspace::ActivatePreviousPane",
@@ -1183,7 +664,7 @@
       "escape": "project_panel::ToggleFocus",
       "h": "project_panel::CollapseSelectedEntry",
       "j": "menu::SelectNext",
-      "k": "menu::SelectPrevious",
+      "k": "menu::SelectPrev",
       "l": "project_panel::ExpandSelectedEntry",
       "o": "project_panel::OpenPermanent",
       "shift-d": "project_panel::Delete",
@@ -1209,7 +690,7 @@
     "context": "OutlinePanel && not_editing",
     "bindings": {
       "j": "menu::SelectNext",
-      "k": "menu::SelectPrevious",
+      "k": "menu::SelectPrev",
       "shift-g": "menu::SelectLast",
       "g g": "menu::SelectFirst"
     }
@@ -1218,7 +699,7 @@
     "context": "GitPanel && ChangesList",
     "use_key_equivalents": true,
     "bindings": {
-      "k": "menu::SelectPrevious",
+      "k": "menu::SelectPrev",
       "j": "menu::SelectNext",
       "g g": "menu::SelectFirst",
       "shift-g": "menu::SelectLast",
@@ -1246,4 +727,4 @@
       "alt-l": "editor::AcceptEditPrediction"
     }
   }
-]
+]

assets/settings/default.json

@@ -1376,6 +1376,12 @@
   //   }
   // ]
   "ssh_connections": [],
+
   // Configures context servers for use in the Assistant.
-  "context_servers": {}
+  "context_servers": {},
+  "debugger": {
+    "stepping_granularity": "line",
+    "save_breakpoints": true,
+    "button": true
+  }
 }

assets/settings/initial_debug_tasks.json

@@ -0,0 +1,32 @@
+[
+  {
+    "label": "Debug active PHP file",
+    "adapter": "php",
+    "program": "$ZED_FILE",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "Debug active Python file",
+    "adapter": "python",
+    "program": "$ZED_FILE",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "Debug active JavaScript file",
+    "adapter": "javascript",
+    "program": "$ZED_FILE",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT"
+  },
+  {
+    "label": "JavaScript debug terminal",
+    "adapter": "javascript",
+    "request": "launch",
+    "cwd": "$ZED_WORKTREE_ROOT",
+    "initialize_args": {
+      "console": "integratedTerminal"
+    }
+  }
+]

crates/activity_indicator/Cargo.toml

@@ -20,7 +20,6 @@ extension_host.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
-lsp.workspace = true
 project.workspace = true
 smallvec.workspace = true
 ui.workspace = true

crates/activity_indicator/src/activity_indicator.rs

@@ -7,8 +7,7 @@ use gpui::{
     EventEmitter, InteractiveElement as _, ParentElement as _, Render, SharedString,
     StatefulInteractiveElement, Styled, Transformation, Window,
 };
-use language::{LanguageRegistry, LanguageServerBinaryStatus, LanguageServerId};
-use lsp::LanguageServerName;
+use language::{BinaryStatus, LanguageRegistry, LanguageServerId};
 use project::{EnvironmentErrorMessage, LanguageServerProgress, Project, WorktreeId};
 use smallvec::SmallVec;
 use std::{cmp::Reverse, fmt::Write, sync::Arc, time::Duration};
@@ -20,21 +19,21 @@ actions!(activity_indicator, [ShowErrorMessage]);
 
 pub enum Event {
     ShowError {
-        lsp_name: LanguageServerName,
+        server_name: SharedString,
         error: String,
     },
 }
 
 pub struct ActivityIndicator {
-    statuses: Vec<LspStatus>,
+    statuses: Vec<ServerStatus>,
     project: Entity<Project>,
     auto_updater: Option<Entity<AutoUpdater>>,
     context_menu_handle: PopoverMenuHandle<ContextMenu>,
 }
 
-struct LspStatus {
-    name: LanguageServerName,
-    status: LanguageServerBinaryStatus,
+struct ServerStatus {
+    name: SharedString,
+    status: BinaryStatus,
 }
 
 struct PendingWork<'a> {
@@ -65,7 +64,20 @@ impl ActivityIndicator {
                 while let Some((name, status)) = status_events.next().await {
                     this.update(&mut cx, |this: &mut ActivityIndicator, cx| {
                         this.statuses.retain(|s| s.name != name);
-                        this.statuses.push(LspStatus { name, status });
+                        this.statuses.push(ServerStatus { name, status });
+                        cx.notify();
+                    })?;
+                }
+                anyhow::Ok(())
+            })
+            .detach();
+
+            let mut status_events = languages.dap_server_binary_statuses();
+            cx.spawn(|this, mut cx| async move {
+                while let Some((name, status)) = status_events.next().await {
+                    this.update(&mut cx, |this, cx| {
+                        this.statuses.retain(|s| s.name != name);
+                        this.statuses.push(ServerStatus { name, status });
                         cx.notify();
                     })?;
                 }
@@ -88,18 +100,18 @@ impl ActivityIndicator {
         });
 
         cx.subscribe_in(&this, window, move |_, _, event, window, cx| match event {
-            Event::ShowError { lsp_name, error } => {
+            Event::ShowError { server_name, error } => {
                 let create_buffer = project.update(cx, |project, cx| project.create_buffer(cx));
                 let project = project.clone();
                 let error = error.clone();
-                let lsp_name = lsp_name.clone();
+                let server_name = server_name.clone();
                 cx.spawn_in(window, |workspace, mut cx| async move {
                     let buffer = create_buffer.await?;
                     buffer.update(&mut cx, |buffer, cx| {
                         buffer.edit(
                             [(
                                 0..0,
-                                format!("Language server error: {}\n\n{}", lsp_name, error),
+                                format!("Language server error: {}\n\n{}", server_name, error),
                             )],
                             None,
                             cx,
@@ -129,9 +141,9 @@ impl ActivityIndicator {
 
     fn show_error_message(&mut self, _: &ShowErrorMessage, _: &mut Window, cx: &mut Context<Self>) {
         self.statuses.retain(|status| {
-            if let LanguageServerBinaryStatus::Failed { error } = &status.status {
+            if let BinaryStatus::Failed { error } = &status.status {
                 cx.emit(Event::ShowError {
-                    lsp_name: status.name.clone(),
+                    server_name: status.name.clone(),
                     error: error.clone(),
                 });
                 false
@@ -260,12 +272,10 @@ impl ActivityIndicator {
         let mut failed = SmallVec::<[_; 3]>::new();
         for status in &self.statuses {
             match status.status {
-                LanguageServerBinaryStatus::CheckingForUpdate => {
-                    checking_for_update.push(status.name.clone())
-                }
-                LanguageServerBinaryStatus::Downloading => downloading.push(status.name.clone()),
-                LanguageServerBinaryStatus::Failed { .. } => failed.push(status.name.clone()),
-                LanguageServerBinaryStatus::None => {}
+                BinaryStatus::CheckingForUpdate => checking_for_update.push(status.name.clone()),
+                BinaryStatus::Downloading => downloading.push(status.name.clone()),
+                BinaryStatus::Failed { .. } => failed.push(status.name.clone()),
+                BinaryStatus::None => {}
             }
         }
 
@@ -278,7 +288,7 @@ impl ActivityIndicator {
                 ),
                 message: format!(
                     "Downloading {}...",
-                    downloading.iter().map(|name| name.0.as_ref()).fold(
+                    downloading.iter().map(|name| name.as_ref()).fold(
                         String::new(),
                         |mut acc, s| {
                             if !acc.is_empty() {
@@ -306,7 +316,7 @@ impl ActivityIndicator {
                 ),
                 message: format!(
                     "Checking for updates to {}...",
-                    checking_for_update.iter().map(|name| name.0.as_ref()).fold(
+                    checking_for_update.iter().map(|name| name.as_ref()).fold(
                         String::new(),
                         |mut acc, s| {
                             if !acc.is_empty() {
@@ -336,7 +346,7 @@ impl ActivityIndicator {
                     "Failed to run {}. Click to show error.",
                     failed
                         .iter()
-                        .map(|name| name.0.as_ref())
+                        .map(|name| name.as_ref())
                         .fold(String::new(), |mut acc, s| {
                             if !acc.is_empty() {
                                 acc.push_str(", ");

crates/assistant2/src/assistant_configuration.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use collections::HashMap;
-use gpui::{Action, AnyView, App, EventEmitter, FocusHandle, Focusable, Subscription};
+use gpui::{AnyView, App, EventEmitter, FocusHandle, Focusable, Subscription};
 use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
 use ui::{prelude::*, Divider, DividerColor, ElevationIndex};
 use zed_actions::assistant::DeployPromptLibrary;
@@ -168,8 +168,8 @@ impl Render for AssistantConfiguration {
                             .icon(IconName::Book)
                             .icon_size(IconSize::Small)
                             .icon_position(IconPosition::Start)
-                            .on_click(|_event, window, cx| {
-                                window.dispatch_action(DeployPromptLibrary.boxed_clone(), cx)
+                            .on_click(|_event, _window, cx| {
+                                cx.dispatch_action(&DeployPromptLibrary)
                             }),
                     ),
             )

crates/assistant2/src/thread.rs

@@ -518,7 +518,7 @@ impl Thread {
                         match output {
                             Ok(output) => {
                                 tool_results.push(LanguageModelToolResult {
-                                    tool_use_id: tool_use_id.clone(),
+                                    tool_use_id: tool_use_id.to_string(),
                                     content: output,
                                     is_error: false,
                                 });
@@ -527,7 +527,7 @@ impl Thread {
                             }
                             Err(err) => {
                                 tool_results.push(LanguageModelToolResult {
-                                    tool_use_id: tool_use_id.clone(),
+                                    tool_use_id: tool_use_id.to_string(),
                                     content: err.to_string(),
                                     is_error: true,
                                 });

crates/assistant2/src/thread_history.rs

@@ -33,9 +33,9 @@ impl ThreadHistory {
         }
     }
 
-    pub fn select_previous(
+    pub fn select_prev(
         &mut self,
-        _: &menu::SelectPrevious,
+        _: &menu::SelectPrev,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
@@ -160,7 +160,7 @@ impl Render for ThreadHistory {
             .overflow_y_scroll()
             .size_full()
             .p_1()
-            .on_action(cx.listener(Self::select_previous))
+            .on_action(cx.listener(Self::select_prev))
             .on_action(cx.listener(Self::select_next))
             .on_action(cx.listener(Self::select_first))
             .on_action(cx.listener(Self::select_last))

crates/assistant_context_editor/src/context_editor.rs

@@ -1087,7 +1087,7 @@ impl ContextEditor {
         patch: AssistantPatch,
         mut cx: AsyncWindowContext,
     ) -> Result<()> {
-        let project = this.read_with(&cx, |this, _| this.project.clone())?;
+        let project = this.update(&mut cx, |this, _| this.project.clone())?;
         let resolved_patch = patch.resolve(project.clone(), &mut cx).await;
 
         let editor = cx.new_window_entity(|window, cx| {
@@ -1112,7 +1112,7 @@ impl ContextEditor {
             editor
         })?;
 
-        this.update(&mut cx, |this, _| {
+        this.update_in(&mut cx, |this, window, cx| {
             if let Some(patch_state) = this.patches.get_mut(&patch.range) {
                 patch_state.editor = Some(PatchEditorState {
                     editor: editor.downgrade(),
@@ -1120,12 +1120,19 @@ impl ContextEditor {
                 });
                 patch_state.update_task.take();
             }
+
+            this.workspace
+                .update(cx, |workspace, cx| {
+                    workspace.add_item_to_active_pane(
+                        Box::new(editor.clone()),
+                        None,
+                        false,
+                        window,
+                        cx,
+                    )
+                })
+                .log_err();
         })?;
-        this.read_with(&cx, |this, _| this.workspace.clone())?
-            .update_in(&mut cx, |workspace, window, cx| {
-                workspace.add_item_to_active_pane(Box::new(editor.clone()), None, false, window, cx)
-            })
-            .log_err();
 
         Ok(())
     }

crates/bedrock/src/models.rs

@@ -7,10 +7,8 @@ use strum::EnumIter;
 pub enum Model {
     // Anthropic models (already included)
     #[default]
-    #[serde(rename = "claude-3-5-sonnet-v2", alias = "claude-3-5-sonnet-latest")]
+    #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-latest")]
     Claude3_5Sonnet,
-    #[serde(rename = "claude-3-7-sonnet", alias = "claude-3-7-sonnet-latest")]
-    Claude3_7Sonnet,
     #[serde(rename = "claude-3-opus", alias = "claude-3-opus-latest")]
     Claude3Opus,
     #[serde(rename = "claude-3-sonnet", alias = "claude-3-sonnet-latest")]
@@ -66,7 +64,7 @@ pub enum Model {
 
 impl Model {
     pub fn from_id(id: &str) -> anyhow::Result<Self> {
-        if id.starts_with("claude-3-5-sonnet-v2") {
+        if id.starts_with("claude-3-5-sonnet") {
             Ok(Self::Claude3_5Sonnet)
         } else if id.starts_with("claude-3-opus") {
             Ok(Self::Claude3Opus)
@@ -74,8 +72,6 @@ impl Model {
             Ok(Self::Claude3Sonnet)
         } else if id.starts_with("claude-3-5-haiku") {
             Ok(Self::Claude3_5Haiku)
-        } else if id.starts_with("claude-3-7-sonnet") {
-            Ok(Self::Claude3_7Sonnet)
         } else {
             Err(anyhow!("invalid model id"))
         }
@@ -87,7 +83,6 @@ impl Model {
             Model::Claude3Opus => "us.anthropic.claude-3-opus-20240229-v1:0",
             Model::Claude3Sonnet => "us.anthropic.claude-3-sonnet-20240229-v1:0",
             Model::Claude3_5Haiku => "us.anthropic.claude-3-5-haiku-20241022-v1:0",
-            Model::Claude3_7Sonnet => "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
             Model::AmazonNovaLite => "us.amazon.nova-lite-v1:0",
             Model::AmazonNovaMicro => "us.amazon.nova-micro-v1:0",
             Model::AmazonNovaPro => "us.amazon.nova-pro-v1:0",
@@ -125,11 +120,10 @@ impl Model {
 
     pub fn display_name(&self) -> &str {
         match self {
-            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet v2",
+            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
             Self::Claude3Opus => "Claude 3 Opus",
             Self::Claude3Sonnet => "Claude 3 Sonnet",
             Self::Claude3_5Haiku => "Claude 3.5 Haiku",
-            Self::Claude3_7Sonnet => "Claude 3.7 Sonnet",
             Self::AmazonNovaLite => "Amazon Nova Lite",
             Self::AmazonNovaMicro => "Amazon Nova Micro",
             Self::AmazonNovaPro => "Amazon Nova Pro",
@@ -172,8 +166,7 @@ impl Model {
             Self::Claude3_5Sonnet
             | Self::Claude3Opus
             | Self::Claude3Sonnet
-            | Self::Claude3_5Haiku
-            | Self::Claude3_7Sonnet => 200_000,
+            | Self::Claude3_5Haiku => 200_000,
             Self::Custom { max_tokens, .. } => *max_tokens,
             _ => 200_000,
         }
@@ -195,8 +188,7 @@ impl Model {
             Self::Claude3_5Sonnet
             | Self::Claude3Opus
             | Self::Claude3Sonnet
-            | Self::Claude3_5Haiku
-            | Self::Claude3_7Sonnet => 1.0,
+            | Self::Claude3_5Haiku => 1.0,
             Self::Custom {
                 default_temperature,
                 ..

crates/breadcrumbs/src/breadcrumbs.rs

@@ -81,7 +81,7 @@ impl Render for Breadcrumbs {
             }
             text_style.color = Color::Muted.color(cx);
 
-            StyledText::new(segment.text.replace('\n', "⏎"))
+            StyledText::new(segment.text.replace('\n', "␤"))
                 .with_highlights(&text_style, segment.highlights.unwrap_or_default())
                 .into_any()
         });

crates/buffer_diff/src/buffer_diff.rs

@@ -184,31 +184,17 @@ impl BufferDiffSnapshot {
         cx: &mut App,
     ) -> Option<Rope> {
         let secondary_diff = self.secondary_diff()?;
-        let head_text = self.base_text().map(|text| text.as_rope().clone());
-        let index_text = secondary_diff
-            .base_text()
-            .map(|text| text.as_rope().clone());
-        let (index_text, head_text) = match (index_text, head_text) {
-            (Some(index_text), Some(head_text)) => (index_text, head_text),
-            // file is deleted in both index and head
-            (None, None) => return None,
-            // file is deleted in index
-            (None, Some(head_text)) => {
-                return if stage {
-                    Some(buffer.as_rope().clone())
-                } else {
-                    Some(head_text)
-                }
-            }
-            // file exists in the index, but is deleted in head
-            (Some(_), None) => {
-                return if stage {
-                    Some(buffer.as_rope().clone())
-                } else {
-                    None
-                }
-            }
+        let index_base = if let Some(index_base) = secondary_diff.base_text() {
+            index_base.text.as_rope().clone()
+        } else if stage {
+            Rope::from("")
+        } else {
+            return None;
         };
+        let head_base = self.base_text().map_or_else(
+            || Rope::from(""),
+            |snapshot| snapshot.text.as_rope().clone(),
+        );
 
         let mut secondary_cursor = secondary_diff.inner.hunks.cursor::<DiffHunkSummary>(buffer);
         secondary_cursor.next(buffer);
@@ -265,7 +251,7 @@ impl BufferDiffSnapshot {
                     .collect::<String>()
             } else {
                 log::debug!("unstaging");
-                head_text
+                head_base
                     .chunks_in_range(diff_base_byte_range.clone())
                     .collect::<String>()
             };
@@ -273,7 +259,7 @@ impl BufferDiffSnapshot {
         }
 
         let buffer = cx.new(|cx| {
-            language::Buffer::local_normalized(index_text, text::LineEnding::default(), cx)
+            language::Buffer::local_normalized(index_base, text::LineEnding::default(), cx)
         });
         let new_text = buffer.update(cx, |buffer, cx| {
             buffer.edit(edits, None, cx);

crates/collab/Cargo.toml

@@ -89,15 +89,17 @@ channel.workspace = true
 client = { workspace = true, features = ["test-support"] }
 collab_ui = { workspace = true, features = ["test-support"] }
 collections = { workspace = true, features = ["test-support"] }
+command_palette_hooks.workspace = true
 context_server.workspace = true
 ctor.workspace = true
+dap = { workspace = true, features = ["test-support"] }
+debugger_ui = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 env_logger.workspace = true
 extension.workspace = true
 file_finder.workspace = true
 fs = { workspace = true, features = ["test-support"] }
 git = { workspace = true, features = ["test-support"] }
-git_ui = { workspace = true, features = ["test-support"] }
 git_hosting_providers.workspace = true
 gpui = { workspace = true, features = ["test-support"] }
 hyper.workspace = true

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

@@ -469,3 +469,14 @@ CREATE TABLE IF NOT EXISTS processed_stripe_events (
 );
 
 CREATE INDEX "ix_processed_stripe_events_on_stripe_event_created_timestamp" ON processed_stripe_events (stripe_event_created_timestamp);
+
+CREATE TABLE IF NOT EXISTS "breakpoints" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
+    "position" INTEGER NOT NULL,
+    "log_message" TEXT NULL,
+    "worktree_id" BIGINT NOT NULL,
+    "path" TEXT NOT NULL,
+    "kind" VARCHAR NOT NULL
+);
+CREATE INDEX "index_breakpoints_on_project_id" ON "breakpoints" ("project_id");

crates/collab/migrations/20241121185750_add_breakpoints.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS "breakpoints" (
+    "id" SERIAL PRIMARY KEY,
+    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
+    "position" INTEGER NOT NULL,
+    "log_message" TEXT NULL,
+    "worktree_id" BIGINT NOT NULL,
+    "path" TEXT NOT NULL,
+    "kind" VARCHAR NOT NULL
+);
+
+CREATE INDEX "index_breakpoints_on_project_id" ON "breakpoints" ("project_id");

crates/collab/src/db.rs

@@ -659,6 +659,7 @@ pub struct RejoinedProject {
     pub collaborators: Vec<ProjectCollaborator>,
     pub worktrees: Vec<RejoinedWorktree>,
     pub language_servers: Vec<proto::LanguageServer>,
+    pub breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>>,
 }
 
 impl RejoinedProject {
@@ -681,6 +682,17 @@ impl RejoinedProject {
                 .map(|collaborator| collaborator.to_proto())
                 .collect(),
             language_servers: self.language_servers.clone(),
+            breakpoints: self
+                .breakpoints
+                .iter()
+                .map(
+                    |(project_path, breakpoints)| proto::SynchronizeBreakpoints {
+                        project_id: self.id.to_proto(),
+                        breakpoints: breakpoints.iter().cloned().collect(),
+                        project_path: Some(project_path.clone()),
+                    },
+                )
+                .collect(),
         }
     }
 }
@@ -727,6 +739,7 @@ pub struct Project {
     pub collaborators: Vec<ProjectCollaborator>,
     pub worktrees: BTreeMap<u64, Worktree>,
     pub language_servers: Vec<proto::LanguageServer>,
+    pub breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>>,
 }
 
 pub struct ProjectCollaborator {

crates/collab/src/db/ids.rs

@@ -94,6 +94,9 @@ id_type!(RoomParticipantId);
 id_type!(ServerId);
 id_type!(SignupId);
 id_type!(UserId);
+id_type!(DebugClientId);
+id_type!(SessionId);
+id_type!(ThreadId);
 
 /// ChannelRole gives you permissions for both channels and calls.
 #[derive(

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

@@ -1,5 +1,5 @@
 use anyhow::Context as _;
-
+use collections::{HashMap, HashSet};
 use util::ResultExt;
 
 use super::*;
@@ -571,6 +571,60 @@ impl Database {
         .await
     }
 
+    pub async fn update_breakpoints(
+        &self,
+        connection_id: ConnectionId,
+        update: &proto::SynchronizeBreakpoints,
+    ) -> Result<TransactionGuard<HashSet<ConnectionId>>> {
+        let project_id = ProjectId::from_proto(update.project_id);
+        self.project_transaction(project_id, |tx| async move {
+            let project_path = update
+                .project_path
+                .as_ref()
+                .ok_or_else(|| anyhow!("invalid project path"))?;
+
+            // Ensure the update comes from the host.
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such project"))?;
+
+            // remove all existing breakpoints
+            breakpoints::Entity::delete_many()
+                .filter(breakpoints::Column::ProjectId.eq(project.id))
+                .exec(&*tx)
+                .await?;
+
+            if !update.breakpoints.is_empty() {
+                breakpoints::Entity::insert_many(update.breakpoints.iter().map(|breakpoint| {
+                    breakpoints::ActiveModel {
+                        id: ActiveValue::NotSet,
+                        project_id: ActiveValue::Set(project_id),
+                        worktree_id: ActiveValue::Set(project_path.worktree_id as i64),
+                        path: ActiveValue::Set(project_path.path.clone()),
+                        kind: match proto::BreakpointKind::from_i32(breakpoint.kind) {
+                            Some(proto::BreakpointKind::Log) => {
+                                ActiveValue::Set(breakpoints::BreakpointKind::Log)
+                            }
+                            Some(proto::BreakpointKind::Standard) => {
+                                ActiveValue::Set(breakpoints::BreakpointKind::Standard)
+                            }
+                            None => ActiveValue::Set(breakpoints::BreakpointKind::Standard),
+                        },
+                        log_message: ActiveValue::Set(breakpoint.message.clone()),
+                        position: ActiveValue::Set(breakpoint.cached_position as i32),
+                    }
+                }))
+                .exec_without_returning(&*tx)
+                .await?;
+            }
+
+            self.internal_project_connection_ids(project_id, connection_id, true, &tx)
+                .await
+        })
+        .await
+    }
+
     /// Updates the worktree settings for the given connection.
     pub async fn update_worktree_settings(
         &self,
@@ -852,6 +906,33 @@ impl Database {
             }
         }
 
+        let mut breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>> =
+            HashMap::default();
+
+        let db_breakpoints = project.find_related(breakpoints::Entity).all(tx).await?;
+
+        for breakpoint in db_breakpoints.iter() {
+            let project_path = proto::ProjectPath {
+                worktree_id: breakpoint.worktree_id as u64,
+                path: breakpoint.path.clone(),
+            };
+
+            breakpoints
+                .entry(project_path)
+                .or_default()
+                .insert(proto::Breakpoint {
+                    position: None,
+                    cached_position: breakpoint.position as u32,
+                    kind: match breakpoint.kind {
+                        breakpoints::BreakpointKind::Standard => {
+                            proto::BreakpointKind::Standard.into()
+                        }
+                        breakpoints::BreakpointKind::Log => proto::BreakpointKind::Log.into(),
+                    },
+                    message: breakpoint.log_message.clone(),
+                });
+        }
+
         // Populate language servers.
         let language_servers = project
             .find_related(language_server::Entity)
@@ -879,6 +960,7 @@ impl Database {
                     worktree_id: None,
                 })
                 .collect(),
+            breakpoints,
         };
         Ok((project, replica_id as ReplicaId))
     }
@@ -1106,41 +1188,52 @@ impl Database {
         exclude_dev_server: bool,
     ) -> Result<TransactionGuard<HashSet<ConnectionId>>> {
         self.project_transaction(project_id, |tx| async move {
-            let project = project::Entity::find_by_id(project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such project"))?;
-
-            let mut collaborators = project_collaborator::Entity::find()
-                .filter(project_collaborator::Column::ProjectId.eq(project_id))
-                .stream(&*tx)
-                .await?;
-
-            let mut connection_ids = HashSet::default();
-            if let Some(host_connection) = project.host_connection().log_err() {
-                if !exclude_dev_server {
-                    connection_ids.insert(host_connection);
-                }
-            }
-
-            while let Some(collaborator) = collaborators.next().await {
-                let collaborator = collaborator?;
-                connection_ids.insert(collaborator.connection());
-            }
-
-            if connection_ids.contains(&connection_id)
-                || Some(connection_id) == project.host_connection().ok()
-            {
-                Ok(connection_ids)
-            } else {
-                Err(anyhow!(
-                    "can only send project updates to a project you're in"
-                ))?
-            }
+            self.internal_project_connection_ids(project_id, connection_id, exclude_dev_server, &tx)
+                .await
         })
         .await
     }
 
+    async fn internal_project_connection_ids(
+        &self,
+        project_id: ProjectId,
+        connection_id: ConnectionId,
+        exclude_dev_server: bool,
+        tx: &DatabaseTransaction,
+    ) -> Result<HashSet<ConnectionId>> {
+        let project = project::Entity::find_by_id(project_id)
+            .one(tx)
+            .await?
+            .ok_or_else(|| anyhow!("no such project"))?;
+
+        let mut collaborators = project_collaborator::Entity::find()
+            .filter(project_collaborator::Column::ProjectId.eq(project_id))
+            .stream(tx)
+            .await?;
+
+        let mut connection_ids = HashSet::default();
+        if let Some(host_connection) = project.host_connection().log_err() {
+            if !exclude_dev_server {
+                connection_ids.insert(host_connection);
+            }
+        }
+
+        while let Some(collaborator) = collaborators.next().await {
+            let collaborator = collaborator?;
+            connection_ids.insert(collaborator.connection());
+        }
+
+        if connection_ids.contains(&connection_id)
+            || Some(connection_id) == project.host_connection().ok()
+        {
+            Ok(connection_ids)
+        } else {
+            Err(anyhow!(
+                "can only send project updates to a project you're in"
+            ))?
+        }
+    }
+
     async fn project_guest_connection_ids(
         &self,
         project_id: ProjectId,

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

@@ -765,6 +765,33 @@ impl Database {
             worktrees.push(worktree);
         }
 
+        let mut breakpoints: HashMap<proto::ProjectPath, HashSet<proto::Breakpoint>> =
+            HashMap::default();
+
+        let db_breakpoints = project.find_related(breakpoints::Entity).all(tx).await?;
+
+        for breakpoint in db_breakpoints.iter() {
+            let project_path = proto::ProjectPath {
+                worktree_id: breakpoint.worktree_id as u64,
+                path: breakpoint.path.clone(),
+            };
+
+            breakpoints
+                .entry(project_path)
+                .or_default()
+                .insert(proto::Breakpoint {
+                    position: None,
+                    cached_position: breakpoint.position as u32,
+                    kind: match breakpoint.kind {
+                        breakpoints::BreakpointKind::Standard => {
+                            proto::BreakpointKind::Standard.into()
+                        }
+                        breakpoints::BreakpointKind::Log => proto::BreakpointKind::Log.into(),
+                    },
+                    message: breakpoint.log_message.clone(),
+                });
+        }
+
         let language_servers = project
             .find_related(language_server::Entity)
             .all(tx)
@@ -834,6 +861,7 @@ impl Database {
             collaborators,
             worktrees,
             language_servers,
+            breakpoints,
         }))
     }
 

crates/collab/src/db/tables.rs

@@ -2,6 +2,7 @@ pub mod access_token;
 pub mod billing_customer;
 pub mod billing_preference;
 pub mod billing_subscription;
+pub mod breakpoints;
 pub mod buffer;
 pub mod buffer_operation;
 pub mod buffer_snapshot;

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

@@ -0,0 +1,47 @@
+use crate::db::ProjectId;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "breakpoints")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(primary_key)]
+    pub project_id: ProjectId,
+    pub worktree_id: i64,
+    pub path: String,
+    pub kind: BreakpointKind,
+    pub log_message: Option<String>,
+    pub position: i32,
+}
+
+#[derive(
+    Copy, Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, Default, Hash, serde::Serialize,
+)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::None)")]
+#[serde(rename_all = "snake_case")]
+pub enum BreakpointKind {
+    #[default]
+    #[sea_orm(string_value = "standard")]
+    Standard,
+    #[sea_orm(string_value = "log")]
+    Log,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::project::Entity",
+        from = "Column::ProjectId",
+        to = "super::project::Column::Id"
+    )]
+    Project,
+}
+
+impl Related<super::project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Project.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

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

@@ -49,6 +49,8 @@ pub enum Relation {
     Collaborators,
     #[sea_orm(has_many = "super::language_server::Entity")]
     LanguageServers,
+    #[sea_orm(has_many = "super::breakpoints::Entity")]
+    Breakpoints,
 }
 
 impl Related<super::user::Entity> for Entity {
@@ -81,4 +83,10 @@ impl Related<super::language_server::Entity> for Entity {
     }
 }
 
+impl Related<super::breakpoints::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Breakpoints.def()
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/llm.rs

@@ -451,15 +451,19 @@ async fn check_usage_limit(
         return Ok(());
     }
 
-    let user_id = UserId::from_proto(claims.user_id);
     let model = state.db.model(provider, model_name)?;
+    let usage = state
+        .db
+        .get_usage(
+            UserId::from_proto(claims.user_id),
+            provider,
+            model_name,
+            Utc::now(),
+        )
+        .await?;
     let free_tier = claims.free_tier_monthly_spending_limit();
 
-    let spending_this_month = state
-        .db
-        .get_user_spending_for_month(user_id, Utc::now())
-        .await?;
-    if spending_this_month >= free_tier {
+    if usage.spending_this_month >= free_tier {
         if !claims.has_llm_subscription {
             return Err(Error::http(
                 StatusCode::PAYMENT_REQUIRED,
@@ -467,8 +471,7 @@ async fn check_usage_limit(
             ));
         }
 
-        let monthly_spend = spending_this_month.saturating_sub(free_tier);
-        if monthly_spend >= Cents(claims.max_monthly_spend_in_cents) {
+        if (usage.spending_this_month - free_tier) >= Cents(claims.max_monthly_spend_in_cents) {
             return Err(Error::Http(
                 StatusCode::FORBIDDEN,
                 "Maximum spending limit reached for this month.".to_string(),
@@ -493,11 +496,6 @@ async fn check_usage_limit(
         model.max_tokens_per_minute as usize / users_in_recent_minutes;
     let per_user_max_tokens_per_day = model.max_tokens_per_day as usize / users_in_recent_days;
 
-    let usage = state
-        .db
-        .get_usage(user_id, provider, model_name, Utc::now())
-        .await?;
-
     let checks = [
         (
             usage.requests_this_minute,

crates/collab/src/llm/authorization.rs

@@ -27,7 +27,7 @@ fn authorize_access_to_model(
     }
 
     if provider == LanguageModelProvider::Anthropic {
-        if model == "claude-3-5-sonnet" || model == "claude-3-7-sonnet" {
+        if model == "claude-3-5-sonnet" {
             return Ok(());
         }
 

crates/collab/src/rpc.rs

@@ -427,7 +427,40 @@ impl Server {
                         app_state.config.openai_api_key.clone(),
                     )
                 }
-            });
+            })
+            .add_message_handler(update_breakpoints)
+            .add_message_handler(broadcast_project_message_from_host::<proto::SetActiveDebugLine>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::RemoveActiveDebugLine>,
+            )
+            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDebugAdapter>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::SetDebugClientCapabilities>,
+            )
+            .add_message_handler(broadcast_project_message_from_host::<proto::ShutdownDebugClient>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapNextRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapStepInRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapStepOutRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapStepBackRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapContinueRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapPauseRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapDisconnectRequest>)
+            .add_request_handler(
+                forward_mutating_project_request::<proto::DapTerminateThreadsRequest>,
+            )
+            .add_request_handler(forward_mutating_project_request::<proto::DapRestartRequest>)
+            .add_request_handler(forward_mutating_project_request::<proto::DapTerminateRequest>)
+            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateThreadStatus>)
+            .add_request_handler(forward_mutating_project_request::<proto::VariablesRequest>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::DapRestartStackFrameRequest>,
+            )
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::ToggleIgnoreBreakpoints>,
+            )
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::IgnoreBreakpointState>,
+            );
 
         Arc::new(server)
     }
@@ -1867,6 +1900,18 @@ fn join_project_internal(
             .trace_err();
     }
 
+    let breakpoints = project
+        .breakpoints
+        .iter()
+        .map(
+            |(project_path, breakpoint_set)| proto::SynchronizeBreakpoints {
+                project_id: project.id.0 as u64,
+                breakpoints: breakpoint_set.iter().map(|bp| bp.clone()).collect(),
+                project_path: Some(project_path.clone()),
+            },
+        )
+        .collect();
+
     // First, we send the metadata associated with each worktree.
     response.send(proto::JoinProjectResponse {
         project_id: project.id.0 as u64,
@@ -1875,6 +1920,7 @@ fn join_project_internal(
         collaborators: collaborators.clone(),
         language_servers: project.language_servers.clone(),
         role: project.role.into(),
+        breakpoints,
     })?;
 
     for (worktree_id, worktree) in mem::take(&mut project.worktrees) {
@@ -2061,7 +2107,7 @@ async fn update_worktree_settings(
     Ok(())
 }
 
-/// Notify other participants that a  language server has started.
+/// Notify other participants that a language server has started.
 async fn start_language_server(
     request: proto::StartLanguageServer,
     session: Session,
@@ -2107,6 +2153,29 @@ async fn update_language_server(
     Ok(())
 }
 
+/// Notify other participants that breakpoints have changed.
+async fn update_breakpoints(
+    request: proto::SynchronizeBreakpoints,
+    session: Session,
+) -> Result<()> {
+    let guest_connection_ids = session
+        .db()
+        .await
+        .update_breakpoints(session.connection_id, &request)
+        .await?;
+
+    broadcast(
+        Some(session.connection_id),
+        guest_connection_ids.iter().copied(),
+        |connection_id| {
+            session
+                .peer
+                .forward_send(session.connection_id, connection_id, request.clone())
+        },
+    );
+    Ok(())
+}
+
 /// forward a project request to the host. These requests should be read only
 /// as guests are allowed to send them.
 async fn forward_read_only_project_request<T>(

crates/collab/src/tests.rs

@@ -11,9 +11,9 @@ mod channel_buffer_tests;
 mod channel_guest_tests;
 mod channel_message_tests;
 mod channel_tests;
+mod debug_panel_tests;
 mod editor_tests;
 mod following_tests;
-mod git_tests;
 mod integration_tests;
 mod notification_tests;
 mod random_channel_buffer_tests;

crates/collab/src/tests/editor_tests.rs

@@ -22,7 +22,7 @@ use language::{
 };
 use project::{
     project_settings::{InlineBlameSettings, ProjectSettings},
-    SERVER_PROGRESS_THROTTLE_TIMEOUT,
+    ProjectPath, SERVER_PROGRESS_THROTTLE_TIMEOUT,
 };
 use recent_projects::disconnected_overlay::DisconnectedOverlay;
 use rpc::RECEIVE_TIMEOUT;
@@ -1591,6 +1591,8 @@ async fn test_mutual_editor_inlay_hint_cache_update(
         .await
         .unwrap();
 
+    executor.run_until_parked();
+
     // Client B joins the project
     let project_b = client_b.join_remote_project(project_id, cx_b).await;
     active_call_b
@@ -2394,6 +2396,202 @@ fn main() { let foo = other::foo(); }"};
     );
 }
 
+#[gpui::test]
+async fn test_add_breakpoints(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
+    let executor = cx_a.executor();
+    let mut server = TestServer::start(executor.clone()).await;
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+    let active_call_a = cx_a.read(ActiveCall::global);
+    let active_call_b = cx_b.read(ActiveCall::global);
+    cx_a.update(editor::init);
+    cx_b.update(editor::init);
+    client_a
+        .fs()
+        .insert_tree(
+            "/a",
+            json!({
+                "test.txt": "one\ntwo\nthree\nfour\nfive",
+            }),
+        )
+        .await;
+    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
+    let project_path = ProjectPath {
+        worktree_id,
+        path: Arc::from(Path::new(&"test.txt")),
+    };
+    active_call_a
+        .update(cx_a, |call, cx| call.set_location(Some(&project_a), cx))
+        .await
+        .unwrap();
+    let project_id = active_call_a
+        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+        .await
+        .unwrap();
+    let project_b = client_b.join_remote_project(project_id, cx_b).await;
+    active_call_b
+        .update(cx_b, |call, cx| call.set_location(Some(&project_b), cx))
+        .await
+        .unwrap();
+    let (workspace_a, cx_a) = client_a.build_workspace(&project_a, cx_a);
+    let (workspace_b, cx_b) = client_b.build_workspace(&project_b, cx_b);
+
+    // Client A opens an editor.
+    let editor_a = workspace_a
+        .update_in(cx_a, |workspace, window, cx| {
+            workspace.open_path(project_path.clone(), None, true, window, cx)
+        })
+        .await
+        .unwrap()
+        .downcast::<Editor>()
+        .unwrap();
+
+    // Client B opens same editor as A.
+    let editor_b = workspace_b
+        .update_in(cx_b, |workspace, window, cx| {
+            workspace.open_path(project_path.clone(), None, true, window, cx)
+        })
+        .await
+        .unwrap()
+        .downcast::<Editor>()
+        .unwrap();
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    // Client A adds breakpoint on line (1)
+    editor_a.update_in(cx_a, |editor, window, cx| {
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(1, breakpoints_a.len());
+    assert_eq!(1, breakpoints_a.get(&project_path).unwrap().len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+
+    // Client B adds breakpoint on line(2)
+    editor_b.update_in(cx_b, |editor, window, cx| {
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(1, breakpoints_a.len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+    assert_eq!(2, breakpoints_a.get(&project_path).unwrap().len());
+
+    // Client A removes last added breakpoint from client B
+    editor_a.update_in(cx_a, |editor, window, cx| {
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.move_down(&editor::actions::MoveDown, window, cx);
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(1, breakpoints_a.len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+    assert_eq!(1, breakpoints_a.get(&project_path).unwrap().len());
+
+    // Client B removes first added breakpoint by client A
+    editor_b.update_in(cx_b, |editor, window, cx| {
+        editor.move_up(&editor::actions::MoveUp, window, cx);
+        editor.move_up(&editor::actions::MoveUp, window, cx);
+        editor.toggle_breakpoint(&editor::actions::ToggleBreakpoint, window, cx);
+    });
+
+    cx_a.run_until_parked();
+    cx_b.run_until_parked();
+
+    let breakpoints_a = editor_a.update(cx_a, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+    let breakpoints_b = editor_b.update(cx_b, |editor, cx| {
+        editor
+            .breakpoint_store()
+            .clone()
+            .unwrap()
+            .read(cx)
+            .breakpoints()
+            .clone()
+    });
+
+    assert_eq!(0, breakpoints_a.len());
+    assert_eq!(breakpoints_a, breakpoints_b);
+}
+
 #[track_caller]
 fn tab_undo_assert(
     cx_a: &mut EditorTestContext,

crates/collab/src/tests/git_tests.rs

@@ -1,130 +0,0 @@
-use std::{
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-
-use call::ActiveCall;
-use git::status::{FileStatus, StatusCode, TrackedStatus};
-use git_ui::project_diff::ProjectDiff;
-use gpui::{TestAppContext, VisualTestContext};
-use project::ProjectPath;
-use serde_json::json;
-use workspace::Workspace;
-
-//
-use crate::tests::TestServer;
-
-#[gpui::test]
-async fn test_project_diff(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
-    let mut server = TestServer::start(cx_a.background_executor.clone()).await;
-    let client_a = server.create_client(cx_a, "user_a").await;
-    let client_b = server.create_client(cx_b, "user_b").await;
-    cx_a.set_name("cx_a");
-    cx_b.set_name("cx_b");
-
-    server
-        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
-        .await;
-
-    client_a
-        .fs()
-        .insert_tree(
-            "/a",
-            json!({
-                ".git": {},
-                "changed.txt": "after\n",
-                "unchanged.txt": "unchanged\n",
-                "created.txt": "created\n",
-                "secret.pem": "secret-changed\n",
-            }),
-        )
-        .await;
-
-    client_a.fs().set_git_content_for_repo(
-        Path::new("/a/.git"),
-        &[
-            ("changed.txt".into(), "before\n".to_string(), None),
-            ("unchanged.txt".into(), "unchanged\n".to_string(), None),
-            ("deleted.txt".into(), "deleted\n".to_string(), None),
-            ("secret.pem".into(), "shh\n".to_string(), None),
-        ],
-    );
-    let (project_a, worktree_id) = client_a.build_local_project("/a", cx_a).await;
-    let active_call_a = cx_a.read(ActiveCall::global);
-    let project_id = active_call_a
-        .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
-        .await
-        .unwrap();
-
-    cx_b.update(editor::init);
-    cx_b.update(git_ui::init);
-    let project_b = client_b.join_remote_project(project_id, cx_b).await;
-    let workspace_b = cx_b.add_window(|window, cx| {
-        Workspace::new(
-            None,
-            project_b.clone(),
-            client_b.app_state.clone(),
-            window,
-            cx,
-        )
-    });
-    let cx_b = &mut VisualTestContext::from_window(*workspace_b, cx_b);
-    let workspace_b = workspace_b.root(cx_b).unwrap();
-
-    cx_b.update(|window, cx| {
-        window
-            .focused(cx)
-            .unwrap()
-            .dispatch_action(&git_ui::project_diff::Diff, window, cx)
-    });
-    let diff = workspace_b.update(cx_b, |workspace, cx| {
-        workspace.active_item(cx).unwrap().act_as::<ProjectDiff>(cx)
-    });
-    let diff = diff.unwrap();
-    cx_b.run_until_parked();
-
-    diff.update(cx_b, |diff, cx| {
-        assert_eq!(
-            diff.excerpt_paths(cx),
-            vec!["changed.txt", "deleted.txt", "created.txt"]
-        );
-    });
-
-    client_a
-        .fs()
-        .insert_tree(
-            "/a",
-            json!({
-                ".git": {},
-                "changed.txt": "before\n",
-                "unchanged.txt": "changed\n",
-                "created.txt": "created\n",
-                "secret.pem": "secret-changed\n",
-            }),
-        )
-        .await;
-    client_a.fs().recalculate_git_status(Path::new("/a/.git"));
-    cx_b.run_until_parked();
-
-    project_b.update(cx_b, |project, cx| {
-        let project_path = ProjectPath {
-            worktree_id,
-            path: Arc::from(PathBuf::from("unchanged.txt")),
-        };
-        let status = project.project_path_git_status(&project_path, cx);
-        assert_eq!(
-            status.unwrap(),
-            FileStatus::Tracked(TrackedStatus {
-                worktree_status: StatusCode::Modified,
-                index_status: StatusCode::Unmodified,
-            })
-        );
-    });
-
-    diff.update(cx_b, |diff, cx| {
-        assert_eq!(
-            diff.excerpt_paths(cx),
-            vec!["deleted.txt", "unchanged.txt", "created.txt"]
-        );
-    });
-}

crates/collab_ui/src/collab_panel.rs

@@ -17,7 +17,7 @@ use gpui::{
     ListState, MouseDownEvent, ParentElement, Pixels, Point, PromptLevel, Render, SharedString,
     Styled, Subscription, Task, TextStyle, WeakEntity, Window,
 };
-use menu::{Cancel, Confirm, SecondaryConfirm, SelectNext, SelectPrevious};
+use menu::{Cancel, Confirm, SecondaryConfirm, SelectNext, SelectPrev};
 use project::{Fs, Project};
 use rpc::{
     proto::{self, ChannelVisibility, PeerId},
@@ -1430,7 +1430,7 @@ impl CollabPanel {
         cx.notify();
     }
 
-    fn select_previous(&mut self, _: &SelectPrevious, _: &mut Window, cx: &mut Context<Self>) {
+    fn select_prev(&mut self, _: &SelectPrev, _: &mut Window, cx: &mut Context<Self>) {
         let ix = self.selection.take().unwrap_or(0);
         if ix > 0 {
             self.selection = Some(ix - 1);
@@ -2878,7 +2878,7 @@ impl Render for CollabPanel {
             .key_context("CollabPanel")
             .on_action(cx.listener(CollabPanel::cancel))
             .on_action(cx.listener(CollabPanel::select_next))
-            .on_action(cx.listener(CollabPanel::select_previous))
+            .on_action(cx.listener(CollabPanel::select_prev))
             .on_action(cx.listener(CollabPanel::confirm))
             .on_action(cx.listener(CollabPanel::insert_space))
             .on_action(cx.listener(CollabPanel::remove_selected_channel))

crates/context_server/Cargo.toml

@@ -14,7 +14,6 @@ path = "src/context_server.rs"
 [dependencies]
 anyhow.workspace = true
 assistant_tool.workspace = true
-async-trait.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 context_server_settings.workspace = true

crates/context_server/src/client.rs

@@ -1,12 +1,16 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Context as _, Result};
 use collections::HashMap;
-use futures::{channel::oneshot, select, FutureExt, StreamExt};
+use futures::{channel::oneshot, io::BufWriter, select, AsyncRead, AsyncWrite, FutureExt};
 use gpui::{AppContext as _, AsyncApp, BackgroundExecutor, Task};
 use parking_lot::Mutex;
 use postage::barrier;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_json::{value::RawValue, Value};
-use smol::channel;
+use smol::{
+    channel,
+    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
+    process::Child,
+};
 use std::{
     fmt,
     path::PathBuf,
@@ -18,8 +22,6 @@ use std::{
 };
 use util::TryFutureExt;
 
-use crate::transport::{StdioTransport, Transport};
-
 const JSON_RPC_VERSION: &str = "2.0";
 const REQUEST_TIMEOUT: Duration = Duration::from_secs(60);
 
@@ -53,8 +55,7 @@ pub struct Client {
     #[allow(dead_code)]
     output_done_rx: Mutex<Option<barrier::Receiver>>,
     executor: BackgroundExecutor,
-    #[allow(dead_code)]
-    transport: Arc<dyn Transport>,
+    server: Arc<Mutex<Option<Child>>>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -151,13 +152,25 @@ impl Client {
             &binary.args
         );
 
-        let server_name = binary
-            .executable
-            .file_name()
-            .map(|name| name.to_string_lossy().to_string())
-            .unwrap_or_else(String::new);
+        let mut command = util::command::new_smol_command(&binary.executable);
+        command
+            .args(&binary.args)
+            .envs(binary.env.unwrap_or_default())
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped())
+            .kill_on_drop(true);
 
-        let transport = Arc::new(StdioTransport::new(binary, &cx)?);
+        let mut server = command.spawn().with_context(|| {
+            format!(
+                "failed to spawn command. (path={:?}, args={:?})",
+                binary.executable, &binary.args
+            )
+        })?;
+
+        let stdin = server.stdin.take().unwrap();
+        let stdout = server.stdout.take().unwrap();
+        let stderr = server.stderr.take().unwrap();
 
         let (outbound_tx, outbound_rx) = channel::unbounded::<String>();
         let (output_done_tx, output_done_rx) = barrier::channel();
@@ -170,22 +183,18 @@ impl Client {
         let stdout_input_task = cx.spawn({
             let notification_handlers = notification_handlers.clone();
             let response_handlers = response_handlers.clone();
-            let transport = transport.clone();
             move |cx| {
-                Self::handle_input(transport, notification_handlers, response_handlers, cx)
-                    .log_err()
+                Self::handle_input(stdout, notification_handlers, response_handlers, cx).log_err()
             }
         });
-        let stderr_input_task = cx.spawn(|_| Self::handle_stderr(transport.clone()).log_err());
+        let stderr_input_task = cx.spawn(|_| Self::handle_stderr(stderr).log_err());
         let input_task = cx.spawn(|_| async move {
             let (stdout, stderr) = futures::join!(stdout_input_task, stderr_input_task);
             stdout.or(stderr)
         });
-
         let output_task = cx.background_spawn({
-            let transport = transport.clone();
             Self::handle_output(
-                transport,
+                stdin,
                 outbound_rx,
                 output_done_tx,
                 response_handlers.clone(),
@@ -193,18 +202,24 @@ impl Client {
             .log_err()
         });
 
-        Ok(Self {
+        let mut context_server = Self {
             server_id,
             notification_handlers,
             response_handlers,
-            name: server_name.into(),
+            name: "".into(),
             next_id: Default::default(),
             outbound_tx,
             executor: cx.background_executor().clone(),
             io_tasks: Mutex::new(Some((input_task, output_task))),
             output_done_rx: Mutex::new(Some(output_done_rx)),
-            transport,
-        })
+            server: Arc::new(Mutex::new(Some(server))),
+        };
+
+        if let Some(name) = binary.executable.file_name() {
+            context_server.name = name.to_string_lossy().into();
+        }
+
+        Ok(context_server)
     }
 
     /// Handles input from the server's stdout.
@@ -213,53 +228,79 @@ impl Client {
     /// parses them as JSON-RPC responses or notifications, and dispatches them
     /// to the appropriate handlers. It processes both responses (which are matched
     /// to pending requests) and notifications (which trigger registered handlers).
-    async fn handle_input(
-        transport: Arc<dyn Transport>,
+    async fn handle_input<Stdout>(
+        stdout: Stdout,
         notification_handlers: Arc<Mutex<HashMap<&'static str, NotificationHandler>>>,
         response_handlers: Arc<Mutex<Option<HashMap<RequestId, ResponseHandler>>>>,
         cx: AsyncApp,
-    ) -> anyhow::Result<()> {
-        let mut receiver = transport.receive();
+    ) -> anyhow::Result<()>
+    where
+        Stdout: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut stdout = BufReader::new(stdout);
+        let mut buffer = String::new();
 
-        while let Some(message) = receiver.next().await {
-            if let Ok(response) = serde_json::from_str::<AnyResponse>(&message) {
-                if let Some(handlers) = response_handlers.lock().as_mut() {
-                    if let Some(handler) = handlers.remove(&response.id) {
-                        handler(Ok(message.to_string()));
+        loop {
+            buffer.clear();
+            if stdout.read_line(&mut buffer).await? == 0 {
+                return Ok(());
+            }
+
+            let content = buffer.trim();
+
+            if !content.is_empty() {
+                if let Ok(response) = serde_json::from_str::<AnyResponse>(content) {
+                    if let Some(handlers) = response_handlers.lock().as_mut() {
+                        if let Some(handler) = handlers.remove(&response.id) {
+                            handler(Ok(content.to_string()));
+                        }
+                    }
+                } else if let Ok(notification) = serde_json::from_str::<AnyNotification>(content) {
+                    let mut notification_handlers = notification_handlers.lock();
+                    if let Some(handler) =
+                        notification_handlers.get_mut(notification.method.as_str())
+                    {
+                        handler(notification.params.unwrap_or(Value::Null), cx.clone());
                     }
                 }
-            } else if let Ok(notification) = serde_json::from_str::<AnyNotification>(&message) {
-                let mut notification_handlers = notification_handlers.lock();
-                if let Some(handler) = notification_handlers.get_mut(notification.method.as_str()) {
-                    handler(notification.params.unwrap_or(Value::Null), cx.clone());
-                }
             }
+
+            smol::future::yield_now().await;
         }
-
-        smol::future::yield_now().await;
-
-        Ok(())
     }
 
     /// Handles the stderr output from the context server.
     /// Continuously reads and logs any error messages from the server.
-    async fn handle_stderr(transport: Arc<dyn Transport>) -> anyhow::Result<()> {
-        while let Some(err) = transport.receive_err().next().await {
-            log::warn!("context server stderr: {}", err.trim());
-        }
+    async fn handle_stderr<Stderr>(stderr: Stderr) -> anyhow::Result<()>
+    where
+        Stderr: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut stderr = BufReader::new(stderr);
+        let mut buffer = String::new();
 
-        Ok(())
+        loop {
+            buffer.clear();
+            if stderr.read_line(&mut buffer).await? == 0 {
+                return Ok(());
+            }
+            log::warn!("context server stderr: {}", buffer.trim());
+            smol::future::yield_now().await;
+        }
     }
 
     /// Handles the output to the context server's stdin.
     /// This function continuously receives messages from the outbound channel,
     /// writes them to the server's stdin, and manages the lifecycle of response handlers.
-    async fn handle_output(
-        transport: Arc<dyn Transport>,
+    async fn handle_output<Stdin>(
+        stdin: Stdin,
         outbound_rx: channel::Receiver<String>,
         output_done_tx: barrier::Sender,
         response_handlers: Arc<Mutex<Option<HashMap<RequestId, ResponseHandler>>>>,
-    ) -> anyhow::Result<()> {
+    ) -> anyhow::Result<()>
+    where
+        Stdin: AsyncWrite + Unpin + Send + 'static,
+    {
+        let mut stdin = BufWriter::new(stdin);
         let _clear_response_handlers = util::defer({
             let response_handlers = response_handlers.clone();
             move || {
@@ -268,7 +309,10 @@ impl Client {
         });
         while let Ok(message) = outbound_rx.recv().await {
             log::trace!("outgoing message: {}", message);
-            transport.send(message).await?;
+
+            stdin.write_all(message.as_bytes()).await?;
+            stdin.write_all(b"\n").await?;
+            stdin.flush().await?;
         }
         drop(output_done_tx);
         Ok(())
@@ -372,6 +416,14 @@ impl Client {
     }
 }
 
+impl Drop for Client {
+    fn drop(&mut self) {
+        if let Some(mut server) = self.server.lock().take() {
+            let _ = server.kill();
+        }
+    }
+}
+
 impl fmt::Display for ContextServerId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)

crates/context_server/src/context_server.rs

@@ -4,7 +4,6 @@ mod extension_context_server;
 pub mod manager;
 pub mod protocol;
 mod registry;
-mod transport;
 pub mod types;
 
 use command_palette_hooks::CommandPaletteFilter;

crates/context_server/src/transport.rs

@@ -1,16 +0,0 @@
-mod stdio_transport;
-
-use std::pin::Pin;
-
-use anyhow::Result;
-use async_trait::async_trait;
-use futures::Stream;
-
-pub use stdio_transport::*;
-
-#[async_trait]
-pub trait Transport: Send + Sync {
-    async fn send(&self, message: String) -> Result<()>;
-    fn receive(&self) -> Pin<Box<dyn Stream<Item = String> + Send>>;
-    fn receive_err(&self) -> Pin<Box<dyn Stream<Item = String> + Send>>;
-}

crates/context_server/src/transport/stdio_transport.rs

@@ -1,140 +0,0 @@
-use std::pin::Pin;
-
-use anyhow::{Context as _, Result};
-use async_trait::async_trait;
-use futures::io::{BufReader, BufWriter};
-use futures::{
-    AsyncBufReadExt as _, AsyncRead, AsyncWrite, AsyncWriteExt as _, Stream, StreamExt as _,
-};
-use gpui::AsyncApp;
-use smol::channel;
-use smol::process::Child;
-use util::TryFutureExt as _;
-
-use crate::client::ModelContextServerBinary;
-use crate::transport::Transport;
-
-pub struct StdioTransport {
-    stdout_sender: channel::Sender<String>,
-    stdin_receiver: channel::Receiver<String>,
-    stderr_receiver: channel::Receiver<String>,
-    server: Child,
-}
-
-impl StdioTransport {
-    pub fn new(binary: ModelContextServerBinary, cx: &AsyncApp) -> Result<Self> {
-        let mut command = util::command::new_smol_command(&binary.executable);
-        command
-            .args(&binary.args)
-            .envs(binary.env.unwrap_or_default())
-            .stdin(std::process::Stdio::piped())
-            .stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::piped())
-            .kill_on_drop(true);
-
-        let mut server = command.spawn().with_context(|| {
-            format!(
-                "failed to spawn command. (path={:?}, args={:?})",
-                binary.executable, &binary.args
-            )
-        })?;
-
-        let stdin = server.stdin.take().unwrap();
-        let stdout = server.stdout.take().unwrap();
-        let stderr = server.stderr.take().unwrap();
-
-        let (stdin_sender, stdin_receiver) = channel::unbounded::<String>();
-        let (stdout_sender, stdout_receiver) = channel::unbounded::<String>();
-        let (stderr_sender, stderr_receiver) = channel::unbounded::<String>();
-
-        cx.spawn(|_| Self::handle_output(stdin, stdout_receiver).log_err())
-            .detach();
-
-        cx.spawn(|_| async move { Self::handle_input(stdout, stdin_sender).await })
-            .detach();
-
-        cx.spawn(|_| async move { Self::handle_err(stderr, stderr_sender).await })
-            .detach();
-
-        Ok(Self {
-            stdout_sender,
-            stdin_receiver,
-            stderr_receiver,
-            server,
-        })
-    }
-
-    async fn handle_input<Stdout>(stdin: Stdout, inbound_rx: channel::Sender<String>)
-    where
-        Stdout: AsyncRead + Unpin + Send + 'static,
-    {
-        let mut stdin = BufReader::new(stdin);
-        let mut line = String::new();
-        while let Ok(n) = stdin.read_line(&mut line).await {
-            if n == 0 {
-                break;
-            }
-            if inbound_rx.send(line.clone()).await.is_err() {
-                break;
-            }
-            line.clear();
-        }
-    }
-
-    async fn handle_output<Stdin>(
-        stdin: Stdin,
-        outbound_rx: channel::Receiver<String>,
-    ) -> Result<()>
-    where
-        Stdin: AsyncWrite + Unpin + Send + 'static,
-    {
-        let mut stdin = BufWriter::new(stdin);
-        let mut pinned_rx = Box::pin(outbound_rx);
-        while let Some(message) = pinned_rx.next().await {
-            log::trace!("outgoing message: {}", message);
-
-            stdin.write_all(message.as_bytes()).await?;
-            stdin.write_all(b"\n").await?;
-            stdin.flush().await?;
-        }
-        Ok(())
-    }
-
-    async fn handle_err<Stderr>(stderr: Stderr, stderr_tx: channel::Sender<String>)
-    where
-        Stderr: AsyncRead + Unpin + Send + 'static,
-    {
-        let mut stderr = BufReader::new(stderr);
-        let mut line = String::new();
-        while let Ok(n) = stderr.read_line(&mut line).await {
-            if n == 0 {
-                break;
-            }
-            if stderr_tx.send(line.clone()).await.is_err() {
-                break;
-            }
-            line.clear();
-        }
-    }
-}
-
-#[async_trait]
-impl Transport for StdioTransport {
-    async fn send(&self, message: String) -> Result<()> {
-        Ok(self.stdout_sender.send(message).await?)
-    }
-
-    fn receive(&self) -> Pin<Box<dyn Stream<Item = String> + Send>> {
-        Box::pin(self.stdin_receiver.clone())
-    }
-
-    fn receive_err(&self) -> Pin<Box<dyn Stream<Item = String> + Send>> {
-        Box::pin(self.stderr_receiver.clone())
-    }
-}
-
-impl Drop for StdioTransport {
-    fn drop(&mut self) {
-        let _ = self.server.kill();
-    }
-}

crates/copilot/src/copilot.rs

@@ -475,7 +475,6 @@ impl Copilot {
                 binary,
                 root_path,
                 None,
-                Default::default(),
                 cx.clone(),
             )?;
 

crates/copilot/src/copilot_chat.rs

@@ -40,8 +40,6 @@ pub enum Model {
     O3Mini,
     #[serde(alias = "claude-3-5-sonnet", rename = "claude-3.5-sonnet")]
     Claude3_5Sonnet,
-    #[serde(alias = "claude-3-7-sonnet", rename = "claude-3.7-sonnet")]
-    Claude3_7Sonnet,
     #[serde(alias = "gemini-2.0-flash", rename = "gemini-2.0-flash-001")]
     Gemini20Flash,
 }
@@ -49,11 +47,7 @@ pub enum Model {
 impl Model {
     pub fn uses_streaming(&self) -> bool {
         match self {
-            Self::Gpt4o
-            | Self::Gpt4
-            | Self::Gpt3_5Turbo
-            | Self::Claude3_5Sonnet
-            | Self::Claude3_7Sonnet => true,
+            Self::Gpt4o | Self::Gpt4 | Self::Gpt3_5Turbo | Self::Claude3_5Sonnet => true,
             Self::O3Mini | Self::O1 | Self::Gemini20Flash => false,
         }
     }
@@ -66,7 +60,6 @@ impl Model {
             "o1" => Ok(Self::O1),
             "o3-mini" => Ok(Self::O3Mini),
             "claude-3-5-sonnet" => Ok(Self::Claude3_5Sonnet),
-            "claude-3-7-sonnet" => Ok(Self::Claude3_7Sonnet),
             "gemini-2.0-flash-001" => Ok(Self::Gemini20Flash),
             _ => Err(anyhow!("Invalid model id: {}", id)),
         }
@@ -80,7 +73,6 @@ impl Model {
             Self::O3Mini => "o3-mini",
             Self::O1 => "o1",
             Self::Claude3_5Sonnet => "claude-3-5-sonnet",
-            Self::Claude3_7Sonnet => "claude-3-7-sonnet",
             Self::Gemini20Flash => "gemini-2.0-flash-001",
         }
     }
@@ -93,7 +85,6 @@ impl Model {
             Self::O3Mini => "o3-mini",
             Self::O1 => "o1",
             Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
-            Self::Claude3_7Sonnet => "Claude 3.7 Sonnet",
             Self::Gemini20Flash => "Gemini 2.0 Flash",
         }
     }
@@ -105,8 +96,7 @@ impl Model {
             Self::Gpt3_5Turbo => 12_288,
             Self::O3Mini => 64_000,
             Self::O1 => 20_000,
-            Self::Claude3_5Sonnet => 200_000,
-            Self::Claude3_7Sonnet => 90_000,
+            Self::Claude3_5Sonnet => 128_000,
             Model::Gemini20Flash => 128_000,
         }
     }

crates/dap/Cargo.toml

@@ -0,0 +1,54 @@
+[package]
+name = "dap"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[features]
+test-support = [
+    "gpui/test-support",
+    "util/test-support",
+    "task/test-support",
+    "async-pipe",
+    "settings/test-support",
+]
+
+[dependencies]
+anyhow.workspace = true
+async-compression.workspace = true
+async-pipe = { workspace = true, optional = true }
+async-tar.workspace = true
+async-trait.workspace = true
+client.workspace = true
+collections.workspace = true
+dap-types = { git = "https://github.com/zed-industries/dap-types", rev = "bf5632dc19f806e8a435c9f04a4bfe7322badea2" }
+fs.workspace = true
+futures.workspace = true
+gpui.workspace = true
+http_client.workspace = true
+language.workspace = true
+log.workspace = true
+node_runtime.workspace = true
+parking_lot.workspace = true
+paths.workspace = true
+schemars.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+smallvec.workspace = true
+smol.workspace = true
+sysinfo.workspace = true
+task.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+async-pipe.workspace = true
+env_logger.workspace = true
+gpui = { workspace = true, features = ["test-support"] }
+settings = { workspace = true, features = ["test-support"] }
+task = { workspace = true, features = ["test-support"] }
+util = { workspace = true, features = ["test-support"] }

crates/dap/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/dap/docs/breakpoints.md

@@ -0,0 +1,9 @@
+# Overview
+
+The active `Project` is responsible for maintain opened and closed breakpoints
+as well as serializing breakpoints to save. At a high level project serializes
+the positions of breakpoints that don't belong to any active buffers and handles
+converting breakpoints from serializing to active whenever a buffer is opened/closed.
+
+`Project` also handles sending all relevant breakpoint information to debug adapter's
+during debugging or when starting a debugger.

crates/dap/src/adapters.rs

@@ -0,0 +1,391 @@
+use ::fs::Fs;
+use anyhow::{anyhow, Context as _, Ok, Result};
+use async_compression::futures::bufread::GzipDecoder;
+use async_tar::Archive;
+use async_trait::async_trait;
+use futures::io::BufReader;
+use gpui::{AsyncApp, SharedString};
+pub use http_client::{github::latest_github_release, HttpClient};
+use language::LanguageToolchainStore;
+use node_runtime::NodeRuntime;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use settings::WorktreeId;
+use smol::{self, fs::File, lock::Mutex};
+use std::{
+    collections::{HashMap, HashSet},
+    ffi::{OsStr, OsString},
+    fmt::Debug,
+    net::Ipv4Addr,
+    ops::Deref,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use sysinfo::{Pid, Process};
+use task::DebugAdapterConfig;
+use util::ResultExt;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DapStatus {
+    None,
+    CheckingForUpdate,
+    Downloading,
+    Failed { error: String },
+}
+
+#[async_trait(?Send)]
+pub trait DapDelegate {
+    fn worktree_id(&self) -> WorktreeId;
+    fn http_client(&self) -> Arc<dyn HttpClient>;
+    fn node_runtime(&self) -> NodeRuntime;
+    fn toolchain_store(&self) -> Arc<dyn LanguageToolchainStore>;
+    fn fs(&self) -> Arc<dyn Fs>;
+    fn updated_adapters(&self) -> Arc<Mutex<HashSet<DebugAdapterName>>>;
+    fn update_status(&self, dap_name: DebugAdapterName, status: DapStatus);
+    fn which(&self, command: &OsStr) -> Option<PathBuf>;
+    async fn shell_env(&self) -> collections::HashMap<String, String>;
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
+pub struct DebugAdapterName(pub Arc<str>);
+
+impl Deref for DebugAdapterName {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<str> for DebugAdapterName {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl AsRef<Path> for DebugAdapterName {
+    fn as_ref(&self) -> &Path {
+        Path::new(&*self.0)
+    }
+}
+
+impl std::fmt::Display for DebugAdapterName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl From<DebugAdapterName> for SharedString {
+    fn from(name: DebugAdapterName) -> Self {
+        SharedString::from(name.0)
+    }
+}
+
+impl<'a> From<&'a str> for DebugAdapterName {
+    fn from(str: &'a str) -> DebugAdapterName {
+        DebugAdapterName(str.to_string().into())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TcpArguments {
+    pub host: Ipv4Addr,
+    pub port: u16,
+    pub timeout: Option<u64>,
+}
+#[derive(Debug, Clone)]
+pub struct DebugAdapterBinary {
+    pub command: String,
+    pub arguments: Option<Vec<OsString>>,
+    pub envs: Option<HashMap<String, String>>,
+    pub cwd: Option<PathBuf>,
+    pub connection: Option<TcpArguments>,
+}
+
+pub struct AdapterVersion {
+    pub tag_name: String,
+    pub url: String,
+}
+
+pub enum DownloadedFileType {
+    Vsix,
+    GzipTar,
+    Zip,
+}
+
+pub struct GithubRepo {
+    pub repo_name: String,
+    pub repo_owner: String,
+}
+
+pub async fn download_adapter_from_github(
+    adapter_name: DebugAdapterName,
+    github_version: AdapterVersion,
+    file_type: DownloadedFileType,
+    delegate: &dyn DapDelegate,
+) -> Result<PathBuf> {
+    let adapter_path = paths::debug_adapters_dir().join(&adapter_name);
+    let version_path = adapter_path.join(format!("{}_{}", adapter_name, github_version.tag_name));
+    let fs = delegate.fs();
+
+    if version_path.exists() {
+        return Ok(version_path);
+    }
+
+    if !adapter_path.exists() {
+        fs.create_dir(&adapter_path.as_path())
+            .await
+            .context("Failed creating adapter path")?;
+    }
+
+    log::debug!(
+        "Downloading adapter {} from {}",
+        adapter_name,
+        &github_version.url,
+    );
+
+    let mut response = delegate
+        .http_client()
+        .get(&github_version.url, Default::default(), true)
+        .await
+        .context("Error downloading release")?;
+    if !response.status().is_success() {
+        Err(anyhow!(
+            "download failed with status {}",
+            response.status().to_string()
+        ))?;
+    }
+
+    match file_type {
+        DownloadedFileType::GzipTar => {
+            let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
+            let archive = Archive::new(decompressed_bytes);
+            archive.unpack(&version_path).await?;
+        }
+        DownloadedFileType::Zip | DownloadedFileType::Vsix => {
+            let zip_path = version_path.with_extension("zip");
+
+            let mut file = File::create(&zip_path).await?;
+            futures::io::copy(response.body_mut(), &mut file).await?;
+
+            // we cannot check the status as some adapter include files with names that trigger `Illegal byte sequence`
+            util::command::new_smol_command("unzip")
+                .arg(&zip_path)
+                .arg("-d")
+                .arg(&version_path)
+                .output()
+                .await?;
+
+            util::fs::remove_matching(&adapter_path, |entry| {
+                entry
+                    .file_name()
+                    .is_some_and(|file| file.to_string_lossy().ends_with(".zip"))
+            })
+            .await;
+        }
+    }
+
+    // remove older versions
+    util::fs::remove_matching(&adapter_path, |entry| {
+        entry.to_string_lossy() != version_path.to_string_lossy()
+    })
+    .await;
+
+    Ok(version_path)
+}
+
+pub async fn fetch_latest_adapter_version_from_github(
+    github_repo: GithubRepo,
+    delegate: &dyn DapDelegate,
+) -> Result<AdapterVersion> {
+    let release = latest_github_release(
+        &format!("{}/{}", github_repo.repo_owner, github_repo.repo_name),
+        false,
+        false,
+        delegate.http_client(),
+    )
+    .await?;
+
+    Ok(AdapterVersion {
+        tag_name: release.tag_name,
+        url: release.zipball_url,
+    })
+}
+
+#[async_trait(?Send)]
+pub trait DebugAdapter: 'static + Send + Sync {
+    fn name(&self) -> DebugAdapterName;
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        if delegate
+            .updated_adapters()
+            .lock()
+            .await
+            .contains(&self.name())
+        {
+            log::info!("Using cached debug adapter binary {}", self.name());
+
+            if let Some(binary) = self
+                .get_installed_binary(delegate, &config, user_installed_path.clone(), cx)
+                .await
+                .log_err()
+            {
+                return Ok(binary);
+            }
+
+            log::info!(
+                "Cached binary {} is corrupt falling back to install",
+                self.name()
+            );
+        }
+
+        log::info!("Getting latest version of debug adapter {}", self.name());
+        delegate.update_status(self.name(), DapStatus::CheckingForUpdate);
+        if let Some(version) = self.fetch_latest_adapter_version(delegate).await.log_err() {
+            log::info!(
+                "Installiing latest version of debug adapter {}",
+                self.name()
+            );
+            delegate.update_status(self.name(), DapStatus::Downloading);
+            self.install_binary(version, delegate).await?;
+
+            delegate
+                .updated_adapters()
+                .lock_arc()
+                .await
+                .insert(self.name());
+        }
+
+        self.get_installed_binary(delegate, &config, user_installed_path, cx)
+            .await
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion>;
+
+    /// Installs the binary for the debug adapter.
+    /// This method is called when the adapter binary is not found or needs to be updated.
+    /// It should download and install the necessary files for the debug adapter to function.
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()>;
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary>;
+
+    /// Should return base configuration to make the debug adapter work
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value;
+
+    /// Filters out the processes that the adapter can attach to for debugging
+    fn attach_processes<'a>(
+        &self,
+        _: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        None
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+pub struct FakeAdapter {}
+
+#[cfg(any(test, feature = "test-support"))]
+impl FakeAdapter {
+    const ADAPTER_NAME: &'static str = "fake-adapter";
+
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+#[async_trait(?Send)]
+impl DebugAdapter for FakeAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        Ok(DebugAdapterBinary {
+            command: "command".into(),
+            arguments: None,
+            connection: None,
+            envs: None,
+            cwd: None,
+        })
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        unimplemented!("fetch latest adapter version");
+    }
+
+    async fn install_binary(
+        &self,
+        _version: AdapterVersion,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        unimplemented!("install binary");
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        unimplemented!("get installed binary");
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        use serde_json::json;
+        use task::DebugRequestType;
+
+        json!({
+            "request": match config.request {
+                DebugRequestType::Launch => "launch",
+                DebugRequestType::Attach(_) => "attach",
+            },
+            "process_id": if let DebugRequestType::Attach(attach_config) = &config.request {
+                attach_config.process_id
+            } else {
+                None
+            },
+        })
+    }
+
+    fn attach_processes<'a>(
+        &self,
+        processes: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        Some(
+            processes
+                .iter()
+                .filter(|(pid, _)| pid.as_u32() == std::process::id())
+                .collect::<Vec<_>>(),
+        )
+    }
+}

crates/dap/src/client.rs

@@ -0,0 +1,485 @@
+use crate::{
+    adapters::DebugAdapterBinary,
+    transport::{IoKind, LogKind, TransportDelegate},
+};
+use anyhow::{anyhow, Result};
+use dap_types::{
+    messages::{Message, Response},
+    requests::Request,
+};
+use futures::{channel::oneshot, select, FutureExt as _};
+use gpui::{App, AsyncApp, BackgroundExecutor};
+use smol::channel::{Receiver, Sender};
+use std::{
+    hash::Hash,
+    sync::atomic::{AtomicU64, Ordering},
+    time::Duration,
+};
+
+#[cfg(any(test, feature = "test-support"))]
+const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(2);
+
+#[cfg(not(any(test, feature = "test-support")))]
+const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(12);
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct SessionId(pub u32);
+
+impl SessionId {
+    pub fn from_proto(client_id: u64) -> Self {
+        Self(client_id as u32)
+    }
+
+    pub fn to_proto(&self) -> u64 {
+        self.0 as u64
+    }
+}
+
+/// Represents a connection to the debug adapter process, either via stdout/stdin or a socket.
+pub struct DebugAdapterClient {
+    id: SessionId,
+    sequence_count: AtomicU64,
+    binary: DebugAdapterBinary,
+    executor: BackgroundExecutor,
+    transport_delegate: TransportDelegate,
+}
+
+pub type DapMessageHandler = Box<dyn FnMut(Message, &mut App) + 'static + Send + Sync>;
+
+impl DebugAdapterClient {
+    pub async fn start(
+        id: SessionId,
+        binary: DebugAdapterBinary,
+        message_handler: DapMessageHandler,
+        cx: AsyncApp,
+    ) -> Result<Self> {
+        let ((server_rx, server_tx), transport_delegate) =
+            TransportDelegate::start(&binary, cx.clone()).await?;
+        let this = Self {
+            id,
+            binary,
+            transport_delegate,
+            sequence_count: AtomicU64::new(1),
+            executor: cx.background_executor().clone(),
+        };
+        log::info!("Successfully connected to debug adapter");
+
+        let client_id = this.id;
+
+        // start handling events/reverse requests
+        cx.update(|cx| {
+            cx.spawn({
+                let server_tx = server_tx.clone();
+                |mut cx| async move {
+                    Self::handle_receive_messages(
+                        client_id,
+                        server_rx,
+                        server_tx,
+                        message_handler,
+                        &mut cx,
+                    )
+                    .await
+                }
+            })
+            .detach_and_log_err(cx);
+
+            this
+        })
+    }
+
+    pub async fn reconnect(
+        &self,
+        session_id: SessionId,
+        binary: DebugAdapterBinary,
+        message_handler: DapMessageHandler,
+        cx: AsyncApp,
+    ) -> Result<Self> {
+        let binary = match self.transport_delegate.transport() {
+            crate::transport::Transport::Tcp(tcp_transport) => DebugAdapterBinary {
+                command: binary.command,
+                arguments: binary.arguments,
+                envs: binary.envs,
+                cwd: binary.cwd,
+                connection: Some(crate::adapters::TcpArguments {
+                    host: tcp_transport.host,
+                    port: tcp_transport.port,
+                    timeout: Some(tcp_transport.timeout),
+                }),
+            },
+            _ => self.binary.clone(),
+        };
+
+        Self::start(session_id, binary, message_handler, cx).await
+    }
+
+    async fn handle_receive_messages(
+        client_id: SessionId,
+        server_rx: Receiver<Message>,
+        client_tx: Sender<Message>,
+        mut message_handler: DapMessageHandler,
+        cx: &mut AsyncApp,
+    ) -> Result<()> {
+        let result = loop {
+            let message = match server_rx.recv().await {
+                Ok(message) => message,
+                Err(e) => break Err(e.into()),
+            };
+
+            if let Err(e) = match message {
+                Message::Event(ev) => {
+                    log::debug!("Client {} received event `{}`", client_id.0, &ev);
+
+                    cx.update(|cx| message_handler(Message::Event(ev), cx))
+                }
+                Message::Request(req) => cx.update(|cx| message_handler(Message::Request(req), cx)),
+                Message::Response(response) => {
+                    log::debug!("Received response after request timeout: {:#?}", response);
+
+                    Ok(())
+                }
+            } {
+                break Err(e);
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        drop(client_tx);
+
+        log::debug!("Handle receive messages dropped");
+
+        result
+    }
+
+    /// Send a request to an adapter and get a response back
+    /// Note: This function will block until a response is sent back from the adapter
+    pub async fn request<R: Request>(&self, arguments: R::Arguments) -> Result<R::Response> {
+        let serialized_arguments = serde_json::to_value(arguments)?;
+
+        let (callback_tx, callback_rx) = oneshot::channel::<Result<Response>>();
+
+        let sequence_id = self.next_sequence_id();
+
+        let request = crate::messages::Request {
+            seq: sequence_id,
+            command: R::COMMAND.to_string(),
+            arguments: Some(serialized_arguments),
+        };
+
+        self.transport_delegate
+            .add_pending_request(sequence_id, callback_tx)
+            .await;
+
+        log::debug!(
+            "Client {} send `{}` request with sequence_id: {}",
+            self.id.0,
+            R::COMMAND.to_string(),
+            sequence_id
+        );
+
+        self.send_message(Message::Request(request)).await?;
+
+        let mut timeout = self.executor.timer(DAP_REQUEST_TIMEOUT).fuse();
+        let command = R::COMMAND.to_string();
+
+        select! {
+            response = callback_rx.fuse() => {
+                log::debug!(
+                    "Client {} received response for: `{}` sequence_id: {}",
+                    self.id.0,
+                    command,
+                    sequence_id
+                );
+
+                let response = response??;
+                match response.success {
+                    true => Ok(serde_json::from_value(response.body.unwrap_or_default())?),
+                    false => Err(anyhow!("Request failed")),
+                }
+            }
+
+            _ = timeout => {
+                self.transport_delegate.cancel_pending_request(&sequence_id).await;
+                log::error!("Cancelled DAP request for {command:?} id {sequence_id} which took over {DAP_REQUEST_TIMEOUT:?}");
+                anyhow::bail!("DAP request timeout");
+            }
+        }
+    }
+
+    pub async fn send_message(&self, message: Message) -> Result<()> {
+        self.transport_delegate.send_message(message).await
+    }
+
+    pub fn id(&self) -> SessionId {
+        self.id
+    }
+
+    pub fn binary(&self) -> &DebugAdapterBinary {
+        &self.binary
+    }
+
+    /// Get the next sequence id to be used in a request
+    pub fn next_sequence_id(&self) -> u64 {
+        self.sequence_count.fetch_add(1, Ordering::Relaxed)
+    }
+
+    pub async fn shutdown(&self) -> Result<()> {
+        self.transport_delegate.shutdown().await
+    }
+
+    pub fn has_adapter_logs(&self) -> bool {
+        self.transport_delegate.has_adapter_logs()
+    }
+
+    pub fn add_log_handler<F>(&self, f: F, kind: LogKind)
+    where
+        F: 'static + Send + FnMut(IoKind, &str),
+    {
+        self.transport_delegate.add_log_handler(f, kind);
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn on_request<R: dap_types::requests::Request, F>(&self, handler: F)
+    where
+        F: 'static
+            + Send
+            + FnMut(u64, R::Arguments) -> Result<R::Response, dap_types::ErrorResponse>,
+    {
+        let transport = self.transport_delegate.transport().as_fake();
+        transport.on_request::<R, F>(handler).await;
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn fake_reverse_request<R: dap_types::requests::Request>(&self, args: R::Arguments) {
+        self.send_message(Message::Request(dap_types::messages::Request {
+            seq: self.sequence_count.load(Ordering::Relaxed),
+            command: R::COMMAND.into(),
+            arguments: serde_json::to_value(args).ok(),
+        }))
+        .await
+        .unwrap();
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn on_response<R: dap_types::requests::Request, F>(&self, handler: F)
+    where
+        F: 'static + Send + Fn(Response),
+    {
+        let transport = self.transport_delegate.transport().as_fake();
+        transport.on_response::<R, F>(handler).await;
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub async fn fake_event(&self, event: dap_types::messages::Events) {
+        self.send_message(Message::Event(Box::new(event)))
+            .await
+            .unwrap();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{client::DebugAdapterClient, debugger_settings::DebuggerSettings};
+    use dap_types::{
+        messages::Events,
+        requests::{Initialize, Request, RunInTerminal},
+        Capabilities, InitializeRequestArguments, InitializeRequestArgumentsPathFormat,
+        RunInTerminalRequestArguments,
+    };
+    use gpui::TestAppContext;
+    use serde_json::json;
+    use settings::{Settings, SettingsStore};
+    use std::sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    };
+
+    pub fn init_test(cx: &mut gpui::TestAppContext) {
+        if std::env::var("RUST_LOG").is_ok() {
+            env_logger::try_init().ok();
+        }
+
+        cx.update(|cx| {
+            let settings = SettingsStore::test(cx);
+            cx.set_global(settings);
+            DebuggerSettings::register(cx);
+        });
+    }
+
+    #[gpui::test]
+    pub async fn test_initialize_client(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let client = DebugAdapterClient::start(
+            crate::client::SessionId(1),
+            DebugAdapterBinary {
+                command: "command".into(),
+                arguments: Default::default(),
+                envs: Default::default(),
+                connection: None,
+                cwd: None,
+            },
+            Box::new(|_, _| panic!("Did not expect to hit this code path")),
+            cx.to_async(),
+        )
+        .await
+        .unwrap();
+
+        client
+            .on_request::<Initialize, _>(move |_, _| {
+                Ok(dap_types::Capabilities {
+                    supports_configuration_done_request: Some(true),
+                    ..Default::default()
+                })
+            })
+            .await;
+
+        cx.run_until_parked();
+
+        let response = client
+            .request::<Initialize>(InitializeRequestArguments {
+                client_id: Some("zed".to_owned()),
+                client_name: Some("Zed".to_owned()),
+                adapter_id: "fake-adapter".to_owned(),
+                locale: Some("en-US".to_owned()),
+                path_format: Some(InitializeRequestArgumentsPathFormat::Path),
+                supports_variable_type: Some(true),
+                supports_variable_paging: Some(false),
+                supports_run_in_terminal_request: Some(true),
+                supports_memory_references: Some(true),
+                supports_progress_reporting: Some(false),
+                supports_invalidated_event: Some(false),
+                lines_start_at1: Some(true),
+                columns_start_at1: Some(true),
+                supports_memory_event: Some(false),
+                supports_args_can_be_interpreted_by_shell: Some(false),
+                supports_start_debugging_request: Some(true),
+            })
+            .await
+            .unwrap();
+
+        cx.run_until_parked();
+
+        assert_eq!(
+            dap_types::Capabilities {
+                supports_configuration_done_request: Some(true),
+                ..Default::default()
+            },
+            response
+        );
+
+        client.shutdown().await.unwrap();
+    }
+
+    #[gpui::test]
+    pub async fn test_calls_event_handler(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let called_event_handler = Arc::new(AtomicBool::new(false));
+
+        let client = DebugAdapterClient::start(
+            crate::client::SessionId(1),
+            DebugAdapterBinary {
+                command: "command".into(),
+                arguments: Default::default(),
+                envs: Default::default(),
+                connection: None,
+                cwd: None,
+            },
+            Box::new({
+                let called_event_handler = called_event_handler.clone();
+                move |event, _| {
+                    called_event_handler.store(true, Ordering::SeqCst);
+
+                    assert_eq!(
+                        Message::Event(Box::new(Events::Initialized(
+                            Some(Capabilities::default())
+                        ))),
+                        event
+                    );
+                }
+            }),
+            cx.to_async(),
+        )
+        .await
+        .unwrap();
+
+        cx.run_until_parked();
+
+        client
+            .fake_event(Events::Initialized(Some(Capabilities::default())))
+            .await;
+
+        cx.run_until_parked();
+
+        assert!(
+            called_event_handler.load(std::sync::atomic::Ordering::SeqCst),
+            "Event handler was not called"
+        );
+
+        client.shutdown().await.unwrap();
+    }
+
+    #[gpui::test]
+    pub async fn test_calls_event_handler_for_reverse_request(cx: &mut TestAppContext) {
+        init_test(cx);
+
+        let called_event_handler = Arc::new(AtomicBool::new(false));
+
+        let client = DebugAdapterClient::start(
+            crate::client::SessionId(1),
+            DebugAdapterBinary {
+                command: "command".into(),
+                arguments: Default::default(),
+                envs: Default::default(),
+                connection: None,
+                cwd: None,
+            },
+            Box::new({
+                let called_event_handler = called_event_handler.clone();
+                move |event, _| {
+                    called_event_handler.store(true, Ordering::SeqCst);
+
+                    assert_eq!(
+                        Message::Request(dap_types::messages::Request {
+                            seq: 1,
+                            command: RunInTerminal::COMMAND.into(),
+                            arguments: Some(json!({
+                                "cwd": "/project/path/src",
+                                "args": ["node", "test.js"],
+                            }))
+                        }),
+                        event
+                    );
+                }
+            }),
+            cx.to_async(),
+        )
+        .await
+        .unwrap();
+
+        cx.run_until_parked();
+
+        client
+            .fake_reverse_request::<RunInTerminal>(RunInTerminalRequestArguments {
+                kind: None,
+                title: None,
+                cwd: "/project/path/src".into(),
+                args: vec!["node".into(), "test.js".into()],
+                env: None,
+                args_can_be_interpreted_by_shell: None,
+            })
+            .await;
+
+        cx.run_until_parked();
+
+        assert!(
+            called_event_handler.load(std::sync::atomic::Ordering::SeqCst),
+            "Event handler was not called"
+        );
+
+        client.shutdown().await.unwrap();
+    }
+}

crates/dap/src/debugger_settings.rs

@@ -0,0 +1,59 @@
+use dap_types::SteppingGranularity;
+use gpui::{App, Global};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use settings::{Settings, SettingsSources};
+
+#[derive(Serialize, Deserialize, JsonSchema, Clone, Copy)]
+#[serde(default)]
+pub struct DebuggerSettings {
+    /// Determines the stepping granularity.
+    ///
+    /// Default: line
+    pub stepping_granularity: SteppingGranularity,
+    /// Whether the breakpoints should be reused across Zed sessions.
+    ///
+    /// Default: true
+    pub save_breakpoints: bool,
+    /// Whether to show the debug button in the status bar.
+    ///
+    /// Default: true
+    pub button: bool,
+    /// Time in milliseconds until timeout error when connecting to a TCP debug adapter
+    ///
+    /// Default: 2000ms
+    pub timeout: u64,
+    /// Whether to log messages between active debug adapters and Zed
+    ///
+    /// Default: true
+    pub log_dap_communications: bool,
+    /// Whether to format dap messages in when adding them to debug adapter logger
+    ///
+    /// Default: true
+    pub format_dap_log_messages: bool,
+}
+
+impl Default for DebuggerSettings {
+    fn default() -> Self {
+        Self {
+            button: true,
+            save_breakpoints: true,
+            stepping_granularity: SteppingGranularity::Line,
+            timeout: 2000,
+            log_dap_communications: true,
+            format_dap_log_messages: true,
+        }
+    }
+}
+
+impl Settings for DebuggerSettings {
+    const KEY: Option<&'static str> = Some("debugger");
+
+    type FileContent = Self;
+
+    fn load(sources: SettingsSources<Self::FileContent>, _: &mut App) -> anyhow::Result<Self> {
+        sources.json_merge()
+    }
+}
+
+impl Global for DebuggerSettings {}

crates/dap/src/lib.rs

@@ -0,0 +1,28 @@
+pub mod adapters;
+pub mod client;
+pub mod debugger_settings;
+pub mod proto_conversions;
+pub mod transport;
+
+pub use dap_types::*;
+pub use task::{DebugAdapterConfig, DebugAdapterKind, DebugRequestType};
+
+pub type ScopeId = u64;
+pub type VariableReference = u64;
+pub type StackFrameId = u64;
+
+#[cfg(any(test, feature = "test-support"))]
+pub use adapters::FakeAdapter;
+
+#[cfg(any(test, feature = "test-support"))]
+pub fn test_config() -> DebugAdapterConfig {
+    DebugAdapterConfig {
+        label: "test config".into(),
+        kind: DebugAdapterKind::Fake,
+        request: DebugRequestType::Launch,
+        program: None,
+        supports_attach: false,
+        cwd: None,
+        initialize_args: None,
+    }
+}

crates/dap/src/proto_conversions.rs

@@ -0,0 +1,638 @@
+use anyhow::{anyhow, Result};
+use client::proto::{
+    self, DapChecksum, DapChecksumAlgorithm, DapEvaluateContext, DapModule, DapScope,
+    DapScopePresentationHint, DapSource, DapSourcePresentationHint, DapStackFrame, DapVariable,
+    SetDebugClientCapabilities,
+};
+use dap_types::{
+    Capabilities, OutputEventCategory, OutputEventGroup, ScopePresentationHint, Source,
+};
+
+pub trait ProtoConversion {
+    type ProtoType;
+    type Output;
+
+    fn to_proto(&self) -> Self::ProtoType;
+    fn from_proto(payload: Self::ProtoType) -> Self::Output;
+}
+
+impl<T> ProtoConversion for Vec<T>
+where
+    T: ProtoConversion<Output = T>,
+{
+    type ProtoType = Vec<T::ProtoType>;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        self.iter().map(|item| item.to_proto()).collect()
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        payload
+            .into_iter()
+            .map(|item| T::from_proto(item))
+            .collect()
+    }
+}
+
+impl ProtoConversion for dap_types::Scope {
+    type ProtoType = DapScope;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            name: self.name.clone(),
+            presentation_hint: self
+                .presentation_hint
+                .as_ref()
+                .map(|hint| hint.to_proto().into()),
+            variables_reference: self.variables_reference,
+            named_variables: self.named_variables,
+            indexed_variables: self.indexed_variables,
+            expensive: self.expensive,
+            source: self.source.as_ref().map(Source::to_proto),
+            line: self.line,
+            end_line: self.end_line,
+            column: self.column,
+            end_column: self.end_column,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        let presentation_hint = payload
+            .presentation_hint
+            .and_then(DapScopePresentationHint::from_i32);
+        Self {
+            name: payload.name,
+            presentation_hint: presentation_hint.map(ScopePresentationHint::from_proto),
+            variables_reference: payload.variables_reference,
+            named_variables: payload.named_variables,
+            indexed_variables: payload.indexed_variables,
+            expensive: payload.expensive,
+            source: payload.source.map(dap_types::Source::from_proto),
+            line: payload.line,
+            end_line: payload.end_line,
+            column: payload.column,
+            end_column: payload.end_column,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Variable {
+    type ProtoType = DapVariable;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            name: self.name.clone(),
+            value: self.value.clone(),
+            r#type: self.type_.clone(),
+            evaluate_name: self.evaluate_name.clone(),
+            variables_reference: self.variables_reference,
+            named_variables: self.named_variables,
+            indexed_variables: self.indexed_variables,
+            memory_reference: self.memory_reference.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            name: payload.name,
+            value: payload.value,
+            type_: payload.r#type,
+            evaluate_name: payload.evaluate_name,
+            presentation_hint: None, // TODO Debugger Collab Add this
+            variables_reference: payload.variables_reference,
+            named_variables: payload.named_variables,
+            indexed_variables: payload.indexed_variables,
+            memory_reference: payload.memory_reference,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::ScopePresentationHint {
+    type ProtoType = DapScopePresentationHint;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::ScopePresentationHint::Locals => DapScopePresentationHint::Locals,
+            dap_types::ScopePresentationHint::Arguments => DapScopePresentationHint::Arguments,
+            dap_types::ScopePresentationHint::Registers => DapScopePresentationHint::Registers,
+            dap_types::ScopePresentationHint::ReturnValue => DapScopePresentationHint::ReturnValue,
+            dap_types::ScopePresentationHint::Unknown => DapScopePresentationHint::ScopeUnknown,
+            &_ => unreachable!(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            DapScopePresentationHint::Locals => dap_types::ScopePresentationHint::Locals,
+            DapScopePresentationHint::Arguments => dap_types::ScopePresentationHint::Arguments,
+            DapScopePresentationHint::Registers => dap_types::ScopePresentationHint::Registers,
+            DapScopePresentationHint::ReturnValue => dap_types::ScopePresentationHint::ReturnValue,
+            DapScopePresentationHint::ScopeUnknown => dap_types::ScopePresentationHint::Unknown,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::SourcePresentationHint {
+    type ProtoType = DapSourcePresentationHint;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::SourcePresentationHint::Normal => DapSourcePresentationHint::SourceNormal,
+            dap_types::SourcePresentationHint::Emphasize => DapSourcePresentationHint::Emphasize,
+            dap_types::SourcePresentationHint::Deemphasize => {
+                DapSourcePresentationHint::Deemphasize
+            }
+            dap_types::SourcePresentationHint::Unknown => DapSourcePresentationHint::SourceUnknown,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            DapSourcePresentationHint::SourceNormal => dap_types::SourcePresentationHint::Normal,
+            DapSourcePresentationHint::Emphasize => dap_types::SourcePresentationHint::Emphasize,
+            DapSourcePresentationHint::Deemphasize => {
+                dap_types::SourcePresentationHint::Deemphasize
+            }
+            DapSourcePresentationHint::SourceUnknown => dap_types::SourcePresentationHint::Unknown,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Checksum {
+    type ProtoType = DapChecksum;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        DapChecksum {
+            algorithm: self.algorithm.to_proto().into(),
+            checksum: self.checksum.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            algorithm: dap_types::ChecksumAlgorithm::from_proto(payload.algorithm()),
+            checksum: payload.checksum,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::ChecksumAlgorithm {
+    type ProtoType = DapChecksumAlgorithm;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::ChecksumAlgorithm::Md5 => DapChecksumAlgorithm::Md5,
+            dap_types::ChecksumAlgorithm::Sha1 => DapChecksumAlgorithm::Sha1,
+            dap_types::ChecksumAlgorithm::Sha256 => DapChecksumAlgorithm::Sha256,
+            dap_types::ChecksumAlgorithm::Timestamp => DapChecksumAlgorithm::Timestamp,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            DapChecksumAlgorithm::Md5 => dap_types::ChecksumAlgorithm::Md5,
+            DapChecksumAlgorithm::Sha1 => dap_types::ChecksumAlgorithm::Sha1,
+            DapChecksumAlgorithm::Sha256 => dap_types::ChecksumAlgorithm::Sha256,
+            DapChecksumAlgorithm::Timestamp => dap_types::ChecksumAlgorithm::Timestamp,
+            DapChecksumAlgorithm::ChecksumAlgorithmUnspecified => unreachable!(),
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Source {
+    type ProtoType = DapSource;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            name: self.name.clone(),
+            path: self.path.clone(),
+            source_reference: self.source_reference,
+            presentation_hint: self.presentation_hint.map(|hint| hint.to_proto().into()),
+            origin: self.origin.clone(),
+            sources: self
+                .sources
+                .clone()
+                .map(|src| src.to_proto())
+                .unwrap_or_default(),
+            adapter_data: Default::default(), // TODO Debugger Collab
+            checksums: self
+                .checksums
+                .clone()
+                .map(|c| c.to_proto())
+                .unwrap_or_default(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            name: payload.name.clone(),
+            path: payload.path.clone(),
+            source_reference: payload.source_reference,
+            presentation_hint: payload
+                .presentation_hint
+                .and_then(DapSourcePresentationHint::from_i32)
+                .map(dap_types::SourcePresentationHint::from_proto),
+            origin: payload.origin.clone(),
+            sources: Some(Vec::<dap_types::Source>::from_proto(payload.sources)),
+            checksums: Some(Vec::<dap_types::Checksum>::from_proto(payload.checksums)),
+            adapter_data: None, // TODO Debugger Collab
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::StackFrame {
+    type ProtoType = DapStackFrame;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        Self::ProtoType {
+            id: self.id,
+            name: self.name.clone(),
+            source: self.source.as_ref().map(|src| src.to_proto()),
+            line: self.line,
+            column: self.column,
+            end_line: self.end_line,
+            end_column: self.end_column,
+            can_restart: self.can_restart,
+            instruction_pointer_reference: self.instruction_pointer_reference.clone(),
+            module_id: None,         // TODO Debugger Collab
+            presentation_hint: None, // TODO Debugger Collab
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            id: payload.id,
+            name: payload.name,
+            source: payload.source.map(dap_types::Source::from_proto),
+            line: payload.line,
+            column: payload.column,
+            end_line: payload.end_line,
+            end_column: payload.end_column,
+            can_restart: payload.can_restart,
+            instruction_pointer_reference: payload.instruction_pointer_reference,
+            module_id: None,         // TODO Debugger Collab
+            presentation_hint: None, // TODO Debugger Collab
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Module {
+    type ProtoType = DapModule;
+    type Output = Result<Self>;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        let id = match &self.id {
+            dap_types::ModuleId::Number(num) => proto::dap_module_id::Id::Number(*num),
+            dap_types::ModuleId::String(string) => proto::dap_module_id::Id::String(string.clone()),
+        };
+
+        DapModule {
+            id: Some(proto::DapModuleId { id: Some(id) }),
+            name: self.name.clone(),
+            path: self.path.clone(),
+            is_optimized: self.is_optimized,
+            is_user_code: self.is_user_code,
+            version: self.version.clone(),
+            symbol_status: self.symbol_status.clone(),
+            symbol_file_path: self.symbol_file_path.clone(),
+            date_time_stamp: self.date_time_stamp.clone(),
+            address_range: self.address_range.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Result<Self> {
+        let id = match payload
+            .id
+            .ok_or(anyhow!("All DapModule proto messages must have an id"))?
+            .id
+            .ok_or(anyhow!("All DapModuleID proto messages must have an id"))?
+        {
+            proto::dap_module_id::Id::String(string) => dap_types::ModuleId::String(string),
+            proto::dap_module_id::Id::Number(num) => dap_types::ModuleId::Number(num),
+        };
+
+        Ok(Self {
+            id,
+            name: payload.name,
+            path: payload.path,
+            is_optimized: payload.is_optimized,
+            is_user_code: payload.is_user_code,
+            version: payload.version,
+            symbol_status: payload.symbol_status,
+            symbol_file_path: payload.symbol_file_path,
+            date_time_stamp: payload.date_time_stamp,
+            address_range: payload.address_range,
+        })
+    }
+}
+
+pub fn capabilities_from_proto(payload: &SetDebugClientCapabilities) -> Capabilities {
+    Capabilities {
+        supports_loaded_sources_request: Some(payload.supports_loaded_sources_request),
+        supports_modules_request: Some(payload.supports_modules_request),
+        supports_restart_request: Some(payload.supports_restart_request),
+        supports_set_expression: Some(payload.supports_set_expression),
+        supports_single_thread_execution_requests: Some(
+            payload.supports_single_thread_execution_requests,
+        ),
+        supports_step_back: Some(payload.supports_step_back),
+        supports_stepping_granularity: Some(payload.supports_stepping_granularity),
+        supports_terminate_threads_request: Some(payload.supports_terminate_threads_request),
+        supports_restart_frame: Some(payload.supports_restart_frame_request),
+        supports_clipboard_context: Some(payload.supports_clipboard_context),
+        ..Default::default()
+    }
+}
+
+pub fn capabilities_to_proto(
+    capabilities: &Capabilities,
+    project_id: u64,
+    session_id: u64,
+) -> SetDebugClientCapabilities {
+    SetDebugClientCapabilities {
+        session_id,
+        project_id,
+        supports_loaded_sources_request: capabilities
+            .supports_loaded_sources_request
+            .unwrap_or_default(),
+        supports_modules_request: capabilities.supports_modules_request.unwrap_or_default(),
+        supports_restart_request: capabilities.supports_restart_request.unwrap_or_default(),
+        supports_set_expression: capabilities.supports_set_expression.unwrap_or_default(),
+        supports_single_thread_execution_requests: capabilities
+            .supports_single_thread_execution_requests
+            .unwrap_or_default(),
+        supports_step_back: capabilities.supports_step_back.unwrap_or_default(),
+        supports_stepping_granularity: capabilities
+            .supports_stepping_granularity
+            .unwrap_or_default(),
+        supports_terminate_threads_request: capabilities
+            .supports_terminate_threads_request
+            .unwrap_or_default(),
+        supports_restart_frame_request: capabilities.supports_restart_frame.unwrap_or_default(),
+        supports_clipboard_context: capabilities.supports_clipboard_context.unwrap_or_default(),
+    }
+}
+
+impl ProtoConversion for dap_types::SteppingGranularity {
+    type ProtoType = proto::SteppingGranularity;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::SteppingGranularity::Statement => proto::SteppingGranularity::Statement,
+            dap_types::SteppingGranularity::Line => proto::SteppingGranularity::Line,
+            dap_types::SteppingGranularity::Instruction => proto::SteppingGranularity::Instruction,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::SteppingGranularity::Line => dap_types::SteppingGranularity::Line,
+            proto::SteppingGranularity::Instruction => dap_types::SteppingGranularity::Instruction,
+            proto::SteppingGranularity::Statement => dap_types::SteppingGranularity::Statement,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::OutputEventCategory {
+    type ProtoType = proto::DapOutputCategory;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            Self::Console => proto::DapOutputCategory::ConsoleOutput,
+            Self::Important => proto::DapOutputCategory::Important,
+            Self::Stdout => proto::DapOutputCategory::Stdout,
+            Self::Stderr => proto::DapOutputCategory::Stderr,
+            _ => proto::DapOutputCategory::Unknown,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapOutputCategory::ConsoleOutput => Self::Console,
+            proto::DapOutputCategory::Important => Self::Important,
+            proto::DapOutputCategory::Stdout => Self::Stdout,
+            proto::DapOutputCategory::Stderr => Self::Stderr,
+            proto::DapOutputCategory::Unknown => Self::Unknown,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::OutputEvent {
+    type ProtoType = proto::DapOutputEvent;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        proto::DapOutputEvent {
+            category: self
+                .category
+                .as_ref()
+                .map(|category| category.to_proto().into()),
+            output: self.output.clone(),
+            variables_reference: self.variables_reference,
+            source: self.source.as_ref().map(|source| source.to_proto()),
+            line: self.line.map(|line| line as u32),
+            column: self.column.map(|column| column as u32),
+            group: self.group.map(|group| group.to_proto().into()),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        dap_types::OutputEvent {
+            category: payload
+                .category
+                .and_then(proto::DapOutputCategory::from_i32)
+                .map(OutputEventCategory::from_proto),
+            output: payload.output.clone(),
+            variables_reference: payload.variables_reference,
+            source: payload.source.map(Source::from_proto),
+            line: payload.line.map(|line| line as u64),
+            column: payload.column.map(|column| column as u64),
+            group: payload
+                .group
+                .and_then(proto::DapOutputEventGroup::from_i32)
+                .map(OutputEventGroup::from_proto),
+            data: None,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::OutputEventGroup {
+    type ProtoType = proto::DapOutputEventGroup;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::OutputEventGroup::Start => proto::DapOutputEventGroup::Start,
+            dap_types::OutputEventGroup::StartCollapsed => {
+                proto::DapOutputEventGroup::StartCollapsed
+            }
+            dap_types::OutputEventGroup::End => proto::DapOutputEventGroup::End,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapOutputEventGroup::Start => Self::Start,
+            proto::DapOutputEventGroup::StartCollapsed => Self::StartCollapsed,
+            proto::DapOutputEventGroup::End => Self::End,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::CompletionItem {
+    type ProtoType = proto::DapCompletionItem;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        proto::DapCompletionItem {
+            label: self.label.clone(),
+            text: self.text.clone(),
+            detail: self.detail.clone(),
+            typ: self
+                .type_
+                .as_ref()
+                .map(ProtoConversion::to_proto)
+                .map(|typ| typ.into()),
+            start: self.start,
+            length: self.length,
+            selection_start: self.selection_start,
+            selection_length: self.selection_length,
+            sort_text: self.sort_text.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        let typ = payload.typ(); // todo(debugger): This might be a potential issue/bug because it defaults to a type when it's None
+
+        Self {
+            label: payload.label,
+            detail: payload.detail,
+            sort_text: payload.sort_text,
+            text: payload.text.clone(),
+            type_: Some(dap_types::CompletionItemType::from_proto(typ)),
+            start: payload.start,
+            length: payload.length,
+            selection_start: payload.selection_start,
+            selection_length: payload.selection_length,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::EvaluateArgumentsContext {
+    type ProtoType = DapEvaluateContext;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::EvaluateArgumentsContext::Variables => {
+                proto::DapEvaluateContext::EvaluateVariables
+            }
+            dap_types::EvaluateArgumentsContext::Watch => proto::DapEvaluateContext::Watch,
+            dap_types::EvaluateArgumentsContext::Hover => proto::DapEvaluateContext::Hover,
+            dap_types::EvaluateArgumentsContext::Repl => proto::DapEvaluateContext::Repl,
+            dap_types::EvaluateArgumentsContext::Clipboard => proto::DapEvaluateContext::Clipboard,
+            dap_types::EvaluateArgumentsContext::Unknown => {
+                proto::DapEvaluateContext::EvaluateUnknown
+            }
+            _ => proto::DapEvaluateContext::EvaluateUnknown,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapEvaluateContext::EvaluateVariables => {
+                dap_types::EvaluateArgumentsContext::Variables
+            }
+            proto::DapEvaluateContext::Watch => dap_types::EvaluateArgumentsContext::Watch,
+            proto::DapEvaluateContext::Hover => dap_types::EvaluateArgumentsContext::Hover,
+            proto::DapEvaluateContext::Repl => dap_types::EvaluateArgumentsContext::Repl,
+            proto::DapEvaluateContext::Clipboard => dap_types::EvaluateArgumentsContext::Clipboard,
+            proto::DapEvaluateContext::EvaluateUnknown => {
+                dap_types::EvaluateArgumentsContext::Unknown
+            }
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::CompletionItemType {
+    type ProtoType = proto::DapCompletionItemType;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        match self {
+            dap_types::CompletionItemType::Class => proto::DapCompletionItemType::Class,
+            dap_types::CompletionItemType::Color => proto::DapCompletionItemType::Color,
+            dap_types::CompletionItemType::Constructor => proto::DapCompletionItemType::Constructor,
+            dap_types::CompletionItemType::Customcolor => proto::DapCompletionItemType::Customcolor,
+            dap_types::CompletionItemType::Enum => proto::DapCompletionItemType::Enum,
+            dap_types::CompletionItemType::Field => proto::DapCompletionItemType::Field,
+            dap_types::CompletionItemType::File => proto::DapCompletionItemType::CompletionItemFile,
+            dap_types::CompletionItemType::Function => proto::DapCompletionItemType::Function,
+            dap_types::CompletionItemType::Interface => proto::DapCompletionItemType::Interface,
+            dap_types::CompletionItemType::Keyword => proto::DapCompletionItemType::Keyword,
+            dap_types::CompletionItemType::Method => proto::DapCompletionItemType::Method,
+            dap_types::CompletionItemType::Module => proto::DapCompletionItemType::Module,
+            dap_types::CompletionItemType::Property => proto::DapCompletionItemType::Property,
+            dap_types::CompletionItemType::Reference => proto::DapCompletionItemType::Reference,
+            dap_types::CompletionItemType::Snippet => proto::DapCompletionItemType::Snippet,
+            dap_types::CompletionItemType::Text => proto::DapCompletionItemType::Text,
+            dap_types::CompletionItemType::Unit => proto::DapCompletionItemType::Unit,
+            dap_types::CompletionItemType::Value => proto::DapCompletionItemType::Value,
+            dap_types::CompletionItemType::Variable => proto::DapCompletionItemType::Variable,
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        match payload {
+            proto::DapCompletionItemType::Class => dap_types::CompletionItemType::Class,
+            proto::DapCompletionItemType::Color => dap_types::CompletionItemType::Color,
+            proto::DapCompletionItemType::CompletionItemFile => dap_types::CompletionItemType::File,
+            proto::DapCompletionItemType::Constructor => dap_types::CompletionItemType::Constructor,
+            proto::DapCompletionItemType::Customcolor => dap_types::CompletionItemType::Customcolor,
+            proto::DapCompletionItemType::Enum => dap_types::CompletionItemType::Enum,
+            proto::DapCompletionItemType::Field => dap_types::CompletionItemType::Field,
+            proto::DapCompletionItemType::Function => dap_types::CompletionItemType::Function,
+            proto::DapCompletionItemType::Interface => dap_types::CompletionItemType::Interface,
+            proto::DapCompletionItemType::Keyword => dap_types::CompletionItemType::Keyword,
+            proto::DapCompletionItemType::Method => dap_types::CompletionItemType::Method,
+            proto::DapCompletionItemType::Module => dap_types::CompletionItemType::Module,
+            proto::DapCompletionItemType::Property => dap_types::CompletionItemType::Property,
+            proto::DapCompletionItemType::Reference => dap_types::CompletionItemType::Reference,
+            proto::DapCompletionItemType::Snippet => dap_types::CompletionItemType::Snippet,
+            proto::DapCompletionItemType::Text => dap_types::CompletionItemType::Text,
+            proto::DapCompletionItemType::Unit => dap_types::CompletionItemType::Unit,
+            proto::DapCompletionItemType::Value => dap_types::CompletionItemType::Value,
+            proto::DapCompletionItemType::Variable => dap_types::CompletionItemType::Variable,
+        }
+    }
+}
+
+impl ProtoConversion for dap_types::Thread {
+    type ProtoType = proto::DapThread;
+    type Output = Self;
+
+    fn to_proto(&self) -> Self::ProtoType {
+        proto::DapThread {
+            id: self.id,
+            name: self.name.clone(),
+        }
+    }
+
+    fn from_proto(payload: Self::ProtoType) -> Self {
+        Self {
+            id: payload.id,
+            name: payload.name,
+        }
+    }
+}

crates/dap/src/transport.rs

@@ -0,0 +1,882 @@
+use anyhow::{anyhow, Context, Result};
+use dap_types::{
+    messages::{Message, Response},
+    ErrorResponse,
+};
+use futures::{channel::oneshot, select, AsyncRead, AsyncReadExt as _, AsyncWrite, FutureExt as _};
+use gpui::AsyncApp;
+use settings::Settings as _;
+use smallvec::SmallVec;
+use smol::{
+    channel::{unbounded, Receiver, Sender},
+    io::{AsyncBufReadExt as _, AsyncWriteExt, BufReader},
+    lock::Mutex,
+    net::{TcpListener, TcpStream},
+    process::Child,
+};
+use std::{
+    collections::HashMap,
+    net::{Ipv4Addr, SocketAddrV4},
+    process::Stdio,
+    sync::Arc,
+    time::Duration,
+};
+use task::TCPHost;
+use util::ResultExt as _;
+
+use crate::{adapters::DebugAdapterBinary, debugger_settings::DebuggerSettings};
+
+pub type IoHandler = Box<dyn Send + FnMut(IoKind, &str)>;
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub enum LogKind {
+    Adapter,
+    Rpc,
+}
+
+pub enum IoKind {
+    StdIn,
+    StdOut,
+    StdErr,
+}
+
+pub struct TransportPipe {
+    input: Box<dyn AsyncWrite + Unpin + Send + 'static>,
+    output: Box<dyn AsyncRead + Unpin + Send + 'static>,
+    stdout: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+    stderr: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+}
+
+impl TransportPipe {
+    pub fn new(
+        input: Box<dyn AsyncWrite + Unpin + Send + 'static>,
+        output: Box<dyn AsyncRead + Unpin + Send + 'static>,
+        stdout: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+        stderr: Option<Box<dyn AsyncRead + Unpin + Send + 'static>>,
+    ) -> Self {
+        TransportPipe {
+            input,
+            output,
+            stdout,
+            stderr,
+        }
+    }
+}
+
+type Requests = Arc<Mutex<HashMap<u64, oneshot::Sender<Result<Response>>>>>;
+type LogHandlers = Arc<parking_lot::Mutex<SmallVec<[(LogKind, IoHandler); 2]>>>;
+
+pub enum Transport {
+    Stdio(StdioTransport),
+    Tcp(TcpTransport),
+    #[cfg(any(test, feature = "test-support"))]
+    Fake(FakeTransport),
+}
+
+impl Transport {
+    async fn start(binary: &DebugAdapterBinary, cx: AsyncApp) -> Result<(TransportPipe, Self)> {
+        #[cfg(any(test, feature = "test-support"))]
+        return FakeTransport::start(cx)
+            .await
+            .map(|(transports, fake)| (transports, Self::Fake(fake)));
+
+        if binary.connection.is_some() {
+            TcpTransport::start(binary, cx)
+                .await
+                .map(|(transports, tcp)| (transports, Self::Tcp(tcp)))
+        } else {
+            StdioTransport::start(binary, cx)
+                .await
+                .map(|(transports, stdio)| (transports, Self::Stdio(stdio)))
+        }
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        match self {
+            Transport::Stdio(stdio_transport) => stdio_transport.has_adapter_logs(),
+            Transport::Tcp(tcp_transport) => tcp_transport.has_adapter_logs(),
+            #[cfg(any(test, feature = "test-support"))]
+            Transport::Fake(fake_transport) => fake_transport.has_adapter_logs(),
+        }
+    }
+
+    async fn kill(&self) -> Result<()> {
+        match self {
+            Transport::Stdio(stdio_transport) => stdio_transport.kill().await,
+            Transport::Tcp(tcp_transport) => tcp_transport.kill().await,
+            #[cfg(any(test, feature = "test-support"))]
+            Transport::Fake(fake_transport) => fake_transport.kill().await,
+        }
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub(crate) fn as_fake(&self) -> &FakeTransport {
+        match self {
+            Transport::Fake(fake_transport) => fake_transport,
+            _ => panic!("Not a fake transport layer"),
+        }
+    }
+}
+
+pub(crate) struct TransportDelegate {
+    log_handlers: LogHandlers,
+    current_requests: Requests,
+    pending_requests: Requests,
+    transport: Transport,
+    server_tx: Arc<Mutex<Option<Sender<Message>>>>,
+}
+
+impl TransportDelegate {
+    pub(crate) async fn start(
+        binary: &DebugAdapterBinary,
+        cx: AsyncApp,
+    ) -> Result<((Receiver<Message>, Sender<Message>), Self)> {
+        let (transport_pipes, transport) = Transport::start(binary, cx.clone()).await?;
+        let mut this = Self {
+            transport,
+            server_tx: Default::default(),
+            log_handlers: Default::default(),
+            current_requests: Default::default(),
+            pending_requests: Default::default(),
+        };
+        let messages = this.start_handlers(transport_pipes, cx).await?;
+        Ok((messages, this))
+    }
+
+    async fn start_handlers(
+        &mut self,
+        mut params: TransportPipe,
+        cx: AsyncApp,
+    ) -> Result<(Receiver<Message>, Sender<Message>)> {
+        let (client_tx, server_rx) = unbounded::<Message>();
+        let (server_tx, client_rx) = unbounded::<Message>();
+
+        let log_dap_communications =
+            cx.update(|cx| DebuggerSettings::get_global(cx).log_dap_communications)
+                .with_context(|| "Failed to get Debugger Setting log dap communications error in transport::start_handlers. Defaulting to false")
+                .unwrap_or(false);
+
+        let log_handler = if log_dap_communications {
+            Some(self.log_handlers.clone())
+        } else {
+            None
+        };
+
+        cx.update(|cx| {
+            if let Some(stdout) = params.stdout.take() {
+                cx.background_executor()
+                    .spawn(Self::handle_adapter_log(stdout, log_handler.clone()))
+                    .detach_and_log_err(cx);
+            }
+
+            cx.background_executor()
+                .spawn(Self::handle_output(
+                    params.output,
+                    client_tx,
+                    self.pending_requests.clone(),
+                    log_handler.clone(),
+                ))
+                .detach_and_log_err(cx);
+
+            if let Some(stderr) = params.stderr.take() {
+                cx.background_executor()
+                    .spawn(Self::handle_error(stderr, self.log_handlers.clone()))
+                    .detach_and_log_err(cx);
+            }
+
+            cx.background_executor()
+                .spawn(Self::handle_input(
+                    params.input,
+                    client_rx,
+                    self.current_requests.clone(),
+                    self.pending_requests.clone(),
+                    log_handler.clone(),
+                ))
+                .detach_and_log_err(cx);
+        })?;
+
+        {
+            let mut lock = self.server_tx.lock().await;
+            *lock = Some(server_tx.clone());
+        }
+
+        Ok((server_rx, server_tx))
+    }
+
+    pub(crate) async fn add_pending_request(
+        &self,
+        sequence_id: u64,
+        request: oneshot::Sender<Result<Response>>,
+    ) {
+        let mut pending_requests = self.pending_requests.lock().await;
+        pending_requests.insert(sequence_id, request);
+    }
+
+    pub(crate) async fn cancel_pending_request(&self, sequence_id: &u64) {
+        let mut pending_requests = self.pending_requests.lock().await;
+        pending_requests.remove(sequence_id);
+    }
+
+    pub(crate) async fn send_message(&self, message: Message) -> Result<()> {
+        if let Some(server_tx) = self.server_tx.lock().await.as_ref() {
+            server_tx
+                .send(message)
+                .await
+                .map_err(|e| anyhow!("Failed to send message: {}", e))
+        } else {
+            Err(anyhow!("Server tx already dropped"))
+        }
+    }
+
+    async fn handle_adapter_log<Stdout>(
+        stdout: Stdout,
+        log_handlers: Option<LogHandlers>,
+    ) -> Result<()>
+    where
+        Stdout: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut reader = BufReader::new(stdout);
+        let mut line = String::new();
+
+        let result = loop {
+            line.truncate(0);
+
+            let bytes_read = match reader.read_line(&mut line).await {
+                Ok(bytes_read) => bytes_read,
+                Err(e) => break Err(e.into()),
+            };
+
+            if bytes_read == 0 {
+                break Err(anyhow!("Debugger log stream closed"));
+            }
+
+            if let Some(log_handlers) = log_handlers.as_ref() {
+                for (kind, handler) in log_handlers.lock().iter_mut() {
+                    if matches!(kind, LogKind::Adapter) {
+                        handler(IoKind::StdOut, line.as_str());
+                    }
+                }
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        log::debug!("Handle adapter log dropped");
+
+        result
+    }
+
+    fn build_rpc_message(message: String) -> String {
+        format!("Content-Length: {}\r\n\r\n{}", message.len(), message)
+    }
+
+    async fn handle_input<Stdin>(
+        mut server_stdin: Stdin,
+        client_rx: Receiver<Message>,
+        current_requests: Requests,
+        pending_requests: Requests,
+        log_handlers: Option<LogHandlers>,
+    ) -> Result<()>
+    where
+        Stdin: AsyncWrite + Unpin + Send + 'static,
+    {
+        let result = loop {
+            match client_rx.recv().await {
+                Ok(message) => {
+                    if let Message::Request(request) = &message {
+                        if let Some(sender) = current_requests.lock().await.remove(&request.seq) {
+                            pending_requests.lock().await.insert(request.seq, sender);
+                        }
+                    }
+
+                    let message = match serde_json::to_string(&message) {
+                        Ok(message) => message,
+                        Err(e) => break Err(e.into()),
+                    };
+
+                    if let Some(log_handlers) = log_handlers.as_ref() {
+                        for (kind, log_handler) in log_handlers.lock().iter_mut() {
+                            if matches!(kind, LogKind::Rpc) {
+                                log_handler(IoKind::StdIn, &message);
+                            }
+                        }
+                    }
+
+                    if let Err(e) = server_stdin
+                        .write_all(Self::build_rpc_message(message).as_bytes())
+                        .await
+                    {
+                        break Err(e.into());
+                    }
+
+                    if let Err(e) = server_stdin.flush().await {
+                        break Err(e.into());
+                    }
+                }
+                Err(error) => break Err(error.into()),
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        log::debug!("Handle adapter input dropped");
+
+        result
+    }
+
+    async fn handle_output<Stdout>(
+        server_stdout: Stdout,
+        client_tx: Sender<Message>,
+        pending_requests: Requests,
+        log_handlers: Option<LogHandlers>,
+    ) -> Result<()>
+    where
+        Stdout: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut recv_buffer = String::new();
+        let mut reader = BufReader::new(server_stdout);
+
+        let result = loop {
+            let message =
+                Self::receive_server_message(&mut reader, &mut recv_buffer, log_handlers.as_ref())
+                    .await;
+
+            match message {
+                Ok(Message::Response(res)) => {
+                    if let Some(tx) = pending_requests.lock().await.remove(&res.request_seq) {
+                        if let Err(e) = tx.send(Self::process_response(res)) {
+                            break Err(anyhow!("Failed to send response: {:?}", e));
+                        }
+                    } else {
+                        client_tx.send(Message::Response(res)).await?;
+                    };
+                }
+                Ok(message) => {
+                    client_tx.send(message).await?;
+                }
+                Err(e) => break Err(e),
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        drop(client_tx);
+
+        log::debug!("Handle adapter output dropped");
+
+        result
+    }
+
+    async fn handle_error<Stderr>(stderr: Stderr, log_handlers: LogHandlers) -> Result<()>
+    where
+        Stderr: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut buffer = String::new();
+
+        let mut reader = BufReader::new(stderr);
+
+        let result = loop {
+            match reader.read_line(&mut buffer).await {
+                Ok(0) => break Err(anyhow!("debugger error stream closed")),
+                Ok(_) => {
+                    for (kind, log_handler) in log_handlers.lock().iter_mut() {
+                        if matches!(kind, LogKind::Adapter) {
+                            log_handler(IoKind::StdErr, buffer.as_str());
+                        }
+                    }
+
+                    buffer.truncate(0);
+                }
+                Err(error) => break Err(error.into()),
+            }
+
+            smol::future::yield_now().await;
+        };
+
+        log::debug!("Handle adapter error dropped");
+
+        result
+    }
+
+    fn process_response(response: Response) -> Result<Response> {
+        if response.success {
+            Ok(response)
+        } else {
+            if let Some(body) = response.body.clone() {
+                if let Ok(error) = serde_json::from_value::<ErrorResponse>(body) {
+                    if let Some(message) = error.error {
+                        return Err(anyhow!(message.format));
+                    };
+                };
+            }
+
+            Err(anyhow!(
+                "Received error response from adapter. Response: {:?}",
+                response.clone()
+            ))
+        }
+    }
+
+    async fn receive_server_message<Stdout>(
+        reader: &mut BufReader<Stdout>,
+        buffer: &mut String,
+        log_handlers: Option<&LogHandlers>,
+    ) -> Result<Message>
+    where
+        Stdout: AsyncRead + Unpin + Send + 'static,
+    {
+        let mut content_length = None;
+        loop {
+            buffer.truncate(0);
+
+            if reader
+                .read_line(buffer)
+                .await
+                .with_context(|| "reading a message from server")?
+                == 0
+            {
+                return Err(anyhow!("debugger reader stream closed"));
+            };
+
+            if buffer == "\r\n" {
+                break;
+            }
+
+            let parts = buffer.trim().split_once(": ");
+
+            match parts {
+                Some(("Content-Length", value)) => {
+                    content_length = Some(value.parse().context("invalid content length")?);
+                }
+                _ => {}
+            }
+        }
+
+        let content_length = content_length.context("missing content length")?;
+
+        let mut content = vec![0; content_length];
+        reader
+            .read_exact(&mut content)
+            .await
+            .with_context(|| "reading after a loop")?;
+
+        let message = std::str::from_utf8(&content).context("invalid utf8 from server")?;
+
+        if let Some(log_handlers) = log_handlers {
+            for (kind, log_handler) in log_handlers.lock().iter_mut() {
+                if matches!(kind, LogKind::Rpc) {
+                    log_handler(IoKind::StdOut, &message);
+                }
+            }
+        }
+
+        Ok(serde_json::from_str::<Message>(message)?)
+    }
+
+    pub async fn shutdown(&self) -> Result<()> {
+        log::debug!("Start shutdown client");
+
+        if let Some(server_tx) = self.server_tx.lock().await.take().as_ref() {
+            server_tx.close();
+        }
+
+        let mut current_requests = self.current_requests.lock().await;
+        let mut pending_requests = self.pending_requests.lock().await;
+
+        current_requests.clear();
+        pending_requests.clear();
+
+        let _ = self.transport.kill().await.log_err();
+
+        drop(current_requests);
+        drop(pending_requests);
+
+        log::debug!("Shutdown client completed");
+
+        anyhow::Ok(())
+    }
+
+    pub fn has_adapter_logs(&self) -> bool {
+        self.transport.has_adapter_logs()
+    }
+
+    pub fn transport(&self) -> &Transport {
+        &self.transport
+    }
+
+    pub fn add_log_handler<F>(&self, f: F, kind: LogKind)
+    where
+        F: 'static + Send + FnMut(IoKind, &str),
+    {
+        let mut log_handlers = self.log_handlers.lock();
+        log_handlers.push((kind, Box::new(f)));
+    }
+}
+
+pub struct TcpTransport {
+    pub port: u16,
+    pub host: Ipv4Addr,
+    pub timeout: u64,
+    process: Mutex<Child>,
+}
+
+impl TcpTransport {
+    /// Get an open port to use with the tcp client when not supplied by debug config
+    pub async fn port(host: &TCPHost) -> Result<u16> {
+        if let Some(port) = host.port {
+            Ok(port)
+        } else {
+            Ok(TcpListener::bind(SocketAddrV4::new(host.host(), 0))
+                .await?
+                .local_addr()?
+                .port())
+        }
+    }
+
+    async fn start(binary: &DebugAdapterBinary, cx: AsyncApp) -> Result<(TransportPipe, Self)> {
+        let Some(connection_args) = binary.connection.as_ref() else {
+            return Err(anyhow!("No connection arguments provided"));
+        };
+
+        let host = connection_args.host;
+        let port = connection_args.port;
+
+        let mut command = util::command::new_smol_command(&binary.command);
+
+        if let Some(cwd) = &binary.cwd {
+            command.current_dir(cwd);
+        }
+
+        if let Some(args) = &binary.arguments {
+            command.args(args);
+        }
+
+        if let Some(envs) = &binary.envs {
+            command.envs(envs);
+        }
+
+        command
+            .stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .kill_on_drop(true);
+
+        let mut process = command
+            .spawn()
+            .with_context(|| "failed to start debug adapter.")?;
+
+        let address = SocketAddrV4::new(host, port);
+
+        let timeout = connection_args.timeout.unwrap_or_else(|| {
+            cx.update(|cx| DebuggerSettings::get_global(cx).timeout)
+                .unwrap_or(2000u64)
+        });
+
+        let (rx, tx) = select! {
+            _ = cx.background_executor().timer(Duration::from_millis(timeout)).fuse() => {
+                return Err(anyhow!(format!("Connection to TCP DAP timeout {}:{}", host, port)))
+            },
+            result = cx.spawn(|cx| async move {
+                loop {
+                    match TcpStream::connect(address).await {
+                        Ok(stream) => return stream.split(),
+                        Err(_) => {
+                            cx.background_executor().timer(Duration::from_millis(100)).await;
+                        }
+                    }
+                }
+            }).fuse() => result
+        };
+        log::info!(
+            "Debug adapter has connected to TCP server {}:{}",
+            host,
+            port
+        );
+        let stdout = process.stdout.take();
+        let stderr = process.stderr.take();
+
+        let this = Self {
+            port,
+            host,
+            process: Mutex::new(process),
+            timeout,
+        };
+
+        let pipe = TransportPipe::new(
+            Box::new(tx),
+            Box::new(BufReader::new(rx)),
+            stdout.map(|s| Box::new(s) as Box<dyn AsyncRead + Unpin + Send>),
+            stderr.map(|s| Box::new(s) as Box<dyn AsyncRead + Unpin + Send>),
+        );
+
+        Ok((pipe, this))
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        true
+    }
+
+    async fn kill(&self) -> Result<()> {
+        self.process.lock().await.kill()?;
+
+        Ok(())
+    }
+}
+
+pub struct StdioTransport {
+    process: Mutex<Child>,
+}
+
+impl StdioTransport {
+    async fn start(binary: &DebugAdapterBinary, _: AsyncApp) -> Result<(TransportPipe, Self)> {
+        let mut command = util::command::new_smol_command(&binary.command);
+
+        if let Some(cwd) = &binary.cwd {
+            command.current_dir(cwd);
+        }
+
+        if let Some(args) = &binary.arguments {
+            command.args(args);
+        }
+
+        if let Some(envs) = &binary.envs {
+            command.envs(envs);
+        }
+
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .kill_on_drop(true);
+
+        let mut process = command
+            .spawn()
+            .with_context(|| "failed to spawn command.")?;
+
+        let stdin = process
+            .stdin
+            .take()
+            .ok_or_else(|| anyhow!("Failed to open stdin"))?;
+        let stdout = process
+            .stdout
+            .take()
+            .ok_or_else(|| anyhow!("Failed to open stdout"))?;
+        let stderr = process
+            .stdout
+            .take()
+            .map(|io_err| Box::new(io_err) as Box<dyn AsyncRead + Unpin + Send>);
+
+        if stderr.is_none() {
+            log::error!(
+                "Failed to connect to stderr for debug adapter command {}",
+                &binary.command
+            );
+        }
+
+        log::info!("Debug adapter has connected to stdio adapter");
+
+        let process = Mutex::new(process);
+
+        Ok((
+            TransportPipe::new(
+                Box::new(stdin),
+                Box::new(BufReader::new(stdout)),
+                None,
+                stderr,
+            ),
+            Self { process },
+        ))
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        false
+    }
+
+    async fn kill(&self) -> Result<()> {
+        self.process.lock().await.kill()?;
+        Ok(())
+    }
+}
+
+#[cfg(any(test, feature = "test-support"))]
+type RequestHandler = Box<
+    dyn Send
+        + FnMut(
+            u64,
+            serde_json::Value,
+            Arc<Mutex<async_pipe::PipeWriter>>,
+        ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>,
+>;
+
+#[cfg(any(test, feature = "test-support"))]
+type ResponseHandler = Box<dyn Send + Fn(Response)>;
+
+#[cfg(any(test, feature = "test-support"))]
+pub struct FakeTransport {
+    // for sending fake response back from adapter side
+    request_handlers: Arc<Mutex<HashMap<&'static str, RequestHandler>>>,
+    // for reverse request responses
+    response_handlers: Arc<Mutex<HashMap<&'static str, ResponseHandler>>>,
+}
+
+#[cfg(any(test, feature = "test-support"))]
+impl FakeTransport {
+    pub async fn on_request<R: dap_types::requests::Request, F>(&self, mut handler: F)
+    where
+        F: 'static + Send + FnMut(u64, R::Arguments) -> Result<R::Response, ErrorResponse>,
+    {
+        self.request_handlers.lock().await.insert(
+            R::COMMAND,
+            Box::new(
+                move |seq, args, writer: Arc<Mutex<async_pipe::PipeWriter>>| {
+                    let response = handler(seq, serde_json::from_value(args).unwrap());
+
+                    let message = serde_json::to_string(&Message::Response(Response {
+                        seq: seq + 1,
+                        request_seq: seq,
+                        success: response.as_ref().is_ok(),
+                        command: R::COMMAND.into(),
+                        body: util::maybe!({ serde_json::to_value(response.ok()?).ok() }),
+                    }))
+                    .unwrap();
+
+                    let writer = writer.clone();
+
+                    Box::pin(async move {
+                        let mut writer = writer.lock().await;
+                        writer
+                            .write_all(TransportDelegate::build_rpc_message(message).as_bytes())
+                            .await
+                            .unwrap();
+                        writer.flush().await.unwrap();
+                    })
+                },
+            ),
+        );
+    }
+
+    pub async fn on_response<R: dap_types::requests::Request, F>(&self, handler: F)
+    where
+        F: 'static + Send + Fn(Response),
+    {
+        self.response_handlers
+            .lock()
+            .await
+            .insert(R::COMMAND, Box::new(handler));
+    }
+
+    async fn start(cx: AsyncApp) -> Result<(TransportPipe, Self)> {
+        let this = Self {
+            request_handlers: Arc::new(Mutex::new(HashMap::default())),
+            response_handlers: Arc::new(Mutex::new(HashMap::default())),
+        };
+        use dap_types::requests::{Request, RunInTerminal, StartDebugging};
+        use serde_json::json;
+
+        let (stdin_writer, stdin_reader) = async_pipe::pipe();
+        let (stdout_writer, stdout_reader) = async_pipe::pipe();
+
+        let request_handlers = this.request_handlers.clone();
+        let response_handlers = this.response_handlers.clone();
+        let stdout_writer = Arc::new(Mutex::new(stdout_writer));
+
+        cx.background_executor()
+            .spawn(async move {
+                let mut reader = BufReader::new(stdin_reader);
+                let mut buffer = String::new();
+
+                loop {
+                    let message =
+                        TransportDelegate::receive_server_message(&mut reader, &mut buffer, None)
+                            .await;
+
+                    match message {
+                        Err(error) => {
+                            break anyhow!(error);
+                        }
+                        Ok(message) => {
+                            match message {
+                                Message::Request(request) => {
+                                    // redirect reverse requests to stdout writer/reader
+                                    if request.command == RunInTerminal::COMMAND
+                                        || request.command == StartDebugging::COMMAND
+                                    {
+                                        let message =
+                                            serde_json::to_string(&Message::Request(request))
+                                                .unwrap();
+
+                                        let mut writer = stdout_writer.lock().await;
+                                        writer
+                                            .write_all(
+                                                TransportDelegate::build_rpc_message(message)
+                                                    .as_bytes(),
+                                            )
+                                            .await
+                                            .unwrap();
+                                        writer.flush().await.unwrap();
+                                    } else {
+                                        if let Some(handle) = request_handlers
+                                            .lock()
+                                            .await
+                                            .get_mut(request.command.as_str())
+                                        {
+                                            handle(
+                                                request.seq,
+                                                request.arguments.unwrap_or(json!({})),
+                                                stdout_writer.clone(),
+                                            )
+                                            .await;
+                                        } else {
+                                            log::error!(
+                                                "No request handler for {}",
+                                                request.command
+                                            );
+                                        }
+                                    }
+                                }
+                                Message::Event(event) => {
+                                    let message =
+                                        serde_json::to_string(&Message::Event(event)).unwrap();
+
+                                    let mut writer = stdout_writer.lock().await;
+                                    writer
+                                        .write_all(
+                                            TransportDelegate::build_rpc_message(message)
+                                                .as_bytes(),
+                                        )
+                                        .await
+                                        .unwrap();
+                                    writer.flush().await.unwrap();
+                                }
+                                Message::Response(response) => {
+                                    if let Some(handle) = response_handlers
+                                        .lock()
+                                        .await
+                                        .get(response.command.as_str())
+                                    {
+                                        handle(response);
+                                    } else {
+                                        log::error!("No response handler for {}", response.command);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            })
+            .detach();
+
+        Ok((
+            TransportPipe::new(Box::new(stdin_writer), Box::new(stdout_reader), None, None),
+            this,
+        ))
+    }
+
+    fn has_adapter_logs(&self) -> bool {
+        false
+    }
+
+    async fn kill(&self) -> Result<()> {
+        Ok(())
+    }
+}

crates/dap_adapters/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "dap_adapters"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[features]
+test-support = [
+    "dap/test-support",
+    "gpui/test-support",
+    "task/test-support",
+    "util/test-support",
+]
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/dap_adapters.rs"
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+async-trait.workspace = true
+dap.workspace = true
+gpui.workspace = true
+language.workspace = true
+paths.workspace = true
+regex.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sysinfo.workspace = true
+task.workspace = true
+util.workspace = true
+
+[dev-dependencies]
+dap = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, features = ["test-support"] }
+task = { workspace = true, features = ["test-support"] }
+util = { workspace = true, features = ["test-support"] }

crates/dap_adapters/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/dap_adapters/src/custom.rs

@@ -0,0 +1,79 @@
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use serde_json::Value;
+use std::{ffi::OsString, path::PathBuf};
+use task::DebugAdapterConfig;
+
+use crate::*;
+
+pub(crate) struct CustomDebugAdapter {
+    custom_args: CustomArgs,
+}
+
+impl CustomDebugAdapter {
+    const ADAPTER_NAME: &'static str = "custom_dap";
+
+    pub(crate) async fn new(custom_args: CustomArgs) -> Result<Self> {
+        Ok(CustomDebugAdapter { custom_args })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for CustomDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        _: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let connection = if let DebugConnectionType::TCP(connection) = &self.custom_args.connection
+        {
+            Some(adapters::TcpArguments {
+                host: connection.host(),
+                port: TcpTransport::port(&connection).await?,
+                timeout: connection.timeout,
+            })
+        } else {
+            None
+        };
+        let ret = DebugAdapterBinary {
+            command: self.custom_args.command.clone(),
+            arguments: self
+                .custom_args
+                .args
+                .clone()
+                .map(|args| args.iter().map(OsString::from).collect()),
+            cwd: config.cwd.clone(),
+            envs: self.custom_args.envs.clone(),
+            connection,
+        };
+        Ok(ret)
+    }
+
+    async fn fetch_latest_adapter_version(&self, _: &dyn DapDelegate) -> Result<AdapterVersion> {
+        bail!("Custom debug adapters don't have latest versions")
+    }
+
+    async fn install_binary(&self, _: AdapterVersion, _: &dyn DapDelegate) -> Result<()> {
+        bail!("Custom debug adapters cannot be installed")
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        bail!("Custom debug adapters cannot be installed")
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({"program": config.program})
+    }
+}

crates/dap_adapters/src/dap_adapters.rs

@@ -0,0 +1,49 @@
+mod custom;
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod gdb;
+mod go;
+mod javascript;
+mod lldb;
+mod php;
+mod python;
+
+use std::sync::Arc;
+
+use anyhow::{anyhow, bail, Result};
+use async_trait::async_trait;
+use custom::CustomDebugAdapter;
+use dap::adapters::{
+    self, AdapterVersion, DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName,
+    GithubRepo,
+};
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+use gdb::GdbDebugAdapter;
+use go::GoDebugAdapter;
+use javascript::JsDebugAdapter;
+use lldb::LldbDebugAdapter;
+use php::PhpDebugAdapter;
+use python::PythonDebugAdapter;
+use serde_json::{json, Value};
+use task::{CustomArgs, DebugAdapterConfig, DebugAdapterKind, DebugConnectionType, TCPHost};
+
+pub async fn build_adapter(kind: &DebugAdapterKind) -> Result<Arc<dyn DebugAdapter>> {
+    match kind {
+        DebugAdapterKind::Custom(start_args) => {
+            Ok(Arc::new(CustomDebugAdapter::new(start_args.clone()).await?))
+        }
+        DebugAdapterKind::Python(host) => Ok(Arc::new(PythonDebugAdapter::new(host).await?)),
+        DebugAdapterKind::Php(host) => Ok(Arc::new(PhpDebugAdapter::new(host.clone()).await?)),
+        DebugAdapterKind::Javascript(host) => {
+            Ok(Arc::new(JsDebugAdapter::new(host.clone()).await?))
+        }
+        DebugAdapterKind::Lldb => Ok(Arc::new(LldbDebugAdapter::new())),
+        DebugAdapterKind::Go(host) => Ok(Arc::new(GoDebugAdapter::new(host).await?)),
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        DebugAdapterKind::Gdb => Ok(Arc::new(GdbDebugAdapter::new())),
+        #[cfg(any(test, feature = "test-support"))]
+        DebugAdapterKind::Fake => Ok(Arc::new(dap::adapters::FakeAdapter::new())),
+        #[cfg(not(any(test, feature = "test-support")))]
+        #[allow(unreachable_patterns)]
+        _ => unreachable!("Fake variant only exists with test-support feature"),
+    }
+}

crates/dap_adapters/src/gdb.rs

@@ -0,0 +1,83 @@
+use std::ffi::OsStr;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use gpui::AsyncApp;
+use task::DebugAdapterConfig;
+
+use crate::*;
+
+pub(crate) struct GdbDebugAdapter {}
+
+impl GdbDebugAdapter {
+    const ADAPTER_NAME: &'static str = "gdb";
+
+    pub(crate) fn new() -> Self {
+        GdbDebugAdapter {}
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for GdbDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<std::path::PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let user_setting_path = user_installed_path
+            .filter(|p| p.exists())
+            .and_then(|p| p.to_str().map(|s| s.to_string()));
+
+        /* GDB implements DAP natively so just need to  */
+        let gdb_path = delegate
+            .which(OsStr::new("gdb"))
+            .and_then(|p| p.to_str().map(|s| s.to_string()))
+            .ok_or(anyhow!("Could not find gdb in path"));
+
+        if gdb_path.is_err() && user_setting_path.is_none() {
+            bail!("Could not find gdb path or it's not installed");
+        }
+
+        let gdb_path = user_setting_path.unwrap_or(gdb_path?);
+
+        Ok(DebugAdapterBinary {
+            command: gdb_path,
+            arguments: Some(vec!["-i=dap".into()]),
+            envs: None,
+            cwd: config.cwd.clone(),
+            connection: None,
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        _version: AdapterVersion,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        unimplemented!("GDB debug adapter cannot be installed by Zed (yet)")
+    }
+
+    async fn fetch_latest_adapter_version(&self, _: &dyn DapDelegate) -> Result<AdapterVersion> {
+        unimplemented!("Fetch latest GDB version not implemented (yet)")
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<std::path::PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        unimplemented!("GDB cannot be installed by Zed (yet)")
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({"program": config.program, "cwd": config.cwd})
+    }
+}

crates/dap_adapters/src/go.rs

@@ -0,0 +1,100 @@
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use std::{ffi::OsStr, net::Ipv4Addr, path::PathBuf};
+
+use crate::*;
+
+pub(crate) struct GoDebugAdapter {
+    port: u16,
+    host: Ipv4Addr,
+    timeout: Option<u64>,
+}
+
+impl GoDebugAdapter {
+    const ADAPTER_NAME: &'static str = "delve";
+
+    pub(crate) async fn new(host: &TCPHost) -> Result<Self> {
+        Ok(GoDebugAdapter {
+            port: TcpTransport::port(host).await?,
+            host: host.host(),
+            timeout: host.timeout,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for GoDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        self.get_installed_binary(delegate, config, user_installed_path, cx)
+            .await
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        unimplemented!("This adapter is used from path for now");
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::Zip,
+            delegate,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let delve_path = delegate
+            .which(OsStr::new("dlv"))
+            .and_then(|p| p.to_str().map(|p| p.to_string()))
+            .ok_or(anyhow!("Dlv not found in path"))?;
+
+        Ok(DebugAdapterBinary {
+            command: delve_path,
+            arguments: Some(vec![
+                "dap".into(),
+                "--listen".into(),
+                format!("{}:{}", self.host, self.port).into(),
+            ]),
+            cwd: config.cwd.clone(),
+            envs: None,
+            connection: Some(adapters::TcpArguments {
+                host: self.host,
+                port: self.port,
+                timeout: self.timeout,
+            }),
+        })
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({
+            "program": config.program,
+            "cwd": config.cwd,
+            "subProcess": true,
+        })
+    }
+}

crates/dap_adapters/src/javascript.rs

@@ -0,0 +1,153 @@
+use adapters::latest_github_release;
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use regex::Regex;
+use std::{collections::HashMap, net::Ipv4Addr, path::PathBuf};
+use sysinfo::{Pid, Process};
+use task::DebugRequestType;
+
+use crate::*;
+
+pub(crate) struct JsDebugAdapter {
+    port: u16,
+    host: Ipv4Addr,
+    timeout: Option<u64>,
+}
+
+impl JsDebugAdapter {
+    const ADAPTER_NAME: &'static str = "vscode-js-debug";
+    const ADAPTER_PATH: &'static str = "js-debug/src/dapDebugServer.js";
+
+    pub(crate) async fn new(host: TCPHost) -> Result<Self> {
+        Ok(JsDebugAdapter {
+            host: host.host(),
+            timeout: host.timeout,
+            port: TcpTransport::port(&host).await?,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for JsDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        let release = latest_github_release(
+            &format!("{}/{}", "microsoft", Self::ADAPTER_NAME),
+            true,
+            false,
+            delegate.http_client(),
+        )
+        .await?;
+
+        let asset_name = format!("js-debug-dap-{}.tar.gz", release.tag_name);
+
+        Ok(AdapterVersion {
+            tag_name: release.tag_name,
+            url: release
+                .assets
+                .iter()
+                .find(|asset| asset.name == asset_name)
+                .ok_or_else(|| anyhow!("no asset found matching {:?}", asset_name))?
+                .browser_download_url
+                .clone(),
+        })
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let adapter_path = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path
+        } else {
+            let adapter_path = paths::debug_adapters_dir().join(self.name());
+
+            let file_name_prefix = format!("{}_", self.name());
+
+            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
+                file_name.starts_with(&file_name_prefix)
+            })
+            .await
+            .ok_or_else(|| anyhow!("Couldn't find JavaScript dap directory"))?
+        };
+
+        Ok(DebugAdapterBinary {
+            command: delegate
+                .node_runtime()
+                .binary_path()
+                .await?
+                .to_string_lossy()
+                .into_owned(),
+            arguments: Some(vec![
+                adapter_path.join(Self::ADAPTER_PATH).into(),
+                self.port.to_string().into(),
+                self.host.to_string().into(),
+            ]),
+            cwd: config.cwd.clone(),
+            envs: None,
+            connection: Some(adapters::TcpArguments {
+                host: self.host,
+                port: self.port,
+                timeout: self.timeout,
+            }),
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::GzipTar,
+            delegate,
+        )
+        .await?;
+
+        return Ok(());
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        let pid = if let DebugRequestType::Attach(attach_config) = &config.request {
+            attach_config.process_id
+        } else {
+            None
+        };
+
+        json!({
+            "program": config.program,
+            "type": "pwa-node",
+            "request": match config.request {
+                DebugRequestType::Launch => "launch",
+                DebugRequestType::Attach(_) => "attach",
+            },
+            "processId": pid,
+            "cwd": config.cwd,
+        })
+    }
+
+    fn attach_processes<'a>(
+        &self,
+        processes: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        let regex = Regex::new(r"(?i)^(?:node|bun|iojs)(?:$|\b)").unwrap();
+
+        Some(
+            processes
+                .iter()
+                .filter(|(_, process)| regex.is_match(&process.name().to_string_lossy()))
+                .collect::<Vec<_>>(),
+        )
+    }
+}

crates/dap_adapters/src/lldb.rs

@@ -0,0 +1,107 @@
+use std::{collections::HashMap, ffi::OsStr, path::PathBuf};
+
+use anyhow::Result;
+use async_trait::async_trait;
+use gpui::AsyncApp;
+use sysinfo::{Pid, Process};
+use task::{DebugAdapterConfig, DebugRequestType};
+
+use crate::*;
+
+pub(crate) struct LldbDebugAdapter {}
+
+impl LldbDebugAdapter {
+    const ADAPTER_NAME: &'static str = "lldb";
+
+    pub(crate) fn new() -> Self {
+        LldbDebugAdapter {}
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for LldbDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn get_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let lldb_dap_path = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path.to_string_lossy().into()
+        } else if cfg!(target_os = "macos") {
+            util::command::new_smol_command("xcrun")
+                .args(&["-f", "lldb-dap"])
+                .output()
+                .await
+                .ok()
+                .and_then(|output| String::from_utf8(output.stdout).ok())
+                .map(|path| path.trim().to_string())
+                .ok_or(anyhow!("Failed to find lldb-dap in user's path"))?
+        } else {
+            delegate
+                .which(OsStr::new("lldb-dap"))
+                .and_then(|p| p.to_str().map(|s| s.to_string()))
+                .ok_or(anyhow!("Could not find lldb-dap in path"))?
+        };
+
+        Ok(DebugAdapterBinary {
+            command: lldb_dap_path,
+            arguments: None,
+            envs: None,
+            cwd: config.cwd.clone(),
+            connection: None,
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        _version: AdapterVersion,
+        _delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        unimplemented!("LLDB debug adapter cannot be installed by Zed (yet)")
+    }
+
+    async fn fetch_latest_adapter_version(&self, _: &dyn DapDelegate) -> Result<AdapterVersion> {
+        unimplemented!("Fetch latest adapter version not implemented for lldb (yet)")
+    }
+
+    async fn get_installed_binary(
+        &self,
+        _: &dyn DapDelegate,
+        _: &DebugAdapterConfig,
+        _: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        unimplemented!("LLDB debug adapter cannot be installed by Zed (yet)")
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        let pid = if let DebugRequestType::Attach(attach_config) = &config.request {
+            attach_config.process_id
+        } else {
+            None
+        };
+
+        json!({
+            "program": config.program,
+            "request": match config.request {
+                DebugRequestType::Launch => "launch",
+                DebugRequestType::Attach(_) => "attach",
+            },
+            "pid": pid,
+            "cwd": config.cwd,
+        })
+    }
+
+    fn attach_processes<'a>(
+        &self,
+        processes: &'a HashMap<Pid, Process>,
+    ) -> Option<Vec<(&'a Pid, &'a Process)>> {
+        Some(processes.iter().collect::<Vec<_>>())
+    }
+}

crates/dap_adapters/src/php.rs

@@ -0,0 +1,123 @@
+use adapters::latest_github_release;
+use dap::{adapters::TcpArguments, transport::TcpTransport};
+use gpui::AsyncApp;
+use std::{net::Ipv4Addr, path::PathBuf};
+
+use crate::*;
+
+pub(crate) struct PhpDebugAdapter {
+    port: u16,
+    _host: Ipv4Addr,
+    _timeout: Option<u64>,
+}
+
+impl PhpDebugAdapter {
+    const ADAPTER_NAME: &'static str = "vscode-php-debug";
+    const ADAPTER_PATH: &'static str = "extension/out/phpDebug.js";
+
+    pub(crate) async fn new(host: TCPHost) -> Result<Self> {
+        Ok(PhpDebugAdapter {
+            port: TcpTransport::port(&host).await?,
+            _host: host.host(),
+            _timeout: host.timeout,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for PhpDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        let release = latest_github_release(
+            &format!("{}/{}", "xdebug", Self::ADAPTER_NAME),
+            true,
+            false,
+            delegate.http_client(),
+        )
+        .await?;
+
+        let asset_name = format!("php-debug-{}.vsix", release.tag_name.replace("v", ""));
+
+        Ok(AdapterVersion {
+            tag_name: release.tag_name,
+            url: release
+                .assets
+                .iter()
+                .find(|asset| asset.name == asset_name)
+                .ok_or_else(|| anyhow!("no asset found matching {:?}", asset_name))?
+                .browser_download_url
+                .clone(),
+        })
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        _: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        let adapter_path = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path
+        } else {
+            let adapter_path = paths::debug_adapters_dir().join(self.name());
+
+            let file_name_prefix = format!("{}_", self.name());
+
+            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
+                file_name.starts_with(&file_name_prefix)
+            })
+            .await
+            .ok_or_else(|| anyhow!("Couldn't find PHP dap directory"))?
+        };
+
+        Ok(DebugAdapterBinary {
+            command: delegate
+                .node_runtime()
+                .binary_path()
+                .await?
+                .to_string_lossy()
+                .into_owned(),
+            arguments: Some(vec![
+                adapter_path.join(Self::ADAPTER_PATH).into(),
+                format!("--server={}", self.port).into(),
+            ]),
+            connection: Some(TcpArguments {
+                port: self.port,
+                host: self._host,
+                timeout: self._timeout,
+            }),
+            cwd: config.cwd.clone(),
+            envs: None,
+        })
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::Vsix,
+            delegate,
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({
+            "program": config.program,
+            "cwd": config.cwd,
+        })
+    }
+}

crates/dap_adapters/src/python.rs

@@ -0,0 +1,141 @@
+use crate::*;
+use dap::transport::TcpTransport;
+use gpui::AsyncApp;
+use std::{ffi::OsStr, net::Ipv4Addr, path::PathBuf};
+
+pub(crate) struct PythonDebugAdapter {
+    port: u16,
+    host: Ipv4Addr,
+    timeout: Option<u64>,
+}
+
+impl PythonDebugAdapter {
+    const ADAPTER_NAME: &'static str = "debugpy";
+    const ADAPTER_PATH: &'static str = "src/debugpy/adapter";
+    const LANGUAGE_NAME: &'static str = "Python";
+
+    pub(crate) async fn new(host: &TCPHost) -> Result<Self> {
+        Ok(PythonDebugAdapter {
+            port: TcpTransport::port(host).await?,
+            host: host.host(),
+            timeout: host.timeout,
+        })
+    }
+}
+
+#[async_trait(?Send)]
+impl DebugAdapter for PythonDebugAdapter {
+    fn name(&self) -> DebugAdapterName {
+        DebugAdapterName(Self::ADAPTER_NAME.into())
+    }
+
+    async fn fetch_latest_adapter_version(
+        &self,
+        delegate: &dyn DapDelegate,
+    ) -> Result<AdapterVersion> {
+        let github_repo = GithubRepo {
+            repo_name: Self::ADAPTER_NAME.into(),
+            repo_owner: "microsoft".into(),
+        };
+
+        adapters::fetch_latest_adapter_version_from_github(github_repo, delegate).await
+    }
+
+    async fn install_binary(
+        &self,
+        version: AdapterVersion,
+        delegate: &dyn DapDelegate,
+    ) -> Result<()> {
+        let version_path = adapters::download_adapter_from_github(
+            self.name(),
+            version,
+            adapters::DownloadedFileType::Zip,
+            delegate,
+        )
+        .await?;
+
+        // only needed when you install the latest version for the first time
+        if let Some(debugpy_dir) =
+            util::fs::find_file_name_in_dir(version_path.as_path(), |file_name| {
+                file_name.starts_with("microsoft-debugpy-")
+            })
+            .await
+        {
+            // TODO Debugger: Rename folder instead of moving all files to another folder
+            // We're doing uncessary IO work right now
+            util::fs::move_folder_files_to_folder(debugpy_dir.as_path(), version_path.as_path())
+                .await?;
+        }
+
+        Ok(())
+    }
+
+    async fn get_installed_binary(
+        &self,
+        delegate: &dyn DapDelegate,
+        config: &DebugAdapterConfig,
+        user_installed_path: Option<PathBuf>,
+        cx: &mut AsyncApp,
+    ) -> Result<DebugAdapterBinary> {
+        const BINARY_NAMES: [&str; 3] = ["python3", "python", "py"];
+
+        let debugpy_dir = if let Some(user_installed_path) = user_installed_path {
+            user_installed_path
+        } else {
+            let adapter_path = paths::debug_adapters_dir().join(self.name());
+            let file_name_prefix = format!("{}_", self.name());
+
+            util::fs::find_file_name_in_dir(adapter_path.as_path(), |file_name| {
+                file_name.starts_with(&file_name_prefix)
+            })
+            .await
+            .ok_or_else(|| anyhow!("Debugpy directory not found"))?
+        };
+
+        let toolchain = delegate
+            .toolchain_store()
+            .active_toolchain(
+                delegate.worktree_id(),
+                language::LanguageName::new(Self::LANGUAGE_NAME),
+                cx,
+            )
+            .await;
+
+        let python_path = if let Some(toolchain) = toolchain {
+            Some(toolchain.path.to_string())
+        } else {
+            BINARY_NAMES
+                .iter()
+                .filter_map(|cmd| {
+                    delegate
+                        .which(OsStr::new(cmd))
+                        .map(|path| path.to_string_lossy().to_string())
+                })
+                .find(|_| true)
+        };
+
+        Ok(DebugAdapterBinary {
+            command: python_path.ok_or(anyhow!("failed to find binary path for python"))?,
+            arguments: Some(vec![
+                debugpy_dir.join(Self::ADAPTER_PATH).into(),
+                format!("--port={}", self.port).into(),
+                format!("--host={}", self.host).into(),
+            ]),
+            connection: Some(adapters::TcpArguments {
+                host: self.host,
+                port: self.port,
+                timeout: self.timeout,
+            }),
+            cwd: config.cwd.clone(),
+            envs: None,
+        })
+    }
+
+    fn request_args(&self, config: &DebugAdapterConfig) -> Value {
+        json!({
+            "program": config.program,
+            "subProcess": true,
+            "cwd": config.cwd,
+        })
+    }
+}

crates/debugger_tools/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "debugger_tools"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/debugger_tools.rs"
+doctest = false
+
+[dependencies]
+anyhow.workspace = true
+dap.workspace = true
+editor.workspace = true
+futures.workspace = true
+gpui.workspace = true
+project.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+smol.workspace = true
+util.workspace = true
+workspace.workspace = true

crates/debugger_tools/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/debugger_tools/src/dap_log.rs

@@ -0,0 +1,834 @@
+use dap::{
+    client::SessionId,
+    debugger_settings::DebuggerSettings,
+    transport::{IoKind, LogKind},
+};
+use editor::{Editor, EditorEvent};
+use futures::{
+    channel::mpsc::{unbounded, UnboundedSender},
+    StreamExt,
+};
+use gpui::{
+    actions, div, App, AppContext, Context, Empty, Entity, EventEmitter, FocusHandle, Focusable,
+    IntoElement, ParentElement, Render, SharedString, Styled, Subscription, WeakEntity, Window,
+};
+use project::{debugger::session::Session, search::SearchQuery, Project};
+use settings::Settings as _;
+use std::{
+    borrow::Cow,
+    collections::{HashMap, VecDeque},
+    sync::Arc,
+};
+use util::maybe;
+use workspace::{
+    item::Item,
+    searchable::{SearchEvent, SearchableItem, SearchableItemHandle},
+    ui::{h_flex, Button, Clickable, ContextMenu, Label, LabelCommon, PopoverMenu},
+    ToolbarItemEvent, ToolbarItemView, Workspace,
+};
+
+struct DapLogView {
+    editor: Entity<Editor>,
+    focus_handle: FocusHandle,
+    log_store: Entity<LogStore>,
+    editor_subscriptions: Vec<Subscription>,
+    current_view: Option<(SessionId, LogKind)>,
+    project: Entity<Project>,
+    _subscriptions: Vec<Subscription>,
+}
+
+struct LogStore {
+    projects: HashMap<WeakEntity<Project>, ProjectState>,
+    debug_clients: HashMap<SessionId, DebugAdapterState>,
+    rpc_tx: UnboundedSender<(SessionId, IoKind, String)>,
+    adapter_log_tx: UnboundedSender<(SessionId, IoKind, String)>,
+}
+
+struct ProjectState {
+    _subscriptions: [gpui::Subscription; 2],
+}
+
+struct DebugAdapterState {
+    log_messages: VecDeque<String>,
+    rpc_messages: RpcMessages,
+}
+
+struct RpcMessages {
+    messages: VecDeque<String>,
+    last_message_kind: Option<MessageKind>,
+}
+
+impl RpcMessages {
+    const MESSAGE_QUEUE_LIMIT: usize = 255;
+
+    fn new() -> Self {
+        Self {
+            last_message_kind: None,
+            messages: VecDeque::with_capacity(Self::MESSAGE_QUEUE_LIMIT),
+        }
+    }
+}
+
+const SEND: &str = "// Send";
+const RECEIVE: &str = "// Receive";
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum MessageKind {
+    Send,
+    Receive,
+}
+
+impl MessageKind {
+    fn label(&self) -> &'static str {
+        match self {
+            Self::Send => SEND,
+            Self::Receive => RECEIVE,
+        }
+    }
+}
+
+impl DebugAdapterState {
+    fn new() -> Self {
+        Self {
+            log_messages: VecDeque::new(),
+            rpc_messages: RpcMessages::new(),
+        }
+    }
+}
+
+impl LogStore {
+    fn new(cx: &Context<Self>) -> Self {
+        let (rpc_tx, mut rpc_rx) = unbounded::<(SessionId, IoKind, String)>();
+        cx.spawn(|this, mut cx| async move {
+            while let Some((client_id, io_kind, message)) = rpc_rx.next().await {
+                if let Some(this) = this.upgrade() {
+                    this.update(&mut cx, |this, cx| {
+                        this.on_rpc_log(client_id, io_kind, &message, cx);
+                    })?;
+                }
+
+                smol::future::yield_now().await;
+            }
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+
+        let (adapter_log_tx, mut adapter_log_rx) = unbounded::<(SessionId, IoKind, String)>();
+        cx.spawn(|this, mut cx| async move {
+            while let Some((client_id, io_kind, message)) = adapter_log_rx.next().await {
+                if let Some(this) = this.upgrade() {
+                    this.update(&mut cx, |this, cx| {
+                        this.on_adapter_log(client_id, io_kind, &message, cx);
+                    })?;
+                }
+
+                smol::future::yield_now().await;
+            }
+            anyhow::Ok(())
+        })
+        .detach_and_log_err(cx);
+        Self {
+            rpc_tx,
+            adapter_log_tx,
+            projects: HashMap::new(),
+            debug_clients: HashMap::new(),
+        }
+    }
+
+    fn on_rpc_log(
+        &mut self,
+        client_id: SessionId,
+        io_kind: IoKind,
+        message: &str,
+        cx: &mut Context<Self>,
+    ) {
+        self.add_debug_client_message(client_id, io_kind, message.to_string(), cx);
+    }
+
+    fn on_adapter_log(
+        &mut self,
+        client_id: SessionId,
+        io_kind: IoKind,
+        message: &str,
+        cx: &mut Context<Self>,
+    ) {
+        self.add_debug_client_log(client_id, io_kind, message.to_string(), cx);
+    }
+
+    pub fn add_project(&mut self, project: &Entity<Project>, cx: &mut Context<Self>) {
+        let weak_project = project.downgrade();
+        self.projects.insert(
+            project.downgrade(),
+            ProjectState {
+                _subscriptions: [
+                    cx.observe_release(project, move |this, _, _| {
+                        this.projects.remove(&weak_project);
+                    }),
+                    cx.subscribe(project, |this, project, event, cx| match event {
+                        project::Event::DebugClientStarted(client_id) => {
+                            let session = project
+                                .read(cx)
+                                .dap_store()
+                                .read(cx)
+                                .session_by_id(client_id);
+                            if let Some(session) = session {
+                                this.add_debug_client(*client_id, session, cx);
+                            }
+                        }
+                        project::Event::DebugClientShutdown(client_id) => {
+                            this.remove_debug_client(*client_id, cx);
+                        }
+
+                        _ => {}
+                    }),
+                ],
+            },
+        );
+    }
+
+    fn get_debug_adapter_state(&mut self, id: SessionId) -> Option<&mut DebugAdapterState> {
+        self.debug_clients.get_mut(&id)
+    }
+
+    fn add_debug_client_message(
+        &mut self,
+        id: SessionId,
+        io_kind: IoKind,
+        message: String,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(debug_client_state) = self.get_debug_adapter_state(id) else {
+            return;
+        };
+
+        let kind = match io_kind {
+            IoKind::StdOut | IoKind::StdErr => MessageKind::Receive,
+            IoKind::StdIn => MessageKind::Send,
+        };
+
+        let rpc_messages = &mut debug_client_state.rpc_messages;
+        if rpc_messages.last_message_kind != Some(kind) {
+            Self::add_debug_client_entry(
+                &mut rpc_messages.messages,
+                id,
+                kind.label().to_string(),
+                LogKind::Rpc,
+                cx,
+            );
+            rpc_messages.last_message_kind = Some(kind);
+        }
+        Self::add_debug_client_entry(&mut rpc_messages.messages, id, message, LogKind::Rpc, cx);
+
+        cx.notify();
+    }
+
+    fn add_debug_client_log(
+        &mut self,
+        id: SessionId,
+        io_kind: IoKind,
+        message: String,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(debug_client_state) = self.get_debug_adapter_state(id) else {
+            return;
+        };
+
+        let message = match io_kind {
+            IoKind::StdErr => {
+                let mut message = message.clone();
+                message.insert_str(0, "stderr: ");
+                message
+            }
+            _ => message,
+        };
+
+        Self::add_debug_client_entry(
+            &mut debug_client_state.log_messages,
+            id,
+            message,
+            LogKind::Adapter,
+            cx,
+        );
+        cx.notify();
+    }
+
+    fn add_debug_client_entry(
+        log_lines: &mut VecDeque<String>,
+        id: SessionId,
+        message: String,
+        kind: LogKind,
+        cx: &mut Context<Self>,
+    ) {
+        while log_lines.len() >= RpcMessages::MESSAGE_QUEUE_LIMIT {
+            log_lines.pop_front();
+        }
+
+        let format_messages = DebuggerSettings::get_global(cx).format_dap_log_messages;
+
+        let entry = if format_messages {
+            maybe!({
+                serde_json::to_string_pretty::<serde_json::Value>(
+                    &serde_json::from_str(&message).ok()?,
+                )
+                .ok()
+            })
+            .unwrap_or(message)
+        } else {
+            message
+        };
+        log_lines.push_back(entry.clone());
+
+        cx.emit(Event::NewLogEntry { id, entry, kind });
+    }
+
+    fn add_debug_client(
+        &mut self,
+        client_id: SessionId,
+        client: Entity<Session>,
+        cx: &App,
+    ) -> Option<&mut DebugAdapterState> {
+        let client_state = self
+            .debug_clients
+            .entry(client_id)
+            .or_insert_with(DebugAdapterState::new);
+
+        let io_tx = self.rpc_tx.clone();
+
+        let client = client.read(cx).adapter_client()?;
+        client.add_log_handler(
+            move |io_kind, message| {
+                io_tx
+                    .unbounded_send((client_id, io_kind, message.to_string()))
+                    .ok();
+            },
+            LogKind::Rpc,
+        );
+
+        let log_io_tx = self.adapter_log_tx.clone();
+        client.add_log_handler(
+            move |io_kind, message| {
+                log_io_tx
+                    .unbounded_send((client_id, io_kind, message.to_string()))
+                    .ok();
+            },
+            LogKind::Adapter,
+        );
+
+        Some(client_state)
+    }
+
+    fn remove_debug_client(&mut self, client_id: SessionId, cx: &mut Context<Self>) {
+        self.debug_clients.remove(&client_id);
+        cx.notify();
+    }
+
+    fn log_messages_for_client(&mut self, client_id: SessionId) -> Option<&mut VecDeque<String>> {
+        Some(&mut self.debug_clients.get_mut(&client_id)?.log_messages)
+    }
+
+    fn rpc_messages_for_client(&mut self, client_id: SessionId) -> Option<&mut VecDeque<String>> {
+        Some(
+            &mut self
+                .debug_clients
+                .get_mut(&client_id)?
+                .rpc_messages
+                .messages,
+        )
+    }
+}
+
+pub struct DapLogToolbarItemView {
+    log_view: Option<Entity<DapLogView>>,
+}
+
+impl DapLogToolbarItemView {
+    pub fn new() -> Self {
+        Self { log_view: None }
+    }
+}
+
+impl Render for DapLogToolbarItemView {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let Some(log_view) = self.log_view.clone() else {
+            return Empty.into_any_element();
+        };
+
+        let (menu_rows, current_client_id) = log_view.update(cx, |log_view, cx| {
+            (
+                log_view.menu_items(cx).unwrap_or_default(),
+                log_view.current_view.map(|(client_id, _)| client_id),
+            )
+        });
+
+        let current_client = current_client_id.and_then(|current_client_id| {
+            menu_rows
+                .iter()
+                .find(|row| row.client_id == current_client_id)
+        });
+
+        let dap_menu: PopoverMenu<_> = PopoverMenu::new("DapLogView")
+            .anchor(gpui::Corner::TopLeft)
+            .trigger(Button::new(
+                "debug_client_menu_header",
+                current_client
+                    .map(|sub_item| {
+                        Cow::Owned(format!(
+                            "{} ({}) - {}",
+                            sub_item.client_name,
+                            sub_item.client_id.0,
+                            match sub_item.selected_entry {
+                                LogKind::Adapter => ADAPTER_LOGS,
+                                LogKind::Rpc => RPC_MESSAGES,
+                            }
+                        ))
+                    })
+                    .unwrap_or_else(|| "No adapter selected".into()),
+            ))
+            .menu(move |mut window, cx| {
+                let log_view = log_view.clone();
+                let menu_rows = menu_rows.clone();
+                ContextMenu::build(&mut window, cx, move |mut menu, window, _cx| {
+                    for row in menu_rows.into_iter() {
+                        menu = menu.custom_row(move |_window, _cx| {
+                            div()
+                                .w_full()
+                                .pl_2()
+                                .child(
+                                    Label::new(
+                                        format!("{}. {}", row.client_id.0, row.client_name,),
+                                    )
+                                    .color(workspace::ui::Color::Muted),
+                                )
+                                .into_any_element()
+                        });
+
+                        if row.has_adapter_logs {
+                            menu = menu.custom_entry(
+                                move |_window, _cx| {
+                                    div()
+                                        .w_full()
+                                        .pl_4()
+                                        .child(Label::new(ADAPTER_LOGS))
+                                        .into_any_element()
+                                },
+                                window.handler_for(&log_view, move |view, window, cx| {
+                                    view.show_log_messages_for_adapter(row.client_id, window, cx);
+                                }),
+                            );
+                        }
+
+                        menu = menu.custom_entry(
+                            move |_window, _cx| {
+                                div()
+                                    .w_full()
+                                    .pl_4()
+                                    .child(Label::new(RPC_MESSAGES))
+                                    .into_any_element()
+                            },
+                            window.handler_for(&log_view, move |view, window, cx| {
+                                view.show_rpc_trace_for_server(row.client_id, window, cx);
+                            }),
+                        );
+                    }
+
+                    menu
+                })
+                .into()
+            });
+
+        h_flex()
+            .size_full()
+            .child(dap_menu)
+            .child(
+                div()
+                    .child(
+                        Button::new("clear_log_button", "Clear").on_click(cx.listener(
+                            |this, _, window, cx| {
+                                if let Some(log_view) = this.log_view.as_ref() {
+                                    log_view.update(cx, |log_view, cx| {
+                                        log_view.editor.update(cx, |editor, cx| {
+                                            editor.set_read_only(false);
+                                            editor.clear(window, cx);
+                                            editor.set_read_only(true);
+                                        });
+                                    })
+                                }
+                            },
+                        )),
+                    )
+                    .ml_2(),
+            )
+            .into_any_element()
+    }
+}
+
+impl EventEmitter<ToolbarItemEvent> for DapLogToolbarItemView {}
+
+impl ToolbarItemView for DapLogToolbarItemView {
+    fn set_active_pane_item(
+        &mut self,
+        active_pane_item: Option<&dyn workspace::item::ItemHandle>,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> workspace::ToolbarItemLocation {
+        if let Some(item) = active_pane_item {
+            if let Some(log_view) = item.downcast::<DapLogView>() {
+                self.log_view = Some(log_view.clone());
+                return workspace::ToolbarItemLocation::PrimaryLeft;
+            }
+        }
+        self.log_view = None;
+
+        cx.notify();
+
+        workspace::ToolbarItemLocation::Hidden
+    }
+}
+
+impl DapLogView {
+    pub fn new(
+        project: Entity<Project>,
+        log_store: Entity<LogStore>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let (editor, editor_subscriptions) = Self::editor_for_logs(String::new(), window, cx);
+
+        let focus_handle = cx.focus_handle();
+
+        let events_subscriptions = cx.subscribe(&log_store, |log_view, _, event, cx| match event {
+            Event::NewLogEntry { id, entry, kind } => {
+                if log_view.current_view == Some((*id, *kind)) {
+                    log_view.editor.update(cx, |editor, cx| {
+                        editor.set_read_only(false);
+                        let last_point = editor.buffer().read(cx).len(cx);
+                        editor.edit(
+                            vec![
+                                (last_point..last_point, entry.trim()),
+                                (last_point..last_point, "\n"),
+                            ],
+                            cx,
+                        );
+                        editor.set_read_only(true);
+                    });
+                }
+            }
+        });
+
+        Self {
+            editor,
+            focus_handle,
+            project,
+            log_store,
+            editor_subscriptions,
+            current_view: None,
+            _subscriptions: vec![events_subscriptions],
+        }
+    }
+
+    fn editor_for_logs(
+        log_contents: String,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> (Entity<Editor>, Vec<Subscription>) {
+        let editor = cx.new(|cx| {
+            let mut editor = Editor::multi_line(window, cx);
+            editor.set_text(log_contents, window, cx);
+            editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
+            editor.set_read_only(true);
+            editor.set_show_edit_predictions(Some(false), window, cx);
+            editor
+        });
+        let editor_subscription = cx.subscribe(
+            &editor,
+            |_, _, event: &EditorEvent, cx: &mut Context<'_, DapLogView>| cx.emit(event.clone()),
+        );
+        let search_subscription = cx.subscribe(
+            &editor,
+            |_, _, event: &SearchEvent, cx: &mut Context<'_, DapLogView>| cx.emit(event.clone()),
+        );
+        (editor, vec![editor_subscription, search_subscription])
+    }
+
+    fn menu_items(&self, cx: &App) -> Option<Vec<DapMenuItem>> {
+        let mut menu_items = self
+            .project
+            .read(cx)
+            .dap_store()
+            .read(cx)
+            .sessions()
+            .filter_map(|client| {
+                let client = client.read(cx).adapter_client()?;
+                Some(DapMenuItem {
+                    client_id: client.id(),
+                    client_name: "debygpy (hard coded)".into(), // todo(debugger) Fix this hard coded
+                    has_adapter_logs: client.has_adapter_logs(),
+                    selected_entry: self.current_view.map_or(LogKind::Adapter, |(_, kind)| kind),
+                })
+            })
+            .collect::<Vec<_>>();
+        menu_items.sort_by_key(|item| item.client_id.0);
+        Some(menu_items)
+    }
+
+    fn show_rpc_trace_for_server(
+        &mut self,
+        client_id: SessionId,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let rpc_log = self.log_store.update(cx, |log_store, _| {
+            log_store
+                .rpc_messages_for_client(client_id)
+                .map(|state| log_contents(&state))
+        });
+        if let Some(rpc_log) = rpc_log {
+            self.current_view = Some((client_id, LogKind::Rpc));
+            let (editor, editor_subscriptions) = Self::editor_for_logs(rpc_log, window, cx);
+            let language = self.project.read(cx).languages().language_for_name("JSON");
+            editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .expect("log buffer should be a singleton")
+                .update(cx, |_, cx| {
+                    cx.spawn({
+                        let buffer = cx.entity();
+                        |_, mut cx| async move {
+                            let language = language.await.ok();
+                            buffer.update(&mut cx, |buffer, cx| {
+                                buffer.set_language(language, cx);
+                            })
+                        }
+                    })
+                    .detach_and_log_err(cx);
+                });
+
+            self.editor = editor;
+            self.editor_subscriptions = editor_subscriptions;
+            cx.notify();
+        }
+
+        cx.focus_self(window);
+    }
+
+    fn show_log_messages_for_adapter(
+        &mut self,
+        client_id: SessionId,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let message_log = self.log_store.update(cx, |log_store, _| {
+            log_store
+                .log_messages_for_client(client_id)
+                .map(|state| log_contents(&state))
+        });
+        if let Some(message_log) = message_log {
+            self.current_view = Some((client_id, LogKind::Adapter));
+            let (editor, editor_subscriptions) = Self::editor_for_logs(message_log, window, cx);
+            editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .expect("log buffer should be a singleton");
+
+            self.editor = editor;
+            self.editor_subscriptions = editor_subscriptions;
+            cx.notify();
+        }
+
+        cx.focus_self(window);
+    }
+}
+
+fn log_contents(lines: &VecDeque<String>) -> String {
+    let (a, b) = lines.as_slices();
+    let a = a.iter().map(move |v| v.as_ref());
+    let b = b.iter().map(move |v| v.as_ref());
+    a.chain(b).fold(String::new(), |mut acc, el| {
+        acc.push_str(el);
+        acc.push('\n');
+        acc
+    })
+}
+
+#[derive(Clone, PartialEq)]
+pub(crate) struct DapMenuItem {
+    pub client_id: SessionId,
+    pub client_name: String,
+    pub has_adapter_logs: bool,
+    pub selected_entry: LogKind,
+}
+
+const ADAPTER_LOGS: &str = "Adapter Logs";
+const RPC_MESSAGES: &str = "RPC Messages";
+
+impl Render for DapLogView {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        self.editor.update(cx, |editor, cx| {
+            editor.render(window, cx).into_any_element()
+        })
+    }
+}
+
+actions!(debug, [OpenDebuggerAdapterLogs]);
+
+pub fn init(cx: &mut App) {
+    let log_store = cx.new(|cx| LogStore::new(cx));
+
+    cx.observe_new(move |workspace: &mut Workspace, window, cx| {
+        let Some(_window) = window else {
+            return;
+        };
+
+        let project = workspace.project();
+        if project.read(cx).is_local() {
+            log_store.update(cx, |store, cx| {
+                store.add_project(project, cx);
+            });
+        }
+
+        let log_store = log_store.clone();
+        workspace.register_action(move |workspace, _: &OpenDebuggerAdapterLogs, window, cx| {
+            let project = workspace.project().read(cx);
+            if project.is_local() {
+                workspace.add_item_to_active_pane(
+                    Box::new(cx.new(|cx| {
+                        DapLogView::new(workspace.project().clone(), log_store.clone(), window, cx)
+                    })),
+                    None,
+                    true,
+                    window,
+                    cx,
+                );
+            }
+        });
+    })
+    .detach();
+}
+
+impl Item for DapLogView {
+    type Event = EditorEvent;
+
+    fn to_item_events(event: &Self::Event, f: impl FnMut(workspace::item::ItemEvent)) {
+        Editor::to_item_events(event, f)
+    }
+
+    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
+        Some("DAP Logs".into())
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        None
+    }
+
+    fn as_searchable(&self, handle: &Entity<Self>) -> Option<Box<dyn SearchableItemHandle>> {
+        Some(Box::new(handle.clone()))
+    }
+}
+
+impl SearchableItem for DapLogView {
+    type Match = <Editor as SearchableItem>::Match;
+
+    fn clear_matches(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        self.editor.update(cx, |e, cx| e.clear_matches(window, cx))
+    }
+
+    fn update_matches(
+        &mut self,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor
+            .update(cx, |e, cx| e.update_matches(matches, window, cx))
+    }
+
+    fn query_suggestion(&mut self, window: &mut Window, cx: &mut Context<Self>) -> String {
+        self.editor
+            .update(cx, |e, cx| e.query_suggestion(window, cx))
+    }
+
+    fn activate_match(
+        &mut self,
+        index: usize,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor
+            .update(cx, |e, cx| e.activate_match(index, matches, window, cx))
+    }
+
+    fn select_matches(
+        &mut self,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.editor
+            .update(cx, |e, cx| e.select_matches(matches, window, cx))
+    }
+
+    fn find_matches(
+        &mut self,
+        query: Arc<project::search::SearchQuery>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> gpui::Task<Vec<Self::Match>> {
+        self.editor
+            .update(cx, |e, cx| e.find_matches(query, window, cx))
+    }
+
+    fn replace(
+        &mut self,
+        _: &Self::Match,
+        _: &SearchQuery,
+        _window: &mut Window,
+        _: &mut Context<Self>,
+    ) {
+        // Since DAP Log is read-only, it doesn't make sense to support replace operation.
+    }
+
+    fn supported_options(&self) -> workspace::searchable::SearchOptions {
+        workspace::searchable::SearchOptions {
+            case: true,
+            word: true,
+            regex: true,
+            find_in_results: true,
+            // DAP log is read-only.
+            replacement: false,
+            selection: false,
+        }
+    }
+    fn active_match_index(
+        &mut self,
+        matches: &[Self::Match],
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<usize> {
+        self.editor
+            .update(cx, |e, cx| e.active_match_index(matches, window, cx))
+    }
+}
+
+impl Focusable for DapLogView {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+pub enum Event {
+    NewLogEntry {
+        id: SessionId,
+        entry: String,
+        kind: LogKind,
+    },
+}
+
+impl EventEmitter<Event> for LogStore {}
+impl EventEmitter<Event> for DapLogView {}
+impl EventEmitter<EditorEvent> for DapLogView {}
+impl EventEmitter<SearchEvent> for DapLogView {}

crates/debugger_tools/src/debugger_tools.rs

@@ -0,0 +1,8 @@
+mod dap_log;
+pub use dap_log::*;
+
+use gpui::App;
+
+pub fn init(cx: &mut App) {
+    dap_log::init(cx);
+}

crates/debugger_ui/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "debugger_ui"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[features]
+test-support = [
+    "dap/test-support",
+    "editor/test-support",
+    "gpui/test-support",
+    "project/test-support",
+    "util/test-support",
+    "workspace/test-support",
+]
+
+[dependencies]
+anyhow.workspace = true
+client.workspace = true
+collections.workspace = true
+command_palette_hooks.workspace = true
+dap.workspace = true
+editor.workspace = true
+feature_flags.workspace = true
+fuzzy.workspace = true
+gpui.workspace = true
+language.workspace = true
+log.workspace = true
+menu.workspace = true
+picker.workspace = true
+pretty_assertions.workspace = true
+project.workspace = true
+rpc.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+settings.workspace = true
+sum_tree.workspace = true
+sysinfo.workspace = true
+task.workspace = true
+tasks_ui.workspace = true
+terminal_view.workspace = true
+theme.workspace = true
+ui.workspace = true
+util.workspace = true
+workspace.workspace = true
+
+[dev-dependencies]
+dap = { workspace = true, features = ["test-support"] }
+editor = { workspace = true, features = ["test-support"] }
+env_logger.workspace = true
+gpui = { workspace = true, features = ["test-support"] }
+project = { workspace = true, features = ["test-support"] }
+unindent.workspace = true
+util = { workspace = true, features = ["test-support"] }
+workspace = { workspace = true, features = ["test-support"] }

crates/debugger_ui/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/debugger_ui/src/attach_modal.rs

@@ -0,0 +1,304 @@
+use dap::client::SessionId;
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::Subscription;
+use gpui::{DismissEvent, Entity, EventEmitter, Focusable, Render};
+use picker::{Picker, PickerDelegate};
+use project::debugger::dap_store::DapStore;
+use std::sync::Arc;
+use sysinfo::System;
+use ui::{prelude::*, Context, Tooltip};
+use ui::{ListItem, ListItemSpacing};
+use workspace::ModalView;
+
+#[derive(Debug, Clone)]
+struct _Candidate {
+    pid: u32,
+    name: String,
+    command: Vec<String>,
+}
+
+pub(crate) struct _AttachModalDelegate {
+    selected_index: usize,
+    matches: Vec<StringMatch>,
+    session_id: SessionId,
+    placeholder_text: Arc<str>,
+    dap_store: Entity<DapStore>,
+    client_id: SessionId,
+    candidates: Option<Vec<_Candidate>>,
+}
+
+impl _AttachModalDelegate {
+    pub fn _new(session_id: SessionId, client_id: SessionId, dap_store: Entity<DapStore>) -> Self {
+        Self {
+            client_id,
+            dap_store,
+            session_id,
+            candidates: None,
+            selected_index: 0,
+            matches: Vec::default(),
+            placeholder_text: Arc::from("Select the process you want to attach the debugger to"),
+        }
+    }
+}
+
+pub(crate) struct _AttachModal {
+    _subscription: Subscription,
+    pub(crate) picker: Entity<Picker<_AttachModalDelegate>>,
+}
+
+impl _AttachModal {
+    pub fn _new(
+        session_id: &SessionId,
+        client_id: SessionId,
+        dap_store: Entity<DapStore>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let picker = cx.new(|cx| {
+            Picker::uniform_list(
+                _AttachModalDelegate::_new(*session_id, client_id, dap_store),
+                window,
+                cx,
+            )
+        });
+        let _subscription = cx.subscribe(&picker, |_, _, _, cx| {
+            cx.emit(DismissEvent);
+        });
+        Self {
+            picker,
+            _subscription,
+        }
+    }
+}
+
+impl Render for _AttachModal {
+    fn render(&mut self, _window: &mut Window, _: &mut Context<Self>) -> impl ui::IntoElement {
+        v_flex()
+            .key_context("AttachModal")
+            .w(rems(34.))
+            .child(self.picker.clone())
+    }
+}
+
+impl EventEmitter<DismissEvent> for _AttachModal {}
+
+impl Focusable for _AttachModal {
+    fn focus_handle(&self, cx: &App) -> gpui::FocusHandle {
+        self.picker.read(cx).focus_handle(cx)
+    }
+}
+
+impl ModalView for _AttachModal {}
+
+impl PickerDelegate for _AttachModalDelegate {
+    type ListItem = ListItem;
+
+    fn match_count(&self) -> usize {
+        self.matches.len()
+    }
+
+    fn selected_index(&self) -> usize {
+        self.selected_index
+    }
+
+    fn set_selected_index(
+        &mut self,
+        ix: usize,
+        _window: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) {
+        self.selected_index = ix;
+    }
+
+    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> std::sync::Arc<str> {
+        self.placeholder_text.clone()
+    }
+
+    fn update_matches(
+        &mut self,
+        query: String,
+        _window: &mut Window,
+        cx: &mut Context<Picker<Self>>,
+    ) -> gpui::Task<()> {
+        cx.spawn(|this, mut cx| async move {
+            let Some(processes) = this
+                .update(&mut cx, |this, cx| {
+                    if let Some(processes) = this.delegate.candidates.clone() {
+                        processes
+                    } else {
+                        let Some(_client) = this.delegate.dap_store.update(cx, |store, cx| {
+                            store
+                                .session_by_id(&this.delegate.client_id)
+                                .and_then(|client| client.read(cx).adapter_client())
+                        }) else {
+                            return Vec::new();
+                        };
+
+                        let _system = System::new_all();
+
+                        todo!("client.adapter().attach_processes(&system.processes())");
+                        // let processes: Vec<(&sysinfo::Pid, &sysinfo::Process)> = vec![];
+
+                        // let processes = processes
+                        //     .into_iter()
+                        //     .map(|(pid, process)| _Candidate {
+                        //         pid: pid.as_u32(),
+                        //         name: process.name().to_string_lossy().into_owned(),
+                        //         command: process
+                        //             .cmd()
+                        //             .iter()
+                        //             .map(|s| s.to_string_lossy().to_string())
+                        //             .collect::<Vec<_>>(),
+                        //     })
+                        //     .collect::<Vec<_Candidate>>();
+
+                        // let _ = this.delegate.candidates.insert(processes.clone());
+
+                        // processes
+                    }
+                })
+                .ok()
+            else {
+                return;
+            };
+
+            let matches = fuzzy::match_strings(
+                &processes
+                    .iter()
+                    .enumerate()
+                    .map(|(id, candidate)| {
+                        StringMatchCandidate::new(
+                            id,
+                            format!(
+                                "{} {} {}",
+                                candidate.command.join(" "),
+                                candidate.pid,
+                                candidate.name
+                            )
+                            .as_str(),
+                        )
+                    })
+                    .collect::<Vec<_>>(),
+                &query,
+                true,
+                100,
+                &Default::default(),
+                cx.background_executor().clone(),
+            )
+            .await;
+
+            this.update(&mut cx, |this, _| {
+                let delegate = &mut this.delegate;
+
+                delegate.matches = matches;
+                delegate.candidates = Some(processes);
+
+                if delegate.matches.is_empty() {
+                    delegate.selected_index = 0;
+                } else {
+                    delegate.selected_index =
+                        delegate.selected_index.min(delegate.matches.len() - 1);
+                }
+            })
+            .ok();
+        })
+    }
+
+    fn confirm(&mut self, _: bool, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        let candidate = self
+            .matches
+            .get(self.selected_index())
+            .and_then(|current_match| {
+                let ix = current_match.candidate_id;
+                self.candidates.as_ref().map(|candidates| &candidates[ix])
+            });
+        let Some(_candidate) = candidate else {
+            return cx.emit(DismissEvent);
+        };
+
+        unimplemented!(
+            r#"self.dap_store.update(cx, |store, cx| {{
+            store
+                .attach(self.client_id, candidate.pid, cx)
+                .detach_and_log_err(cx);
+        }})"#
+        );
+
+        // cx.emit(DismissEvent);
+    }
+
+    fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
+        self.selected_index = 0;
+        self.candidates.take();
+
+        self.dap_store.update(cx, |store, cx| {
+            store.shutdown_session(&self.session_id, cx).detach();
+        });
+
+        cx.emit(DismissEvent);
+    }
+
+    fn render_match(
+        &self,
+        ix: usize,
+        selected: bool,
+        _window: &mut Window,
+        _: &mut Context<Picker<Self>>,
+    ) -> Option<Self::ListItem> {
+        let candidates = self.candidates.as_ref()?;
+        let hit = &self.matches[ix];
+        let candidate = &candidates.get(hit.candidate_id)?;
+
+        Some(
+            ListItem::new(SharedString::from(format!("process-entry-{ix}")))
+                .inset(true)
+                .spacing(ListItemSpacing::Sparse)
+                .toggle_state(selected)
+                .child(
+                    v_flex()
+                        .items_start()
+                        .child(Label::new(format!("{} {}", candidate.name, candidate.pid)))
+                        .child(
+                            div()
+                                .id(SharedString::from(format!("process-entry-{ix}-command")))
+                                .tooltip(Tooltip::text(
+                                    candidate
+                                        .command
+                                        .clone()
+                                        .into_iter()
+                                        .collect::<Vec<_>>()
+                                        .join(" "),
+                                ))
+                                .child(
+                                    Label::new(format!(
+                                        "{} {}",
+                                        candidate.name,
+                                        candidate
+                                            .command
+                                            .clone()
+                                            .into_iter()
+                                            .skip(1)
+                                            .collect::<Vec<_>>()
+                                            .join(" ")
+                                    ))
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
+                                ),
+                        ),
+                ),
+        )
+    }
+}
+
+#[allow(dead_code)]
+#[cfg(any(test, feature = "test-support"))]
+pub(crate) fn procss_names(modal: &_AttachModal, cx: &mut Context<_AttachModal>) -> Vec<String> {
+    modal.picker.update(cx, |picker, _| {
+        picker
+            .delegate
+            .matches
+            .iter()
+            .map(|hit| hit.string.clone())
+            .collect::<Vec<_>>()
+    })
+}

crates/debugger_ui/src/debugger_panel.rs

@@ -0,0 +1,398 @@
+use crate::session::DebugSession;
+use anyhow::Result;
+use command_palette_hooks::CommandPaletteFilter;
+use dap::{
+    client::SessionId, debugger_settings::DebuggerSettings, ContinuedEvent, LoadedSourceEvent,
+    ModuleEvent, OutputEvent, StoppedEvent, ThreadEvent,
+};
+use gpui::{
+    actions, Action, App, AsyncWindowContext, Context, Entity, EventEmitter, FocusHandle,
+    Focusable, Subscription, Task, WeakEntity,
+};
+use project::{
+    debugger::dap_store::{self, DapStore},
+    Project,
+};
+use rpc::proto::{self};
+use settings::Settings;
+use std::any::TypeId;
+use ui::prelude::*;
+use workspace::{
+    dock::{DockPosition, Panel, PanelEvent},
+    pane, Continue, Disconnect, Pane, Pause, Restart, StepBack, StepInto, StepOut, StepOver, Stop,
+    ToggleIgnoreBreakpoints, Workspace,
+};
+
+pub enum DebugPanelEvent {
+    Exited(SessionId),
+    Terminated(SessionId),
+    Stopped {
+        client_id: SessionId,
+        event: StoppedEvent,
+        go_to_stack_frame: bool,
+    },
+    Thread((SessionId, ThreadEvent)),
+    Continued((SessionId, ContinuedEvent)),
+    Output((SessionId, OutputEvent)),
+    Module((SessionId, ModuleEvent)),
+    LoadedSource((SessionId, LoadedSourceEvent)),
+    ClientShutdown(SessionId),
+    CapabilitiesChanged(SessionId),
+}
+
+actions!(debug_panel, [ToggleFocus]);
+pub struct DebugPanel {
+    size: Pixels,
+    pane: Entity<Pane>,
+    project: WeakEntity<Project>,
+    workspace: WeakEntity<Workspace>,
+    _subscriptions: Vec<Subscription>,
+}
+
+impl DebugPanel {
+    pub fn new(
+        workspace: &Workspace,
+        window: &mut Window,
+        cx: &mut Context<Workspace>,
+    ) -> Entity<Self> {
+        cx.new(|cx| {
+            let project = workspace.project().clone();
+            let dap_store = project.read(cx).dap_store();
+            let weak_workspace = workspace.weak_handle();
+            let pane = cx.new(|cx| {
+                let mut pane = Pane::new(
+                    workspace.weak_handle(),
+                    workspace.project().clone(),
+                    Default::default(),
+                    None,
+                    gpui::NoAction.boxed_clone(),
+                    window,
+                    cx,
+                );
+                pane.set_can_split(None);
+                pane.set_can_navigate(true, cx);
+                pane.display_nav_history_buttons(None);
+                pane.set_should_display_tab_bar(|_window, _cx| true);
+                pane.set_close_pane_if_empty(true, cx);
+                pane.set_render_tab_bar_buttons(cx, {
+                    let project = project.clone();
+                    let weak_workspace = weak_workspace.clone();
+                    move |_, _, cx| {
+                        let project = project.clone();
+                        let weak_workspace = weak_workspace.clone();
+                        (
+                            None,
+                            Some(
+                                h_flex()
+                                    .child(
+                                        IconButton::new("new-debug-session", IconName::Plus)
+                                            .icon_size(IconSize::Small)
+                                            .on_click(cx.listener(move |pane, _, window, cx| {
+                                                pane.add_item(
+                                                    Box::new(DebugSession::inert(
+                                                        project.clone(),
+                                                        weak_workspace.clone(),
+                                                        window,
+                                                        cx,
+                                                    )),
+                                                    false,
+                                                    false,
+                                                    None,
+                                                    window,
+                                                    cx,
+                                                );
+                                            })),
+                                    )
+                                    .into_any_element(),
+                            ),
+                        )
+                    }
+                });
+                pane.add_item(
+                    Box::new(DebugSession::inert(
+                        project.clone(),
+                        weak_workspace.clone(),
+                        window,
+                        cx,
+                    )),
+                    false,
+                    false,
+                    None,
+                    window,
+                    cx,
+                );
+                pane
+            });
+
+            let _subscriptions = vec![
+                cx.observe(&pane, |_, _, cx| cx.notify()),
+                cx.subscribe_in(&pane, window, Self::handle_pane_event),
+                cx.subscribe_in(&dap_store, window, Self::handle_dap_store_event),
+            ];
+
+            let debug_panel = Self {
+                pane,
+                size: px(300.),
+                _subscriptions,
+                project: project.downgrade(),
+                workspace: workspace.weak_handle(),
+            };
+
+            debug_panel
+        })
+    }
+
+    pub fn load(
+        workspace: WeakEntity<Workspace>,
+        cx: AsyncWindowContext,
+    ) -> Task<Result<Entity<Self>>> {
+        cx.spawn(|mut cx| async move {
+            workspace.update_in(&mut cx, |workspace, window, cx| {
+                let debug_panel = DebugPanel::new(workspace, window, cx);
+
+                cx.observe(&debug_panel, |_, debug_panel, cx| {
+                    let (has_active_session, support_step_back) =
+                        debug_panel.update(cx, |this, cx| {
+                            this.active_debug_panel_item(cx)
+                                .map(|_item| (true, false))
+                                .unwrap_or((false, false))
+                        });
+
+                    let filter = CommandPaletteFilter::global_mut(cx);
+                    let debugger_action_types = [
+                        TypeId::of::<Continue>(),
+                        TypeId::of::<StepOver>(),
+                        TypeId::of::<StepInto>(),
+                        TypeId::of::<StepOut>(),
+                        TypeId::of::<Stop>(),
+                        TypeId::of::<Disconnect>(),
+                        TypeId::of::<Pause>(),
+                        TypeId::of::<Restart>(),
+                        TypeId::of::<ToggleIgnoreBreakpoints>(),
+                    ];
+
+                    let step_back_action_type = [TypeId::of::<StepBack>()];
+
+                    if has_active_session {
+                        filter.show_action_types(debugger_action_types.iter());
+
+                        if support_step_back {
+                            filter.show_action_types(step_back_action_type.iter());
+                        } else {
+                            filter.hide_action_types(&step_back_action_type);
+                        }
+                    } else {
+                        // show only the `debug: start`
+                        filter.hide_action_types(&debugger_action_types);
+                        filter.hide_action_types(&step_back_action_type);
+                    }
+                })
+                .detach();
+
+                debug_panel
+            })
+        })
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn message_queue(&self) -> &HashMap<SessionId, VecDeque<OutputEvent>> {
+        // &self.message_queue
+        unimplemented!("Should chekc session for console messagse")
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn dap_store(&self) -> Entity<DapStore> {
+        self.dap_store.clone()
+    }
+
+    pub fn active_debug_panel_item(&self, cx: &Context<Self>) -> Option<Entity<DebugSession>> {
+        self.pane
+            .read(cx)
+            .active_item()
+            .and_then(|panel| panel.downcast::<DebugSession>())
+    }
+
+    pub fn debug_panel_items_by_client(
+        &self,
+        client_id: &SessionId,
+        cx: &Context<Self>,
+    ) -> Vec<Entity<DebugSession>> {
+        self.pane
+            .read(cx)
+            .items()
+            .filter_map(|item| item.downcast::<DebugSession>())
+            .filter(|item| item.read(cx).session_id(cx) == Some(*client_id))
+            .map(|item| item.clone())
+            .collect()
+    }
+
+    pub fn debug_panel_item_by_client(
+        &self,
+        client_id: SessionId,
+        cx: &mut Context<Self>,
+    ) -> Option<Entity<DebugSession>> {
+        self.pane
+            .read(cx)
+            .items()
+            .filter_map(|item| item.downcast::<DebugSession>())
+            .find(|item| {
+                let item = item.read(cx);
+
+                item.session_id(cx) == Some(client_id)
+            })
+    }
+
+    fn handle_dap_store_event(
+        &mut self,
+        dap_store: &Entity<DapStore>,
+        event: &dap_store::DapStoreEvent,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            dap_store::DapStoreEvent::DebugClientStarted(session_id) => {
+                let Some(session) = dap_store.read(cx).session_by_id(session_id) else {
+                    return log::error!("Couldn't get session with id: {session_id:?} from DebugClientStarted event");
+                };
+
+                let Some(project) = self.project.upgrade() else {
+                    return log::error!("Debug Panel out lived it's weak reference to Project");
+                };
+
+                let session_item =
+                    DebugSession::running(project, self.workspace.clone(), session, window, cx);
+
+                self.pane.update(cx, |pane, cx| {
+                    pane.add_item(Box::new(session_item), true, true, None, window, cx);
+                    window.focus(&pane.focus_handle(cx));
+                    cx.notify();
+                });
+            }
+            _ => {}
+        }
+    }
+
+    fn handle_pane_event(
+        &mut self,
+        _: &Entity<Pane>,
+        event: &pane::Event,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            pane::Event::Remove { .. } => cx.emit(PanelEvent::Close),
+            pane::Event::ZoomIn => cx.emit(PanelEvent::ZoomIn),
+            pane::Event::ZoomOut => cx.emit(PanelEvent::ZoomOut),
+            pane::Event::AddItem { item } => {
+                self.workspace
+                    .update(cx, |workspace, cx| {
+                        item.added_to_pane(workspace, self.pane.clone(), window, cx)
+                    })
+                    .ok();
+            }
+            _ => {}
+        }
+    }
+}
+
+impl EventEmitter<PanelEvent> for DebugPanel {}
+impl EventEmitter<DebugPanelEvent> for DebugPanel {}
+impl EventEmitter<project::Event> for DebugPanel {}
+
+impl Focusable for DebugPanel {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        self.pane.focus_handle(cx)
+    }
+}
+
+impl Panel for DebugPanel {
+    fn pane(&self) -> Option<Entity<Pane>> {
+        Some(self.pane.clone())
+    }
+
+    fn persistent_name() -> &'static str {
+        "DebugPanel"
+    }
+
+    fn position(&self, _window: &Window, _cx: &App) -> DockPosition {
+        DockPosition::Bottom
+    }
+
+    fn position_is_valid(&self, position: DockPosition) -> bool {
+        position == DockPosition::Bottom
+    }
+
+    fn set_position(
+        &mut self,
+        _position: DockPosition,
+        _window: &mut Window,
+        _cx: &mut Context<Self>,
+    ) {
+    }
+
+    fn size(&self, _window: &Window, _cx: &App) -> Pixels {
+        self.size
+    }
+
+    fn set_size(&mut self, size: Option<Pixels>, _window: &mut Window, _cx: &mut Context<Self>) {
+        self.size = size.unwrap();
+    }
+
+    fn remote_id() -> Option<proto::PanelId> {
+        Some(proto::PanelId::DebugPanel)
+    }
+
+    fn icon(&self, _window: &Window, _cx: &App) -> Option<IconName> {
+        Some(IconName::Debug)
+    }
+
+    fn icon_tooltip(&self, _window: &Window, cx: &App) -> Option<&'static str> {
+        if DebuggerSettings::get_global(cx).button {
+            Some("Debug Panel")
+        } else {
+            None
+        }
+    }
+
+    fn toggle_action(&self) -> Box<dyn Action> {
+        Box::new(ToggleFocus)
+    }
+
+    fn activation_priority(&self) -> u32 {
+        9
+    }
+    fn set_active(&mut self, active: bool, window: &mut Window, cx: &mut Context<Self>) {
+        if active && self.pane.read(cx).items_len() == 0 {
+            let Some(project) = self.project.clone().upgrade() else {
+                return;
+            };
+            // todo: We need to revisit it when we start adding stopped items to pane (as that'll cause us to add two items).
+            self.pane.update(cx, |this, cx| {
+                this.add_item(
+                    Box::new(DebugSession::inert(
+                        project,
+                        self.workspace.clone(),
+                        window,
+                        cx,
+                    )),
+                    false,
+                    false,
+                    None,
+                    window,
+                    cx,
+                );
+            });
+        }
+    }
+}
+
+impl Render for DebugPanel {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .key_context("DebugPanel")
+            .track_focus(&self.focus_handle(cx))
+            .size_full()
+            .child(self.pane.clone())
+            .into_any()
+    }
+}

crates/debugger_ui/src/lib.rs

@@ -0,0 +1,52 @@
+use dap::debugger_settings::DebuggerSettings;
+use debugger_panel::{DebugPanel, ToggleFocus};
+use feature_flags::{Debugger, FeatureFlagViewExt};
+use gpui::App;
+use session::DebugSession;
+use settings::Settings;
+use workspace::{ShutdownDebugAdapters, Start, Workspace};
+
+pub mod attach_modal;
+pub mod debugger_panel;
+pub mod session;
+
+#[cfg(test)]
+mod tests;
+
+pub fn init(cx: &mut App) {
+    DebuggerSettings::register(cx);
+    workspace::FollowableViewRegistry::register::<DebugSession>(cx);
+
+    cx.observe_new(|_: &mut Workspace, window, cx| {
+        let Some(window) = window else {
+            return;
+        };
+
+        cx.when_flag_enabled::<Debugger>(window, |workspace, _, _| {
+            workspace
+                .register_action(|workspace, _: &ToggleFocus, window, cx| {
+                    workspace.toggle_panel_focus::<DebugPanel>(window, cx);
+                })
+                .register_action(|workspace: &mut Workspace, _: &Start, window, cx| {
+                    tasks_ui::toggle_modal(
+                        workspace,
+                        None,
+                        task::TaskModal::DebugModal,
+                        window,
+                        cx,
+                    )
+                    .detach();
+                })
+                .register_action(
+                    |workspace: &mut Workspace, _: &ShutdownDebugAdapters, _window, cx| {
+                        workspace.project().update(cx, |project, cx| {
+                            project.dap_store().update(cx, |store, cx| {
+                                store.shutdown_sessions(cx).detach();
+                            })
+                        })
+                    },
+                );
+        })
+    })
+    .detach();
+}

crates/debugger_ui/src/session.rs

@@ -0,0 +1,251 @@
+mod inert;
+mod running;
+mod starting;
+
+use dap::client::SessionId;
+use gpui::{
+    AnyElement, App, Entity, EventEmitter, FocusHandle, Focusable, Subscription, Task, WeakEntity,
+};
+use inert::{InertEvent, InertState};
+use project::debugger::{dap_store::DapStore, session::Session};
+use project::worktree_store::WorktreeStore;
+use project::Project;
+use rpc::proto::{self, PeerId};
+use running::RunningState;
+use starting::{StartingEvent, StartingState};
+use ui::prelude::*;
+use workspace::{
+    item::{self, Item},
+    FollowableItem, ViewId, Workspace,
+};
+
+enum DebugSessionState {
+    Inert(Entity<InertState>),
+    Starting(Entity<StartingState>),
+    Running(Entity<running::RunningState>),
+}
+
+pub struct DebugSession {
+    remote_id: Option<workspace::ViewId>,
+    mode: DebugSessionState,
+    dap_store: WeakEntity<DapStore>,
+    worktree_store: WeakEntity<WorktreeStore>,
+    workspace: WeakEntity<Workspace>,
+    _subscriptions: [Subscription; 1],
+}
+#[derive(Debug)]
+pub enum DebugPanelItemEvent {
+    Close,
+    Stopped { go_to_stack_frame: bool },
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub enum ThreadItem {
+    Console,
+    LoadedSource,
+    Modules,
+    Variables,
+}
+
+impl DebugSession {
+    pub(super) fn inert(
+        project: Entity<Project>,
+        workspace: WeakEntity<Workspace>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Entity<Self> {
+        let inert = cx.new(|cx| InertState::new(window, cx));
+
+        let project = project.read(cx);
+        let dap_store = project.dap_store().downgrade();
+        let worktree_store = project.worktree_store().downgrade();
+        cx.new(|cx| {
+            let _subscriptions = [cx.subscribe_in(&inert, window, Self::on_inert_event)];
+            Self {
+                remote_id: None,
+                mode: DebugSessionState::Inert(inert),
+                dap_store,
+                worktree_store,
+                workspace,
+                _subscriptions,
+            }
+        })
+    }
+
+    pub(crate) fn running(
+        project: Entity<Project>,
+        workspace: WeakEntity<Workspace>,
+        session: Entity<Session>,
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Entity<Self> {
+        let mode = DebugSessionState::Running(
+            cx.new(|cx| RunningState::new(session.clone(), workspace.clone(), window, cx)),
+        );
+
+        cx.new(|cx| Self {
+            remote_id: None,
+            mode,
+            dap_store: project.read(cx).dap_store().downgrade(),
+            worktree_store: project.read(cx).worktree_store().downgrade(),
+            workspace,
+            _subscriptions: [cx.subscribe(&project, |_, _, _, _| {})], // todo(debugger) We don't need this subscription
+        })
+    }
+
+    pub(crate) fn session_id(&self, cx: &App) -> Option<SessionId> {
+        match &self.mode {
+            DebugSessionState::Inert(_) => None,
+            DebugSessionState::Starting(_entity) => unimplemented!(),
+            DebugSessionState::Running(entity) => Some(entity.read(cx).session_id()),
+        }
+    }
+    fn on_inert_event(
+        &mut self,
+        _: &Entity<InertState>,
+        event: &InertEvent,
+        window: &mut Window,
+        cx: &mut Context<'_, Self>,
+    ) {
+        let dap_store = self.dap_store.clone();
+        let InertEvent::Spawned { config } = event;
+        let config = config.clone();
+        let worktree = self
+            .worktree_store
+            .update(cx, |this, _| this.worktrees().next())
+            .ok()
+            .flatten()
+            .expect("worktree-less project");
+        let Ok(task) = dap_store.update(cx, |store, cx| {
+            store.new_session(config, &worktree, None, cx)
+        }) else {
+            return;
+        };
+        let starting = cx.new(|cx| StartingState::new(task, cx));
+
+        self._subscriptions = [cx.subscribe_in(&starting, window, Self::on_starting_event)];
+        self.mode = DebugSessionState::Starting(starting);
+    }
+
+    fn on_starting_event(
+        &mut self,
+        _: &Entity<StartingState>,
+        event: &StartingEvent,
+        window: &mut Window,
+        cx: &mut Context<'_, Self>,
+    ) {
+        let StartingEvent::Finished(Ok(session)) = event else {
+            return;
+        };
+
+        let mode =
+            cx.new(|cx| RunningState::new(session.clone(), self.workspace.clone(), window, cx));
+
+        self.mode = DebugSessionState::Running(mode);
+    }
+}
+impl EventEmitter<DebugPanelItemEvent> for DebugSession {}
+
+impl Focusable for DebugSession {
+    fn focus_handle(&self, cx: &App) -> FocusHandle {
+        match &self.mode {
+            DebugSessionState::Inert(inert_state) => inert_state.focus_handle(cx),
+            DebugSessionState::Starting(starting_state) => starting_state.focus_handle(cx),
+            DebugSessionState::Running(running_state) => running_state.focus_handle(cx),
+        }
+    }
+}
+
+impl Item for DebugSession {
+    type Event = DebugPanelItemEvent;
+    fn tab_content(&self, _: item::TabContentParams, _: &Window, _: &App) -> AnyElement {
+        let label = match &self.mode {
+            DebugSessionState::Inert(_) => "New Session",
+            DebugSessionState::Starting(_) => "Starting",
+            DebugSessionState::Running(_) => "Running",
+        };
+        div().child(Label::new(label)).into_any_element()
+    }
+}
+
+impl FollowableItem for DebugSession {
+    fn remote_id(&self) -> Option<workspace::ViewId> {
+        self.remote_id
+    }
+
+    fn to_state_proto(&self, _window: &Window, _cx: &App) -> Option<proto::view::Variant> {
+        None
+    }
+
+    fn from_state_proto(
+        _workspace: Entity<Workspace>,
+        _remote_id: ViewId,
+        _state: &mut Option<proto::view::Variant>,
+        _window: &mut Window,
+        _cx: &mut App,
+    ) -> Option<gpui::Task<gpui::Result<Entity<Self>>>> {
+        None
+    }
+
+    fn add_event_to_update_proto(
+        &self,
+        _event: &Self::Event,
+        _update: &mut Option<proto::update_view::Variant>,
+        _window: &Window,
+        _cx: &App,
+    ) -> bool {
+        // update.get_or_insert_with(|| proto::update_view::Variant::DebugPanel(Default::default()));
+
+        true
+    }
+
+    fn apply_update_proto(
+        &mut self,
+        _project: &Entity<project::Project>,
+        _message: proto::update_view::Variant,
+        _window: &mut Window,
+        _cx: &mut Context<Self>,
+    ) -> gpui::Task<gpui::Result<()>> {
+        Task::ready(Ok(()))
+    }
+
+    fn set_leader_peer_id(
+        &mut self,
+        _leader_peer_id: Option<PeerId>,
+        _window: &mut Window,
+        _cx: &mut Context<Self>,
+    ) {
+    }
+
+    fn to_follow_event(_event: &Self::Event) -> Option<workspace::item::FollowEvent> {
+        None
+    }
+
+    fn dedup(&self, existing: &Self, _window: &Window, cx: &App) -> Option<workspace::item::Dedup> {
+        if existing.session_id(cx) == self.session_id(cx) {
+            Some(item::Dedup::KeepExisting)
+        } else {
+            None
+        }
+    }
+
+    fn is_project_item(&self, _window: &Window, _cx: &App) -> bool {
+        true
+    }
+}
+
+impl Render for DebugSession {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<'_, Self>) -> impl IntoElement {
+        match &self.mode {
+            DebugSessionState::Inert(inert_state) => {
+                inert_state.update(cx, |this, cx| this.render(window, cx).into_any_element())
+            }
+            DebugSessionState::Starting(starting_state) => {
+                starting_state.update(cx, |this, cx| this.render(window, cx).into_any_element())
+            }
+            DebugSessionState::Running(running_state) => {
+                running_state.update(cx, |this, cx| this.render(window, cx).into_any_element())
+            }
+        }
+    }
+}

crates/debugger_ui/src/session/inert.rs

@@ -0,0 +1,165 @@
+use std::path::PathBuf;
+
+use dap::{DebugAdapterConfig, DebugAdapterKind, DebugRequestType};
+use editor::{Editor, EditorElement, EditorStyle};
+use gpui::{App, AppContext, Entity, EventEmitter, FocusHandle, Focusable, TextStyle};
+use settings::Settings as _;
+use task::TCPHost;
+use theme::ThemeSettings;
+use ui::{
+    h_flex, relative, v_flex, ActiveTheme as _, Button, ButtonCommon, ButtonStyle, Clickable,
+    Context, ContextMenu, DropdownMenu, InteractiveElement, IntoElement, Label, ParentElement,
+    Render, SharedString, Styled, Window,
+};
+
+pub(super) struct InertState {
+    focus_handle: FocusHandle,
+    selected_debugger: Option<SharedString>,
+    program_editor: Entity<Editor>,
+    cwd_editor: Entity<Editor>,
+}
+
+impl InertState {
+    pub(super) fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
+        Self {
+            focus_handle: cx.focus_handle(),
+            selected_debugger: None,
+            program_editor: cx.new(|cx| Editor::single_line(window, cx)),
+            cwd_editor: cx.new(|cx| Editor::single_line(window, cx)),
+        }
+    }
+}
+impl Focusable for InertState {
+    fn focus_handle(&self, _cx: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+pub(crate) enum InertEvent {
+    Spawned { config: DebugAdapterConfig },
+}
+
+impl EventEmitter<InertEvent> for InertState {}
+
+static SELECT_DEBUGGER_LABEL: SharedString = SharedString::new_static("Select Debugger");
+
+impl Render for InertState {
+    fn render(
+        &mut self,
+        window: &mut ui::Window,
+        cx: &mut ui::Context<'_, Self>,
+    ) -> impl ui::IntoElement {
+        let weak = cx.weak_entity();
+        v_flex()
+            .track_focus(&self.focus_handle)
+            .size_full()
+            .gap_1()
+            .p_1()
+            .child(
+                h_flex().child(DropdownMenu::new(
+                    "dap-adapter-picker",
+                    self.selected_debugger
+                        .as_ref()
+                        .unwrap_or_else(|| &SELECT_DEBUGGER_LABEL)
+                        .clone(),
+                    ContextMenu::build(window, cx, move |this, _, _| {
+                        let setter_for_name = |name: &'static str| {
+                            let weak = weak.clone();
+                            move |_: &mut Window, cx: &mut App| {
+                                let name = name;
+                                (&weak)
+                                    .update(cx, move |this, _| {
+                                        this.selected_debugger = Some(name.into());
+                                    })
+                                    .ok();
+                            }
+                        };
+                        this.entry("GDB", None, setter_for_name("GDB"))
+                            .entry("Delve", None, setter_for_name("Delve"))
+                            .entry("LLDB", None, setter_for_name("LLDB"))
+                            .entry("PHP", None, setter_for_name("PHP"))
+                            .entry("JavaScript", None, setter_for_name("JavaScript"))
+                            .entry("Debugpy", None, setter_for_name("Debugpy"))
+                    }),
+                )),
+            )
+            .child(
+                v_flex()
+                    .child(
+                        h_flex()
+                            .w_4_5()
+                            .gap_2()
+                            .child(Label::new("Program path"))
+                            .child(Self::render_editor(&self.program_editor, cx)),
+                    )
+                    .child(
+                        h_flex()
+                            .gap_2()
+                            .child(Label::new("Working directory"))
+                            .child(Self::render_editor(&self.cwd_editor, cx)),
+                    ),
+            )
+            .child(
+                h_flex()
+                    .gap_1()
+                    .child(
+                        Button::new("launch-dap", "Launch")
+                            .style(ButtonStyle::Filled)
+                            .on_click(cx.listener(|this, _, _, cx| {
+                                let program = this.program_editor.read(cx).text(cx);
+                                let cwd = PathBuf::from(this.cwd_editor.read(cx).text(cx));
+                                let kind = kind_for_label(this.selected_debugger.as_deref().unwrap_or_else(|| unimplemented!("Automatic selection of a debugger based on users project")));
+                                cx.emit(InertEvent::Spawned {
+                                    config: DebugAdapterConfig {
+                                        label: "hard coded".into(),
+                                        kind,
+                                        request: DebugRequestType::Launch,
+                                        program: Some(program),
+                                        cwd: Some(cwd),
+                                        initialize_args: None,
+                                        supports_attach: false,
+                                    },
+                                });
+                            })),
+                    )
+                    .child(Button::new("attach-dap", "Attach").style(ButtonStyle::Filled)),
+            )
+    }
+}
+
+fn kind_for_label(label: &str) -> DebugAdapterKind {
+    match label {
+        "LLDB" => DebugAdapterKind::Lldb,
+        "Debugpy" => DebugAdapterKind::Python(TCPHost::default()),
+        "JavaScript" => DebugAdapterKind::Javascript(TCPHost::default()),
+        "PHP" => DebugAdapterKind::Php(TCPHost::default()),
+        "Delve" => DebugAdapterKind::Go(TCPHost::default()),
+        _ => {
+            unimplemented!()
+        } // Maybe we should set a toast notification here
+    }
+}
+impl InertState {
+    fn render_editor(editor: &Entity<Editor>, cx: &Context<Self>) -> impl IntoElement {
+        let settings = ThemeSettings::get_global(cx);
+        let text_style = TextStyle {
+            color: cx.theme().colors().text,
+            font_family: settings.buffer_font.family.clone(),
+            font_features: settings.buffer_font.features.clone(),
+            font_size: settings.buffer_font_size(cx).into(),
+            font_weight: settings.buffer_font.weight,
+            line_height: relative(settings.buffer_line_height.value()),
+            ..Default::default()
+        };
+
+        EditorElement::new(
+            editor,
+            EditorStyle {
+                background: cx.theme().colors().editor_background,
+                local_player: cx.theme().players().local(),
+                text: text_style,
+                ..Default::default()
+            },
+        )
+    }
+}

crates/debugger_ui/src/session/running.rs

@@ -0,0 +1,680 @@
+mod console;
+mod loaded_source_list;
+mod module_list;
+mod stack_frame_list;
+mod variable_list;
+
+use super::{DebugPanelItemEvent, ThreadItem};
+use console::Console;
+use dap::{client::SessionId, debugger_settings::DebuggerSettings, Capabilities};
+use gpui::{AppContext, Entity, EventEmitter, FocusHandle, Focusable, Subscription, WeakEntity};
+use loaded_source_list::LoadedSourceList;
+use module_list::ModuleList;
+use project::debugger::session::{Session, ThreadId, ThreadStatus};
+use rpc::proto::ViewId;
+use settings::Settings;
+use stack_frame_list::{StackFrameList, StackFrameListEvent};
+use ui::{
+    div, h_flex, v_flex, ActiveTheme, AnyElement, App, Button, ButtonCommon, Clickable, Context,
+    ContextMenu, Disableable, DropdownMenu, FluentBuilder, IconButton, IconName, IconSize,
+    Indicator, InteractiveElement, IntoElement, ParentElement, Render, SharedString,
+    StatefulInteractiveElement, Styled, Tooltip, Window,
+};
+use variable_list::VariableList;
+use workspace::{item::ItemEvent, Item, Workspace};
+
+pub struct RunningState {
+    session: Entity<Session>,
+    thread: Option<(ThreadId, String)>,
+    console: Entity<console::Console>,
+    focus_handle: FocusHandle,
+    _remote_id: Option<ViewId>,
+    show_console_indicator: bool,
+    module_list: Entity<module_list::ModuleList>,
+    active_thread_item: ThreadItem,
+    _workspace: WeakEntity<Workspace>,
+    session_id: SessionId,
+    variable_list: Entity<variable_list::VariableList>,
+    _subscriptions: Vec<Subscription>,
+    stack_frame_list: Entity<stack_frame_list::StackFrameList>,
+    loaded_source_list: Entity<loaded_source_list::LoadedSourceList>,
+}
+
+impl Render for RunningState {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let threads = self.session.update(cx, |this, cx| this.threads(cx));
+        if let Some((thread, _)) = threads.first().filter(|_| self.thread.is_none()) {
+            self.select_thread(ThreadId(thread.id), thread.name.clone(), cx);
+        }
+
+        let thread_status = self
+            .thread
+            .as_ref()
+            .map(|(thread_id, _)| self.session.read(cx).thread_status(*thread_id))
+            .unwrap_or(ThreadStatus::Exited);
+        let is_terminated = self.session.read(cx).is_terminated();
+        let active_thread_item = &self.active_thread_item;
+
+        let has_no_threads = threads.is_empty();
+        let capabilities = self.capabilities(cx);
+        let state = cx.entity();
+        h_flex()
+            .when(is_terminated, |this| this.bg(gpui::red()))
+            .key_context("DebugPanelItem")
+            .track_focus(&self.focus_handle(cx))
+            .size_full()
+            .items_start()
+            .child(
+                v_flex()
+                    .size_full()
+                    .items_start()
+                    .child(
+                        h_flex()
+                            .w_full()
+                            .border_b_1()
+                            .border_color(cx.theme().colors().border_variant)
+                            .justify_between()
+                            .child(
+                                h_flex()
+                                    .p_1()
+                                    .w_full()
+                                    .gap_2()
+                                    .map(|this| {
+                                        if thread_status == ThreadStatus::Running {
+                                            this.child(
+                                                IconButton::new(
+                                                    "debug-pause",
+                                                    IconName::DebugPause,
+                                                )
+                                                .icon_size(IconSize::Small)
+                                                .on_click(cx.listener(|this, _, _window, cx| {
+                                                    this.pause_thread(cx);
+                                                }))
+                                                .tooltip(move |window, cx| {
+                                                    Tooltip::text("Pause program")(window, cx)
+                                                }),
+                                            )
+                                        } else {
+                                            this.child(
+                                                IconButton::new(
+                                                    "debug-continue",
+                                                    IconName::DebugContinue,
+                                                )
+                                                .icon_size(IconSize::Small)
+                                                .on_click(cx.listener(|this, _, _window, cx| {
+                                                    this.continue_thread(cx)
+                                                }))
+                                                .disabled(thread_status != ThreadStatus::Stopped)
+                                                .tooltip(move |window, cx| {
+                                                    Tooltip::text("Continue program")(window, cx)
+                                                }),
+                                            )
+                                        }
+                                    })
+                                    .when(
+                                        capabilities.supports_step_back.unwrap_or(false),
+                                        |this| {
+                                            this.child(
+                                                IconButton::new(
+                                                    "debug-step-back",
+                                                    IconName::DebugStepBack,
+                                                )
+                                                .icon_size(IconSize::Small)
+                                                .on_click(cx.listener(|this, _, _window, cx| {
+                                                    this.step_back(cx);
+                                                }))
+                                                .disabled(thread_status != ThreadStatus::Stopped)
+                                                .tooltip(move |window, cx| {
+                                                    Tooltip::text("Step back")(window, cx)
+                                                }),
+                                            )
+                                        },
+                                    )
+                                    .child(
+                                        IconButton::new("debug-step-over", IconName::DebugStepOver)
+                                            .icon_size(IconSize::Small)
+                                            .on_click(cx.listener(|this, _, _window, cx| {
+                                                this.step_over(cx);
+                                            }))
+                                            .disabled(thread_status != ThreadStatus::Stopped)
+                                            .tooltip(move |window, cx| {
+                                                Tooltip::text("Step over")(window, cx)
+                                            }),
+                                    )
+                                    .child(
+                                        IconButton::new("debug-step-in", IconName::DebugStepInto)
+                                            .icon_size(IconSize::Small)
+                                            .on_click(cx.listener(|this, _, _window, cx| {
+                                                this.step_in(cx);
+                                            }))
+                                            .disabled(thread_status != ThreadStatus::Stopped)
+                                            .tooltip(move |window, cx| {
+                                                Tooltip::text("Step in")(window, cx)
+                                            }),
+                                    )
+                                    .child(
+                                        IconButton::new("debug-step-out", IconName::DebugStepOut)
+                                            .icon_size(IconSize::Small)
+                                            .on_click(cx.listener(|this, _, _window, cx| {
+                                                this.step_out(cx);
+                                            }))
+                                            .disabled(thread_status != ThreadStatus::Stopped)
+                                            .tooltip(move |window, cx| {
+                                                Tooltip::text("Step out")(window, cx)
+                                            }),
+                                    )
+                                    .child(
+                                        IconButton::new("debug-restart", IconName::DebugRestart)
+                                            .icon_size(IconSize::Small)
+                                            .on_click(cx.listener(|this, _, _window, cx| {
+                                                this.restart_client(cx);
+                                            }))
+                                            .disabled(
+                                                !capabilities
+                                                    .supports_restart_request
+                                                    .unwrap_or_default(),
+                                            )
+                                            .tooltip(move |window, cx| {
+                                                Tooltip::text("Restart")(window, cx)
+                                            }),
+                                    )
+                                    .child(
+                                        IconButton::new("debug-stop", IconName::DebugStop)
+                                            .icon_size(IconSize::Small)
+                                            .on_click(cx.listener(|this, _, _window, cx| {
+                                                this.stop_thread(cx);
+                                            }))
+                                            .disabled(
+                                                thread_status != ThreadStatus::Stopped
+                                                    && thread_status != ThreadStatus::Running,
+                                            )
+                                            .tooltip(move |window, cx| {
+                                                Tooltip::text("Stop")(window, cx)
+                                            }),
+                                    )
+                                    .child(
+                                        IconButton::new(
+                                            "debug-disconnect",
+                                            IconName::DebugDisconnect,
+                                        )
+                                        .icon_size(IconSize::Small)
+                                        .on_click(cx.listener(|this, _, _window, cx| {
+                                            this.disconnect_client(cx);
+                                        }))
+                                        .disabled(
+                                            thread_status == ThreadStatus::Exited
+                                                || thread_status == ThreadStatus::Ended,
+                                        )
+                                        .tooltip(
+                                            move |window, cx| {
+                                                Tooltip::text("Disconnect")(window, cx)
+                                            },
+                                        ),
+                                    )
+                                    .child(
+                                        IconButton::new(
+                                            "debug-ignore-breakpoints",
+                                            if self.session.read(cx).breakpoints_enabled() {
+                                                IconName::DebugBreakpoint
+                                            } else {
+                                                IconName::DebugIgnoreBreakpoints
+                                            },
+                                        )
+                                        .icon_size(IconSize::Small)
+                                        .on_click(cx.listener(|this, _, _window, cx| {
+                                            this.toggle_ignore_breakpoints(cx);
+                                        }))
+                                        .disabled(
+                                            thread_status == ThreadStatus::Exited
+                                                || thread_status == ThreadStatus::Ended,
+                                        )
+                                        .tooltip(
+                                            move |window, cx| {
+                                                Tooltip::text("Ignore breakpoints")(window, cx)
+                                            },
+                                        ),
+                                    ),
+                            )
+                            //.child(h_flex())
+                            .child(
+                                h_flex().p_1().mx_2().w_3_4().justify_end().child(
+                                    DropdownMenu::new(
+                                        ("thread-list", self.session_id.0),
+                                        self.thread
+                                            .as_ref()
+                                            .map(|(_, name)| format!("Thread {name}"))
+                                            .unwrap_or_else(|| "Threads".into()),
+                                        ContextMenu::build(window, cx, move |mut this, _, _| {
+                                            for (thread, _) in threads {
+                                                let state = state.clone();
+                                                let thread_id = thread.id;
+                                                let thread_name = SharedString::from(&thread.name);
+                                                this =
+                                                    this.entry(thread.name, None, move |_, cx| {
+                                                        state.update(cx, |state, cx| {
+                                                            state.select_thread(
+                                                                ThreadId(thread_id),
+                                                                String::from(thread_name.as_ref()),
+                                                                cx,
+                                                            );
+                                                        });
+                                                    });
+                                            }
+                                            this
+                                        }),
+                                    )
+                                    .disabled(has_no_threads),
+                                ),
+                            ),
+                    )
+                    .child(
+                        h_flex()
+                            .size_full()
+                            .items_start()
+                            .p_1()
+                            .gap_4()
+                            .child(self.stack_frame_list.clone()),
+                    ),
+            )
+            .child(
+                v_flex()
+                    .border_l_1()
+                    .border_color(cx.theme().colors().border_variant)
+                    .size_full()
+                    .items_start()
+                    .child(
+                        h_flex()
+                            .border_b_1()
+                            .w_full()
+                            .border_color(cx.theme().colors().border_variant)
+                            .child(self.render_entry_button(
+                                &SharedString::from("Variables"),
+                                ThreadItem::Variables,
+                                cx,
+                            ))
+                            .when(
+                                capabilities.supports_modules_request.unwrap_or_default(),
+                                |this| {
+                                    this.child(self.render_entry_button(
+                                        &SharedString::from("Modules"),
+                                        ThreadItem::Modules,
+                                        cx,
+                                    ))
+                                },
+                            )
+                            .when(
+                                capabilities
+                                    .supports_loaded_sources_request
+                                    .unwrap_or_default(),
+                                |this| {
+                                    this.child(self.render_entry_button(
+                                        &SharedString::from("Loaded Sources"),
+                                        ThreadItem::LoadedSource,
+                                        cx,
+                                    ))
+                                },
+                            )
+                            .child(self.render_entry_button(
+                                &SharedString::from("Console"),
+                                ThreadItem::Console,
+                                cx,
+                            )),
+                    )
+                    .when(*active_thread_item == ThreadItem::Variables, |this| {
+                        this.size_full().child(self.variable_list.clone())
+                    })
+                    .when(*active_thread_item == ThreadItem::Modules, |this| {
+                        this.size_full().child(self.module_list.clone())
+                    })
+                    .when(*active_thread_item == ThreadItem::LoadedSource, |this| {
+                        this.size_full().child(self.loaded_source_list.clone())
+                    })
+                    .when(*active_thread_item == ThreadItem::Console, |this| {
+                        this.child(self.console.clone())
+                    }),
+            )
+    }
+}
+
+impl RunningState {
+    pub fn new(
+        session: Entity<Session>,
+        workspace: WeakEntity<Workspace>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let focus_handle = cx.focus_handle();
+        let session_id = session.read(cx).session_id();
+        let stack_frame_list =
+            cx.new(|cx| StackFrameList::new(workspace.clone(), session.clone(), cx));
+
+        let variable_list =
+            cx.new(|cx| VariableList::new(session.clone(), stack_frame_list.clone(), window, cx));
+
+        let module_list = cx.new(|cx| ModuleList::new(session.clone(), cx));
+
+        let loaded_source_list = cx.new(|cx| LoadedSourceList::new(session.clone(), cx));
+
+        let console = cx.new(|cx| {
+            Console::new(
+                session.clone(),
+                stack_frame_list.clone(),
+                variable_list.clone(),
+                window,
+                cx,
+            )
+        });
+
+        cx.observe(&module_list, |_, _, cx| cx.notify()).detach();
+
+        let _subscriptions = vec![cx.subscribe(
+            &stack_frame_list,
+            move |this: &mut Self, _, event: &StackFrameListEvent, cx| match event {
+                StackFrameListEvent::SelectedStackFrameChanged(_) => this.clear_highlights(cx),
+            },
+        )];
+
+        Self {
+            session,
+            console,
+            _workspace: workspace,
+            module_list,
+            focus_handle,
+            variable_list,
+            _subscriptions,
+            thread: None,
+            _remote_id: None,
+            stack_frame_list,
+            loaded_source_list,
+            session_id,
+            show_console_indicator: false,
+            active_thread_item: ThreadItem::Variables,
+        }
+    }
+
+    // pub(crate) fn update_adapter(
+    //     &mut self,
+    //     update: &UpdateDebugAdapter,
+    //     window: &mut Window,
+    //     cx: &mut Context<Self>,
+    // ) {
+    //     if let Some(update_variant) = update.variant.as_ref() {
+    //         match update_variant {
+    //             proto::update_debug_adapter::Variant::StackFrameList(stack_frame_list) => {
+    //                 self.stack_frame_list.update(cx, |this, cx| {
+    //                     this.set_from_proto(stack_frame_list.clone(), cx);
+    //                 })
+    //             }
+    //             proto::update_debug_adapter::Variant::ThreadState(thread_state) => {
+    //                 self.thread_state.update(cx, |this, _| {
+    //                     *this = ThreadState::from_proto(thread_state.clone());
+    //                 })
+    //             }
+    //             proto::update_debug_adapter::Variant::VariableList(variable_list) => self
+    //                 .variable_list
+    //                 .update(cx, |this, cx| this.set_from_proto(variable_list, cx)),
+    //             proto::update_debug_adapter::Variant::AddToVariableList(variables_to_add) => self
+    //                 .variable_list
+    //                 .update(cx, |this, _| this.add_variables(variables_to_add.clone())),
+    //             proto::update_debug_adapter::Variant::Modules(_) => {}
+    //             proto::update_debug_adapter::Variant::OutputEvent(output_event) => {
+    //                 self.console.update(cx, |this, cx| {
+    //                     this.add_message(OutputEvent::from_proto(output_event.clone()), window, cx);
+    //                 })
+    //             }
+    //         }
+    //     }
+    // }
+
+    pub fn session(&self) -> &Entity<Session> {
+        &self.session
+    }
+
+    pub fn session_id(&self) -> SessionId {
+        self.session_id
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn set_thread_item(&mut self, thread_item: ThreadItem, cx: &mut Context<Self>) {
+        self.active_thread_item = thread_item;
+        cx.notify()
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn stack_frame_list(&self) -> &Entity<StackFrameList> {
+        &self.stack_frame_list
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn console(&self) -> &Entity<Console> {
+        &self.console
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn module_list(&self) -> &Entity<ModuleList> {
+        &self.module_list
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn variable_list(&self) -> &Entity<VariableList> {
+        &self.variable_list
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn are_breakpoints_ignored(&self, cx: &App) -> bool {
+        self.session.read(cx).ignore_breakpoints()
+    }
+
+    pub fn capabilities(&self, cx: &mut Context<Self>) -> Capabilities {
+        self.session().read(cx).capabilities().clone()
+    }
+
+    fn select_thread(&mut self, thread_id: ThreadId, thread_name: String, cx: &mut Context<Self>) {
+        self.thread = Some((thread_id, thread_name));
+
+        self.stack_frame_list.update(cx, |stack_frame_list, cx| {
+            stack_frame_list.set_thread_id(self.thread.as_ref().map(|id| id.0), cx);
+        });
+
+        cx.notify();
+    }
+
+    fn clear_highlights(&self, _cx: &mut Context<Self>) {
+        // TODO(debugger): make this work again
+        // if let Some((_, project_path, _)) = self.dap_store.read(cx).active_debug_line() {
+        //     self.workspace
+        //         .update(cx, |workspace, cx| {
+        //             let editor = workspace
+        //                 .items_of_type::<Editor>(cx)
+        //                 .find(|editor| Some(project_path.clone()) == editor.project_path(cx));
+
+        //             if let Some(editor) = editor {
+        //                 editor.update(cx, |editor, cx| {
+        //                     editor.clear_row_highlights::<editor::DebugCurrentRowHighlight>();
+
+        //                     cx.notify();
+        //                 });
+        //             }
+        //         })
+        //         .ok();
+        // }
+    }
+
+    pub fn _go_to_current_stack_frame(&self, window: &mut Window, cx: &mut Context<Self>) {
+        self.stack_frame_list.update(cx, |stack_frame_list, cx| {
+            if let Some(stack_frame) = stack_frame_list
+                .stack_frames(cx)
+                .iter()
+                .find(|frame| frame.dap.id == stack_frame_list.current_stack_frame_id())
+                .cloned()
+            {
+                stack_frame_list
+                    .select_stack_frame(&stack_frame.dap, true, window, cx)
+                    .detach_and_log_err(cx);
+            }
+        });
+    }
+
+    fn render_entry_button(
+        &self,
+        label: &SharedString,
+        thread_item: ThreadItem,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let has_indicator =
+            matches!(thread_item, ThreadItem::Console) && self.show_console_indicator;
+
+        div()
+            .id(label.clone())
+            .px_2()
+            .py_1()
+            .cursor_pointer()
+            .border_b_2()
+            .when(self.active_thread_item == thread_item, |this| {
+                this.border_color(cx.theme().colors().border)
+            })
+            .child(
+                h_flex()
+                    .child(Button::new(label.clone(), label.clone()))
+                    .when(has_indicator, |this| this.child(Indicator::dot())),
+            )
+            .on_click(cx.listener(move |this, _, _window, cx| {
+                this.active_thread_item = thread_item.clone();
+
+                if matches!(this.active_thread_item, ThreadItem::Console) {
+                    this.show_console_indicator = false;
+                }
+
+                cx.notify();
+            }))
+            .into_any_element()
+    }
+
+    pub fn continue_thread(&mut self, cx: &mut Context<Self>) {
+        let Some((thread_id, _)) = self.thread else {
+            return;
+        };
+
+        self.session().update(cx, |state, cx| {
+            state.continue_thread(thread_id, cx);
+        });
+    }
+
+    pub fn step_over(&mut self, cx: &mut Context<Self>) {
+        let Some((thread_id, _)) = self.thread else {
+            return;
+        };
+
+        let granularity = DebuggerSettings::get_global(cx).stepping_granularity;
+
+        self.session().update(cx, |state, cx| {
+            state.step_over(thread_id, granularity, cx);
+        });
+    }
+
+    pub fn step_in(&mut self, cx: &mut Context<Self>) {
+        let Some((thread_id, _)) = self.thread else {
+            return;
+        };
+
+        let granularity = DebuggerSettings::get_global(cx).stepping_granularity;
+
+        self.session().update(cx, |state, cx| {
+            state.step_in(thread_id, granularity, cx);
+        });
+    }
+
+    pub fn step_out(&mut self, cx: &mut Context<Self>) {
+        let Some((thread_id, _)) = self.thread else {
+            return;
+        };
+
+        let granularity = DebuggerSettings::get_global(cx).stepping_granularity;
+
+        self.session().update(cx, |state, cx| {
+            state.step_out(thread_id, granularity, cx);
+        });
+    }
+
+    pub fn step_back(&mut self, cx: &mut Context<Self>) {
+        let Some((thread_id, _)) = self.thread else {
+            return;
+        };
+
+        let granularity = DebuggerSettings::get_global(cx).stepping_granularity;
+
+        self.session().update(cx, |state, cx| {
+            state.step_back(thread_id, granularity, cx);
+        });
+    }
+
+    pub fn restart_client(&self, cx: &mut Context<Self>) {
+        self.session().update(cx, |state, cx| {
+            state.restart(None, cx);
+        });
+    }
+
+    pub fn pause_thread(&self, cx: &mut Context<Self>) {
+        let Some((thread_id, _)) = self.thread else {
+            return;
+        };
+
+        self.session().update(cx, |state, cx| {
+            state.pause_thread(thread_id, cx);
+        });
+    }
+
+    pub fn stop_thread(&self, cx: &mut Context<Self>) {
+        let Some((thread_id, _)) = self.thread else {
+            return;
+        };
+
+        self.session().update(cx, |state, cx| {
+            state.terminate_threads(Some(vec![thread_id; 1]), cx);
+        });
+    }
+
+    pub fn disconnect_client(&self, cx: &mut Context<Self>) {
+        self.session().update(cx, |state, cx| {
+            state.disconnect_client(cx);
+        });
+    }
+
+    pub fn toggle_ignore_breakpoints(&mut self, cx: &mut Context<Self>) {
+        self.session
+            .update(cx, |session, cx| session.toggle_ignore_breakpoints(cx))
+            .detach_and_log_err(cx);
+    }
+}
+
+impl EventEmitter<DebugPanelItemEvent> for RunningState {}
+
+impl Focusable for RunningState {
+    fn focus_handle(&self, _: &App) -> FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Item for RunningState {
+    type Event = DebugPanelItemEvent;
+
+    fn tab_content(
+        &self,
+        _params: workspace::item::TabContentParams,
+        _window: &Window,
+        _cx: &App,
+    ) -> AnyElement {
+        todo!()
+    }
+
+    fn tab_tooltip_text(&self, _cx: &App) -> Option<SharedString> {
+        todo!()
+    }
+
+    fn to_item_events(event: &Self::Event, mut f: impl FnMut(ItemEvent)) {
+        match event {
+            DebugPanelItemEvent::Close => f(ItemEvent::CloseItem),
+            DebugPanelItemEvent::Stopped { .. } => {}
+        }
+    }
+}

crates/debugger_ui/src/session/running/console.rs

@@ -0,0 +1,505 @@
+use super::{
+    stack_frame_list::{StackFrameList, StackFrameListEvent},
+    variable_list::VariableList,
+};
+use collections::HashMap;
+use dap::{OutputEvent, OutputEventGroup};
+use editor::{
+    display_map::{Crease, CreaseId},
+    Anchor, CompletionProvider, Editor, EditorElement, EditorStyle, FoldPlaceholder,
+};
+use fuzzy::StringMatchCandidate;
+use gpui::{Context, Entity, Render, Subscription, Task, TextStyle, WeakEntity};
+use language::{Buffer, CodeLabel, LanguageServerId};
+use menu::Confirm;
+use project::{
+    debugger::session::{CompletionsQuery, Session},
+    Completion,
+};
+use settings::Settings;
+use std::{cell::RefCell, rc::Rc, sync::Arc, usize};
+use theme::ThemeSettings;
+use ui::{prelude::*, ButtonLike, Disclosure, ElevationIndex};
+
+pub struct OutputGroup {
+    pub start: Anchor,
+    pub collapsed: bool,
+    pub end: Option<Anchor>,
+    pub crease_ids: Vec<CreaseId>,
+    pub placeholder: SharedString,
+}
+
+pub struct Console {
+    groups: Vec<OutputGroup>,
+    console: Entity<Editor>,
+    query_bar: Entity<Editor>,
+    session: Entity<Session>,
+    _subscriptions: Vec<Subscription>,
+    variable_list: Entity<VariableList>,
+    stack_frame_list: Entity<StackFrameList>,
+}
+
+impl Console {
+    pub fn new(
+        session: Entity<Session>,
+        stack_frame_list: Entity<StackFrameList>,
+        variable_list: Entity<VariableList>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let console = cx.new(|cx| {
+            let mut editor = Editor::multi_line(window, cx);
+            editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
+            editor.set_read_only(true);
+            editor.set_show_gutter(true, cx);
+            editor.set_show_runnables(false, cx);
+            editor.set_show_code_actions(false, cx);
+            editor.set_show_line_numbers(false, cx);
+            editor.set_show_git_diff_gutter(false, cx);
+            editor.set_autoindent(false);
+            editor.set_input_enabled(false);
+            editor.set_use_autoclose(false);
+            editor.set_show_wrap_guides(false, cx);
+            editor.set_show_indent_guides(false, cx);
+            editor.set_show_edit_predictions(Some(false), window, cx);
+            editor
+        });
+
+        let this = cx.weak_entity();
+        let query_bar = cx.new(|cx| {
+            let mut editor = Editor::single_line(window, cx);
+            editor.set_placeholder_text("Evaluate an expression", cx);
+            editor.set_use_autoclose(false);
+            editor.set_show_gutter(false, cx);
+            editor.set_show_wrap_guides(false, cx);
+            editor.set_show_indent_guides(false, cx);
+            editor.set_completion_provider(Some(Box::new(ConsoleQueryBarCompletionProvider(this))));
+
+            editor
+        });
+
+        let _subscriptions = vec![
+            cx.subscribe(&stack_frame_list, Self::handle_stack_frame_list_events),
+            cx.observe_in(&session, window, |console, session, window, cx| {
+                let (output, last_processed_ix) = session.update(cx, |session, _| {
+                    (session.output(), session.last_processed_output())
+                });
+
+                if output.len() > last_processed_ix {
+                    for event in &output[last_processed_ix..] {
+                        console.add_message(event.clone(), window, cx);
+                    }
+
+                    session.update(cx, |session, _| {
+                        session.set_last_processed_output(output.len());
+                    });
+                }
+            }),
+        ];
+
+        Self {
+            session,
+            console,
+            query_bar,
+            variable_list,
+            _subscriptions,
+            stack_frame_list,
+            groups: Vec::default(),
+        }
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn editor(&self) -> &Entity<Editor> {
+        &self.console
+    }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn query_bar(&self) -> &Entity<Editor> {
+        &self.query_bar
+    }
+
+    fn is_local(&self, cx: &Context<Self>) -> bool {
+        self.session.read(cx).is_local()
+    }
+
+    fn handle_stack_frame_list_events(
+        &mut self,
+        _: Entity<StackFrameList>,
+        event: &StackFrameListEvent,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            StackFrameListEvent::SelectedStackFrameChanged(_) => cx.notify(),
+        }
+    }
+
+    pub fn add_message(&mut self, event: OutputEvent, window: &mut Window, cx: &mut Context<Self>) {
+        self.console.update(cx, |console, cx| {
+            let output = event.output.trim_end().to_string();
+
+            let snapshot = console.buffer().read(cx).snapshot(cx);
+
+            let start = snapshot.anchor_before(snapshot.max_point());
+
+            let mut indent_size = self
+                .groups
+                .iter()
+                .filter(|group| group.end.is_none())
+                .count();
+            if Some(OutputEventGroup::End) == event.group {
+                indent_size = indent_size.saturating_sub(1);
+            }
+
+            let indent = if indent_size > 0 {
+                "    ".repeat(indent_size)
+            } else {
+                "".to_string()
+            };
+
+            console.set_read_only(false);
+            console.move_to_end(&editor::actions::MoveToEnd, window, cx);
+            console.insert(format!("{}{}\n", indent, output).as_str(), window, cx);
+            console.set_read_only(true);
+
+            let end = snapshot.anchor_before(snapshot.max_point());
+
+            match event.group {
+                Some(OutputEventGroup::Start) => {
+                    self.groups.push(OutputGroup {
+                        start,
+                        end: None,
+                        collapsed: false,
+                        placeholder: output.clone().into(),
+                        crease_ids: console.insert_creases(
+                            vec![Self::create_crease(output.into(), start, end)],
+                            cx,
+                        ),
+                    });
+                }
+                Some(OutputEventGroup::StartCollapsed) => {
+                    self.groups.push(OutputGroup {
+                        start,
+                        end: None,
+                        collapsed: true,
+                        placeholder: output.clone().into(),
+                        crease_ids: console.insert_creases(
+                            vec![Self::create_crease(output.into(), start, end)],
+                            cx,
+                        ),
+                    });
+                }
+                Some(OutputEventGroup::End) => {
+                    if let Some(index) = self.groups.iter().rposition(|group| group.end.is_none()) {
+                        let group = self.groups.remove(index);
+
+                        console.remove_creases(group.crease_ids.clone(), cx);
+
+                        let creases =
+                            vec![Self::create_crease(group.placeholder, group.start, end)];
+                        console.insert_creases(creases.clone(), cx);
+
+                        if group.collapsed {
+                            console.fold_creases(creases, false, window, cx);
+                        }
+                    }
+                }
+                None => {}
+            }
+
+            cx.notify();
+        });
+    }
+
+    fn create_crease(placeholder: SharedString, start: Anchor, end: Anchor) -> Crease<Anchor> {
+        Crease::inline(
+            start..end,
+            FoldPlaceholder {
+                render: Arc::new({
+                    let placeholder = placeholder.clone();
+                    move |_id, _range, _cx| {
+                        ButtonLike::new("output-group-placeholder")
+                            .style(ButtonStyle::Transparent)
+                            .layer(ElevationIndex::ElevatedSurface)
+                            .child(Label::new(placeholder.clone()).single_line())
+                            .into_any_element()
+                    }
+                }),
+                ..Default::default()
+            },
+            move |row, is_folded, fold, _window, _cx| {
+                Disclosure::new(("output-group", row.0 as u64), !is_folded)
+                    .toggle_state(is_folded)
+                    .on_click(move |_event, window, cx| fold(!is_folded, window, cx))
+                    .into_any_element()
+            },
+            move |_id, _range, _window, _cx| gpui::Empty.into_any_element(),
+        )
+    }
+
+    pub fn evaluate(&mut self, _: &Confirm, window: &mut Window, cx: &mut Context<Self>) {
+        let expression = self.query_bar.update(cx, |editor, cx| {
+            let expression = editor.text(cx);
+
+            editor.clear(window, cx);
+
+            expression
+        });
+
+        self.session.update(cx, |state, cx| {
+            state.evaluate(
+                expression,
+                Some(dap::EvaluateArgumentsContext::Variables),
+                Some(self.stack_frame_list.read(cx).current_stack_frame_id()),
+                None,
+                cx,
+            );
+        });
+    }
+
+    fn render_console(&self, cx: &Context<Self>) -> impl IntoElement {
+        let settings = ThemeSettings::get_global(cx);
+        let text_style = TextStyle {
+            color: if self.console.read(cx).read_only(cx) {
+                cx.theme().colors().text_disabled
+            } else {
+                cx.theme().colors().text
+            },
+            font_family: settings.buffer_font.family.clone(),
+            font_features: settings.buffer_font.features.clone(),
+            font_size: settings.buffer_font_size(cx).into(),
+            font_weight: settings.buffer_font.weight,
+            line_height: relative(settings.buffer_line_height.value()),
+            ..Default::default()
+        };
+
+        EditorElement::new(
+            &self.console,
+            EditorStyle {
+                background: cx.theme().colors().editor_background,
+                local_player: cx.theme().players().local(),
+                text: text_style,
+                ..Default::default()
+            },
+        )
+    }
+
+    fn render_query_bar(&self, cx: &Context<Self>) -> impl IntoElement {
+        let settings = ThemeSettings::get_global(cx);
+        let text_style = TextStyle {
+            color: if self.console.read(cx).read_only(cx) {
+                cx.theme().colors().text_disabled
+            } else {
+                cx.theme().colors().text
+            },
+            font_family: settings.ui_font.family.clone(),
+            font_features: settings.ui_font.features.clone(),
+            font_fallbacks: settings.ui_font.fallbacks.clone(),
+            font_size: TextSize::Editor.rems(cx).into(),
+            font_weight: settings.ui_font.weight,
+            line_height: relative(1.3),
+            ..Default::default()
+        };
+
+        EditorElement::new(
+            &self.query_bar,
+            EditorStyle {
+                background: cx.theme().colors().editor_background,
+                local_player: cx.theme().players().local(),
+                text: text_style,
+                ..Default::default()
+            },
+        )
+    }
+}
+
+impl Render for Console {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        v_flex()
+            .key_context("DebugConsole")
+            .on_action(cx.listener(Self::evaluate))
+            .size_full()
+            .child(self.render_console(cx))
+            .when(self.is_local(cx), |this| {
+                this.child(self.render_query_bar(cx))
+                    .pt(DynamicSpacing::Base04.rems(cx))
+            })
+            .border_2()
+    }
+}
+
+struct ConsoleQueryBarCompletionProvider(WeakEntity<Console>);
+
+impl CompletionProvider for ConsoleQueryBarCompletionProvider {
+    fn completions(
+        &self,
+        buffer: &Entity<Buffer>,
+        buffer_position: language::Anchor,
+        _trigger: editor::CompletionContext,
+        _window: &mut Window,
+        cx: &mut Context<Editor>,
+    ) -> gpui::Task<gpui::Result<Vec<project::Completion>>> {
+        let Some(console) = self.0.upgrade() else {
+            return Task::ready(Ok(Vec::new()));
+        };
+
+        let support_completions = console
+            .read(cx)
+            .session
+            .read(cx)
+            .capabilities()
+            .supports_completions_request
+            .unwrap_or_default();
+
+        if support_completions {
+            self.client_completions(&console, buffer, buffer_position, cx)
+        } else {
+            self.variable_list_completions(&console, buffer, buffer_position, cx)
+        }
+    }
+
+    fn resolve_completions(
+        &self,
+        _buffer: Entity<Buffer>,
+        _completion_indices: Vec<usize>,
+        _completions: Rc<RefCell<Box<[Completion]>>>,
+        _cx: &mut Context<Editor>,
+    ) -> gpui::Task<gpui::Result<bool>> {
+        Task::ready(Ok(false))
+    }
+
+    fn apply_additional_edits_for_completion(
+        &self,
+        _buffer: Entity<Buffer>,
+        _completions: Rc<RefCell<Box<[Completion]>>>,
+        _completion_index: usize,
+        _push_to_history: bool,
+        _cx: &mut Context<Editor>,
+    ) -> gpui::Task<gpui::Result<Option<language::Transaction>>> {
+        Task::ready(Ok(None))
+    }
+
+    fn is_completion_trigger(
+        &self,
+        _buffer: &Entity<Buffer>,
+        _position: language::Anchor,
+        _text: &str,
+        _trigger_in_words: bool,
+        _cx: &mut Context<Editor>,
+    ) -> bool {
+        true
+    }
+}
+
+impl ConsoleQueryBarCompletionProvider {
+    fn variable_list_completions(
+        &self,
+        console: &Entity<Console>,
+        buffer: &Entity<Buffer>,
+        buffer_position: language::Anchor,
+        cx: &mut Context<Editor>,
+    ) -> gpui::Task<gpui::Result<Vec<project::Completion>>> {
+        let (variables, string_matches) = console.update(cx, |console, cx| {
+            let mut variables = HashMap::new();
+            let mut string_matches = Vec::new();
+
+            for variable in console.variable_list.update(cx, |variable_list, cx| {
+                variable_list.completion_variables(cx)
+            }) {
+                if let Some(evaluate_name) = &variable.evaluate_name {
+                    variables.insert(evaluate_name.clone(), variable.value.clone());
+                    string_matches.push(StringMatchCandidate {
+                        id: 0,
+                        string: evaluate_name.clone(),
+                        char_bag: evaluate_name.chars().collect(),
+                    });
+                }
+
+                variables.insert(variable.name.clone(), variable.value.clone());
+
+                string_matches.push(StringMatchCandidate {
+                    id: 0,
+                    string: variable.name.clone(),
+                    char_bag: variable.name.chars().collect(),
+                });
+            }
+
+            (variables, string_matches)
+        });
+
+        let query = buffer.read(cx).text();
+
+        cx.spawn(|_, cx| async move {
+            let matches = fuzzy::match_strings(
+                &string_matches,
+                &query,
+                true,
+                10,
+                &Default::default(),
+                cx.background_executor().clone(),
+            )
+            .await;
+
+            Ok(matches
+                .iter()
+                .filter_map(|string_match| {
+                    let variable_value = variables.get(&string_match.string)?;
+
+                    Some(project::Completion {
+                        old_range: buffer_position..buffer_position,
+                        new_text: string_match.string.clone(),
+                        label: CodeLabel {
+                            filter_range: 0..string_match.string.len(),
+                            text: format!("{} {}", string_match.string.clone(), variable_value),
+                            runs: Vec::new(),
+                        },
+                        server_id: LanguageServerId(usize::MAX),
+                        documentation: None,
+                        lsp_completion: Default::default(),
+                        confirm: None,
+                        resolved: true,
+                    })
+                })
+                .collect())
+        })
+    }
+
+    fn client_completions(
+        &self,
+        console: &Entity<Console>,
+        buffer: &Entity<Buffer>,
+        buffer_position: language::Anchor,
+        cx: &mut Context<Editor>,
+    ) -> gpui::Task<gpui::Result<Vec<project::Completion>>> {
+        let completion_task = console.update(cx, |console, cx| {
+            console.session.update(cx, |state, cx| {
+                let frame_id = Some(console.stack_frame_list.read(cx).current_stack_frame_id());
+
+                state.completions(
+                    CompletionsQuery::new(buffer.read(cx), buffer_position, frame_id),
+                    cx,
+                )
+            })
+        });
+
+        cx.background_executor().spawn(async move {
+            Ok(completion_task
+                .await?
+                .iter()
+                .map(|completion| project::Completion {
+                    old_range: buffer_position..buffer_position, // TODO(debugger): change this
+                    new_text: completion.text.clone().unwrap_or(completion.label.clone()),
+                    label: CodeLabel {
+                        filter_range: 0..completion.label.len(),
+                        text: completion.label.clone(),
+                        runs: Vec::new(),
+                    },
+                    server_id: LanguageServerId(usize::MAX),
+                    documentation: None,
+                    lsp_completion: Default::default(),
+                    confirm: None,
+                    resolved: true,
+                })
+                .collect())
+        })
+    }
+}

crates/debugger_ui/src/session/running/loaded_source_list.rs

@@ -0,0 +1,95 @@
+use gpui::{list, AnyElement, Empty, Entity, FocusHandle, Focusable, ListState, Subscription};
+use project::debugger::session::Session;
+use ui::prelude::*;
+use util::maybe;
+
+pub struct LoadedSourceList {
+    list: ListState,
+    focus_handle: FocusHandle,
+    _subscription: Subscription,
+    session: Entity<Session>,
+}
+
+impl LoadedSourceList {
+    pub fn new(session: Entity<Session>, cx: &mut Context<Self>) -> Self {
+        let weak_entity = cx.weak_entity();
+        let focus_handle = cx.focus_handle();
+
+        let list = ListState::new(
+            0,
+            gpui::ListAlignment::Top,
+            px(1000.),
+            move |ix, _window, cx| {
+                weak_entity
+                    .upgrade()
+                    .map(|loaded_sources| {
+                        loaded_sources.update(cx, |this, cx| this.render_entry(ix, cx))
+                    })
+                    .unwrap_or(div().into_any())
+            },
+        );
+
+        let _subscription = cx.observe(&session, |loaded_source_list, state, cx| {
+            let len = state.update(cx, |state, cx| state.loaded_sources(cx).len());
+
+            loaded_source_list.list.reset(len);
+            cx.notify();
+        });
+
+        Self {
+            list,
+            session,
+            focus_handle,
+            _subscription,
+        }
+    }
+
+    fn render_entry(&mut self, ix: usize, cx: &mut Context<Self>) -> AnyElement {
+        let Some(source) = maybe!({
+            self.session
+                .update(cx, |state, cx| state.loaded_sources(cx).get(ix).cloned())
+        }) else {
+            return Empty.into_any();
+        };
+
+        v_flex()
+            .rounded_md()
+            .w_full()
+            .group("")
+            .p_1()
+            .hover(|s| s.bg(cx.theme().colors().element_hover))
+            .child(
+                h_flex()
+                    .gap_0p5()
+                    .text_ui_sm(cx)
+                    .when_some(source.name.clone(), |this, name| this.child(name)),
+            )
+            .child(
+                h_flex()
+                    .text_ui_xs(cx)
+                    .text_color(cx.theme().colors().text_muted)
+                    .when_some(source.path.clone(), |this, path| this.child(path)),
+            )
+            .into_any()
+    }
+}
+
+impl Focusable for LoadedSourceList {
+    fn focus_handle(&self, _: &gpui::App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for LoadedSourceList {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        self.session.update(cx, |state, cx| {
+            state.loaded_sources(cx);
+        });
+
+        div()
+            .track_focus(&self.focus_handle)
+            .size_full()
+            .p_1()
+            .child(list(self.list.clone()).size_full())
+    }
+}