dependencies = [

"anyhow",

"fern",

"helix-core",

"helix-stdx",

"log",

"serde",

"serde_json",

"thiserror 2.0.12",

"tokio",

]

[[package]]

ropey = { version = "1.6.1", default-features = false, features = ["simd"] }

foldhash = "0.1"

parking_lot = "0.12"

[workspace.package]

version = "25.1.1"

serde_json = "1.0"

tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "net", "sync"] }

thiserror.workspace = true

[dev-dependencies]

fern = "0.7"

use crate::{

transport::{Payload, Request, Response, Transport},

types::*,

Error, Result,

};

use serde_json::Value;

#[derive(Debug)]

pub struct Client {

_process: Option<Child>,

server_tx: UnboundedSender<Payload>,

request_counter: AtomicU64,

connection_type: Option<ConnectionType>,

starting_request_args: Option<Value>,

pub caps: Option<DebuggerCapabilities>,

// thread_id -> frames

pub stack_frames: HashMap<ThreadId, Vec<StackFrame>>,

/// Currently active frame for the current thread.

pub active_frame: Option<usize>,

pub quirks: DebuggerQuirks,

}

impl Client {

// Spawn a process and communicate with it by either TCP or stdio

pub async fn process(

transport: &str,

command: &str,

args: Vec<&str>,

port_arg: Option<&str>,

if command.is_empty() {

return Result::Err(Error::Other(anyhow!("Command not provided")));

}

rx: Box<dyn AsyncBufRead + Unpin + Send>,

tx: Box<dyn AsyncWrite + Unpin + Send>,

err: Option<Box<dyn AsyncBufRead + Unpin + Send>>,

process: Option<Child>,

let (server_rx, server_tx) = Transport::start(rx, tx, err, id);

let (client_tx, client_rx) = unbounded_channel();

caps: None,

connection_type: None,

starting_request_args: None,

stack_frames: HashMap::new(),

thread_states: HashMap::new(),

thread_id: None,

active_frame: None,

quirks: DebuggerQuirks::default(),

};

Ok((client, client_rx))

}

pub async fn tcp(

addr: std::net::SocketAddr,

let stream = TcpStream::connect(addr).await?;

let (rx, tx) = stream.into_split();

Self::streams(Box::new(BufReader::new(rx)), Box::new(tx), None, id, None)

pub fn stdio(

cmd: &str,

args: Vec<&str>,

// Resolve path to the binary

let cmd = helix_stdx::env::which(cmd)?;

cmd: &str,

args: Vec<&str>,

port_format: &str,

let port = Self::get_port().await.unwrap();

let process = Command::new(cmd)

// Wait for adapter to become ready for connection

time::sleep(time::Duration::from_millis(500)).await;

let (rx, tx) = stream.into_split();

Box::new(BufReader::new(rx)),

Box::new(tx),

None,

id,

Some(process),

}

while let Some(msg) = server_rx.recv().await {

match msg {

Payload::Event(ev) => {

}

Payload::Response(_) => unreachable!(),

Payload::Request(req) => {

client_tx

.expect("Failed to send");

}

}

}

}

self.id

}

self.call::<requests::Disconnect>(args)

}

pub fn launch(&mut self, args: serde_json::Value) -> impl Future<Output = Result<Value>> {

self.connection_type = Some(ConnectionType::Launch);

self.starting_request_args = Some(args.clone());

mod client;

mod transport;

mod types;

pub use transport::{Payload, Response, Transport};

pub use types::*;

#[derive(Debug)]

pub enum Request {

RunInTerminal(<requests::RunInTerminal as types::Request>::Arguments),

}

impl Request {

let arguments = arguments.unwrap_or_default();

let request = match command {

requests::RunInTerminal::COMMAND => Self::RunInTerminal(parse_value(arguments)?),

_ => return Err(Error::Unhandled),

};

use anyhow::Context;

use log::{error, info, warn};

use serde::{Deserialize, Serialize};

use serde_json::Value;

use std::sync::Arc;

use tokio::{

io::{AsyncBufRead, AsyncBufReadExt, AsyncReadExt, AsyncWrite, AsyncWriteExt},

sync::{

#[derive(Debug)]

pub struct Transport {

#[allow(unused)]

pending_requests: Mutex<HashMap<u64, Sender<Result<Response>>>>,

}

server_stdout: Box<dyn AsyncBufRead + Unpin + Send>,

server_stdin: Box<dyn AsyncWrite + Unpin + Send>,

server_stderr: Option<Box<dyn AsyncBufRead + Unpin + Send>>,

) -> (UnboundedReceiver<Payload>, UnboundedSender<Payload>) {

let (client_tx, rx) = unbounded_channel();

let (tx, client_rx) = unbounded_channel();

let transport = Arc::new(transport);

tokio::spawn(Self::send(transport, server_stdin, client_rx));

if let Some(stderr) = server_stderr {

tokio::spawn(Self::err(stderr));

}

async fn recv_server_message(

reader: &mut Box<dyn AsyncBufRead + Unpin + Send>,

buffer: &mut String,

content: &mut Vec<u8>,

reader.read_exact(content).await?;

let msg = std::str::from_utf8(content).context("invalid utf8 from server")?;

// try parsing as output (server response) or call (server request)

let output: serde_json::Result<Payload> = serde_json::from_str(msg);

server_stdin: &mut Box<dyn AsyncWrite + Unpin + Send>,

request: String,

) -> Result<()> {

// send the headers

server_stdin

Ok(())

}

if res.success {

Ok(res)

} else {

error!(

);

Err(Error::Other(anyhow::format_err!("{:?}", res.body)))

let tx = self.pending_requests.lock().await.remove(&request_seq);

match tx {

Ok(_) => (),

Err(_) => error!(

"Tried sending response into a closed channel (id={:?}), original request likely timed out",

ref seq,

..

}) => {

client_tx.send(msg).expect("Failed to send");

Ok(())

}

Payload::Event(ref event) => {

client_tx.send(msg).expect("Failed to send");

Ok(())

}

}

async fn recv(

transport: Arc<Self>,

mut server_stdout: Box<dyn AsyncBufRead + Unpin + Send>,

client_tx: UnboundedSender<Payload>,

let mut content_buffer = Vec::new();

loop {

match Self::recv_server_message(

&mut server_stdout,

&mut recv_buffer,

&mut content_buffer,

Ok(msg) => match transport.process_server_message(&client_tx, msg).await {

Ok(_) => (),

Err(err) => {

break;

}

},

const COMMAND: &'static str = "disconnect";

}

#[derive(Debug)]

pub enum ConfigurationDone {}

type Result = RunInTerminalResponse;

const COMMAND: &'static str = "runInTerminal";

}

}

// Events

}

}

#[test]

fn test_deserialize_module_id_from_number() {

let raw = r#"{"id": 0, "name": "Name"}"#;

helix-lsp-types = { path = "../helix-lsp-types" }

anyhow = "1.0"

globset = "0.4.16"

log = "0.4"

serde = { version = "1.0", features = ["derive"] }

serde_json = "1.0"

tokio = { version = "1.45", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "sync"] }

parking_lot.workspace = true

arc-swap = "1"

slotmap.workspace = true

// limit render calls for fast language server messages

helix_event::request_redraw();

}

if needs_render {

self.render().await;

}

};

use dap::{StackFrame, Thread, ThreadStates};

use helix_core::syntax::config::{DebugArgumentValue, DebugConfigCompletion, DebugTemplate};

use helix_lsp::block_on;

use helix_view::editor::Breakpoint;

use serde_json::{to_value, Value};

use tui::text::Spans;

use std::collections::HashMap;

move |cx, thread, _action| callback_fn(cx.editor, thread),

)

.with_preview(move |editor, thread| {

let frame = frames.first()?;

let path = frame.source.as_ref()?.path.as_ref()?.as_path();

let pos = Some((

params: Option<Vec<std::borrow::Cow<str>>>,

) -> Result<(), anyhow::Error> {

let doc = doc!(cx.editor);

let config = doc

.language_config()

.and_then(|config| config.debugger.as_ref())

.ok_or_else(|| anyhow!("No debug adapter available for language"))?;

// TODO: avoid refetching all of this... pass a config in

let template = match name {

// }

};

match &template.request[..] {

"launch" => {

let call = debugger.launch(args);

};

// TODO: either await "initialized" or buffer commands until event is received

Ok(())

}

pub fn dap_launch(cx: &mut Context) {

cx.editor.set_error("Debugger is already running");

return;

}

}

pub fn dap_restart(cx: &mut Context) {

Some(debugger) => debugger,

None => {

cx.editor.set_error("Debugger is not running");

}

pub fn dap_terminate(cx: &mut Context) {

let debugger = debugger!(cx.editor);

dap_callback(cx.jobs, request, |editor, _compositor, _response: ()| {

// editor.set_error(format!("Failed to disconnect: {}", e));

});

}

return Ok(());

}

let (frame, thread_id) = match (debugger.active_frame, debugger.thread_id) {

(Some(frame), Some(thread_id)) => (frame, thread_id),

_ => {

tree::{self, Tree},

Document, DocumentId, View, ViewId,

};

use helix_event::dispatch;

use helix_vcs::DiffProviderRegistry;

},

Change, LineEnding, Position, Range, Selection, Uri, NATIVE_LINE_ENDING,

};

use helix_lsp::lsp;

use helix_stdx::path::canonicalize;

pub diagnostics: Diagnostics,

pub diff_providers: DiffProviderRegistry,

pub breakpoints: HashMap<PathBuf, Vec<Breakpoint>>,

pub syn_loader: Arc<ArcSwap<syntax::Loader>>,

DocumentSaved(DocumentSavedEventResult),

ConfigEvent(ConfigEvent),

LanguageServerMessage((LanguageServerId, Call)),

IdleTimer,

Redraw,

}

language_servers,

diagnostics: Diagnostics::new(),

diff_providers: DiffProviderRegistry::default(),

breakpoints: HashMap::new(),

syn_loader,

theme_loader,

Some(message) = self.language_servers.incoming.next() => {

return EditorEvent::LanguageServerMessage(message)

}

return EditorEvent::DebuggerEvent(event)

}

}

}

}

/// Returns the id of a view that this doc contains a selection for,

use crate::{align_view, Align, Editor};

use dap::requests::DisconnectArguments;

use helix_core::Selection;

use helix_lsp::block_on;

use std::fmt::Write;

use std::path::PathBuf;

#[macro_export]

macro_rules! debugger {

($editor:expr) => {{

}};

}

}

impl Editor {

use helix_dap::{events, Event};

match payload {

Payload::Event(event) => {

let event = match Event::parse(&event.event, event.body) {

all_threads_stopped,

..

}) => {

let all_threads_stopped = all_threads_stopped.unwrap_or_default();

if all_threads_stopped {

} else if let Some(thread_id) = thread_id {

debugger.thread_states.insert(thread_id, reason.clone()); // TODO: dap uses "type" || "reason" here

// whichever thread stops is made "current" (if no previously selected thread).

select_thread_id(self, thread_id, false).await;

}

}

self.set_status(status);

}

Event::Continued(events::ContinuedBody { thread_id, .. }) => {

debugger

.thread_states

.insert(thread_id, "running".to_owned());

debugger.resume_application();

}

}

}

Event::Breakpoint(events::BreakpointBody { reason, breakpoint }) => {

match &reason[..] {

self.set_status(format!("{} {}", prefix, output));

}

Event::Initialized(_) => {

// send existing breakpoints

for (path, breakpoints) in &mut self.breakpoints {

// TODO: call futures in parallel, await all

}; // TODO: do we need to handle error?

}

Event::Terminated(terminated) => {

terminated.restart

} else {

None

};

let disconnect_args = Some(DisconnectArguments {

terminate_debuggee: None,

suspend_debuggee: None,

});

return false;

}

log::info!("Attempting to restart debug session.");

let connection_type = match debugger.connection_type() {

Some(connection_type) => connection_type,

let relaunch_resp = if let ConnectionType::Launch = connection_type

{

} else {

};

if let Err(err) = relaunch_resp {

));

}

}

}

}

Event::Exited(resp) => {

shell_process_id: None,

}))

}

Err(err) => Err(err),

};

debugger

.reply(request.seq, &request.command, reply)

.await

indent = { tab-width = 2, unit = " " }

[language.debugger]

# args consisting of cmd (node) and path to adapter should be added to user's configuration

quirks = { absolute-paths = true }

name = "source"

request = "launch"

completion = [ { name = "main", completion = "filename", default = "index.js" } ]

[[grammar]]

name = "javascript"