Mountain/Environment/

DebugProvider.rs

//! # DebugProvider (Environment)
//!
//! RESPONSIBILITIES:
//! - Implements [`DebugService`](CommonLibrary::Debug::DebugService) for
//!   [`MountainEnvironment`]
//! - Manages complete debugging session lifecycle from configuration to
//!   termination
//! - Orchestrates between extension host (Cocoon), debug adapter, and UI
//! - Handles DAP (Debug Adapter Protocol) message mediation
//!
//! ARCHITECTURAL ROLE:
//! - Core provider for debugging functionality, analogous to VSCode's debug
//!   service
//! - Uses two-stage registration: configuration providers and adapter
//!   descriptor factories
//! - Each debug type (node, java, rust) can have its own configuration and
//!   adapter
//! - Integrates with [`IPCProvider`](CommonLibrary::IPC::IPCProvider) for RPC
//!   to Cocoon
//!
//! DEBUG SESSION FLOW:
//! 1. UI calls `StartDebugging` with folder URI and configuration
//! 2. Mountain RPCs to Cocoon to resolve debug configuration (variable
//!    substitution)
//! 3. Mountain RPCs to Cocoon to create debug adapter descriptor
//! 4. Mountain spawns debug adapter process or connects to TCP server
//! 5. Mountain mediates DAP messages between UI and debug adapter
//! 6. UI sends DAP commands via `SendCommand` which forwards to adapter
//! 7. Debug adapter sends DAP events/notifications back through Mountain to UI
//! 8. Session ends on stop request or adapter process exit
//!
//! ERROR HANDLING:
//! - Uses [`CommonError`](CommonLibrary::Error::CommonError) for all operations
//! - Validates debug type is non-empty (InvalidArgument error)
//! - TODO: Implement proper session lookup, timeout handling, and error
//!   recovery
//!
//! PERFORMANCE:
//! - Debug adapter spawning should be async with timeout protection (5000ms in
//!   current RPC)
//! - DAP message routing needs efficient session lookup (TODO: O(1) hash map)
//! - Multiple simultaneous debug sessions require careful resource management
//!
//! VS CODE REFERENCE:
//! - `vs/workbench/contrib/debug/browser/debugService.ts` - debug service main
//!   logic
//! - `vs/workbench/contrib/debug/common/debug.ts` - debug interfaces and models
//! - `vs/workbench/contrib/debug/browser/adapter/descriptorFactory.ts` -
//!   adapter descriptor factories
//! - `vs/debugAdapter/common/debugProtocol.ts` - DAP protocol specification
//!
//! IMPLEMENTED:
//! - Provider/factory registrations stored in ApplicationState (DebugState)
//! - Active session tracking via DebugState::DebugSessions map
//! - Executable adapter spawning with stdin/stdout/stderr pipes
//! - DAP frame parsing (Content-Length header + JSON body) on adapter stdout
//! - Stdout messages emitted on `sky://debug/dap-message` for renderer pickup
//! - SendCommand serialises DAP request → writes framed bytes to stdin
//! - StopDebugging sends DAP `disconnect` request then unregisters session
//!
//! FOLLOWUP:
//! - `server` / `pipeServer` adapter connection (TCP / named-pipe)
//! - Reverse-RPC `$sendDAPRequest` Cocoon handler for inline-impl adapters
//! - Per-session request_seq allocation (currently caller-supplied)
//! - Adapter crash detection: when stdout EOFs unexpectedly, emit
//!   `$onDidTerminateDebugSession` so the workbench tears down its session view
//!   (today the user sees a stale session row)
//! - Debug console / variable inspection integration
//! - Telemetry for adapter spawn duration, session length, exit codes
//!
//! MODULE CONTENTS:
//! - [`DebugService`](CommonLibrary::Debug::DebugService) implementation:
//! - `RegisterDebugConfigurationProvider` - register config resolver
//! - `RegisterDebugAdapterDescriptorFactory` - register adapter factory
//! - `StartDebugging` - start debug session (partial)
//! - `SendCommand` - send DAP command to adapter (stub)

use std::sync::Arc;

use CommonLibrary::{
	Debug::DebugService::DebugService,
	Environment::Requires::Requires,
	Error::CommonError::CommonError,
	IPC::{DTO::ProxyTarget::ProxyTarget, IPCProvider::IPCProvider},
};
use async_trait::async_trait;
use serde_json::{Value, json};
use tauri::Emitter;
use url::Url;

use super::MountainEnvironment::MountainEnvironment;
use crate::dev_log;

#[async_trait]
impl DebugService for MountainEnvironment {
	async fn RegisterDebugConfigurationProvider(
		&self,

		DebugType:String,

		ProviderHandle:u32,

		SideCarIdentifier:String,
	) -> Result<(), CommonError> {
		// Validate debug type is non-empty
		if DebugType.is_empty() {
			return Err(CommonError::InvalidArgument {
				ArgumentName:"DebugType".to_string(),
				Reason:"DebugType cannot be empty".to_string(),
			});
		}

		dev_log!(
			"exthost",
			"[DebugProvider] Registering DebugConfigurationProvider for type '{}' (handle: {}, sidecar: {})",
			DebugType,
			ProviderHandle,
			SideCarIdentifier
		);

		// Store debug configuration provider registration in ApplicationState
		self.ApplicationState
			.Feature
			.Debug
			.RegisterDebugConfigurationProvider(DebugType, ProviderHandle, SideCarIdentifier)
			.map_err(|e| CommonError::Unknown { Description:e })?;

		Ok(())
	}

	async fn RegisterDebugAdapterDescriptorFactory(
		&self,

		DebugType:String,

		FactoryHandle:u32,

		SideCarIdentifier:String,
	) -> Result<(), CommonError> {
		// Validate debug type is non-empty
		if DebugType.is_empty() {
			return Err(CommonError::InvalidArgument {
				ArgumentName:"DebugType".to_string(),
				Reason:"DebugType cannot be empty".to_string(),
			});
		}

		dev_log!(
			"exthost",
			"[DebugProvider] Registering DebugAdapterDescriptorFactory for type '{}' (handle: {}, sidecar: {})",
			DebugType,
			FactoryHandle,
			SideCarIdentifier
		);

		// Store debug adapter descriptor factory registration in ApplicationState
		self.ApplicationState
			.Feature
			.Debug
			.RegisterDebugAdapterDescriptorFactory(DebugType, FactoryHandle, SideCarIdentifier)
			.map_err(|e| CommonError::Unknown { Description:e })?;

		Ok(())
	}

	async fn StartDebugging(&self, _FolderURI:Option<Url>, Configuration:Value) -> Result<String, CommonError> {
		let SessionID = uuid::Uuid::new_v4().to_string();
		dev_log!(
			"exthost",
			"[DebugProvider] Starting debug session '{}' with config: {:?}",
			SessionID,
			Configuration
		);

		let IPCProvider:Arc<dyn IPCProvider> = self.Require();
		let DebugType = Configuration
			.get("type")
			.and_then(Value::as_str)
			.ok_or_else(|| {
				CommonError::InvalidArgument {
					ArgumentName:"Configuration".into(),

					Reason:"Missing 'type' field in debug configuration.".into(),
				}
			})?
			.to_string();

		// TODO: Look up which sidecar (extension) handles this debug type using
		// the registration stored in ApplicationState. The mapping should be based
		// on previous RegisterDebugConfigurationProvider calls. Initial stub uses
		// hardcoded "cocoon-main" until proper registration tracking is implemented.
		let TargetSideCar = "cocoon-main".to_string();

		// 1. Resolve configuration (Reverse-RPC to Cocoon)
		dev_log!(
			"exthost",
			"[DebugProvider] Resolving debug configuration for type '{}'",
			DebugType
		);
		dev_log!("exthost", "[DebugProvider] Resolving debug configuration...");
		let ResolveConfigMethod = format!("{}$resolveDebugConfiguration", ProxyTarget::ExtHostDebug.GetTargetPrefix());
		let ResolvedConfig = IPCProvider
			.SendRequestToSideCar(
				TargetSideCar.clone(),
				ResolveConfigMethod,
				json!([DebugType.clone(), Configuration]),
				5000,
			)
			.await?;

		// 2. Get the Debug Adapter Descriptor (Reverse-RPC to Cocoon)
		dev_log!("exthost", "[DebugProvider] Creating debug adapter descriptor...");
		let CreateDescriptorMethod =
			format!("{}$createDebugAdapterDescriptor", ProxyTarget::ExtHostDebug.GetTargetPrefix());
		let Descriptor = IPCProvider
			.SendRequestToSideCar(
				TargetSideCar.clone(),
				CreateDescriptorMethod,
				json!([DebugType, &ResolvedConfig]),
				5000,
			)
			.await?;

		// 3. Spawn the Debug Adapter process based on the descriptor.
		dev_log!(
			"exthost",
			"[DebugProvider] Spawning Debug Adapter based on descriptor: {:?}",
			Descriptor
		);

		// Adapter-descriptor DTO shapes mirror VS Code's
		// `vs/workbench/api/common/extHostDebugService.ts::convert*ToDto`:
		//   executable  → { type: "executable", command, args, options: { env?, cwd? }
		// }   server      → { type: "server", port, host? }
		//   pipeServer  → { type: "pipeServer", path }
		//   implementation → { type: "implementation" }   (handled in-process by
		// Cocoon)
		//
		// Phase 1 of DAP spawning supports `executable` only - that covers
		// every JS/TS debug adapter (vscode-js-debug, node) and most
		// language-server-driven adapters that ship as a CLI binary.
		// Server / pipeServer connections are stubbed with a warn-log + a
		// session-registry entry without an `StdinSender`, so SendCommand
		// can still resolve the session and surface "adapter type
		// unsupported" instead of a silent no-op. Inline implementations
		// are handled entirely in the extension host - Cocoon's
		// `$createDebugAdapterDescriptor` returns `{type:"implementation"}`
		// and Cocoon dispatches DAP frames internally; we still record
		// the session so `vscode.debug.onDidStartDebugSession` listeners
		// receive the activation event.
		let DescriptorType = Descriptor.get("type").and_then(Value::as_str).unwrap_or("").to_string();
		let AdapterStdinSender:Option<tokio::sync::mpsc::UnboundedSender<Vec<u8>>>;
		let AdapterChildPid:Option<u32>;
		match DescriptorType.as_str() {
			"executable" => {
				let Command = Descriptor
					.get("command")
					.and_then(Value::as_str)
					.ok_or_else(|| {
						CommonError::InvalidArgument {
							ArgumentName:"Descriptor.command".into(),
							Reason:"executable adapter descriptor missing 'command'".into(),
						}
					})?
					.to_string();
				let Args:Vec<String> = Descriptor
					.get("args")
					.and_then(Value::as_array)
					.map(|A| A.iter().filter_map(|V| V.as_str().map(str::to_string)).collect())
					.unwrap_or_default();
				let OptionsValue = Descriptor.get("options").cloned().unwrap_or(Value::Null);
				let Cwd = OptionsValue.get("cwd").and_then(Value::as_str).map(str::to_string);
				let EnvOverrides:Vec<(String, String)> = OptionsValue
					.get("env")
					.and_then(Value::as_object)
					.map(|O| {
						O.iter()
							.filter_map(|(K, V)| V.as_str().map(|S| (K.clone(), S.to_string())))
							.collect()
					})
					.unwrap_or_default();

				let mut Builder = tokio::process::Command::new(&Command);
				Builder
					.args(&Args)
					.stdin(std::process::Stdio::piped())
					.stdout(std::process::Stdio::piped())
					.stderr(std::process::Stdio::piped());
				if let Some(CwdPath) = &Cwd {
					Builder.current_dir(CwdPath);
				}
				for (Key, Value) in &EnvOverrides {
					Builder.env(Key, Value);
				}

				let mut Child = Builder.spawn().map_err(|Error| {
					CommonError::IPCError {
						Description:format!(
							"Failed to spawn debug adapter '{}' for session {}: {}",
							Command, SessionID, Error
						),
					}
				})?;

				let Pid = Child.id();
				let Stdin = Child.stdin.take().ok_or_else(|| {
					CommonError::IPCError { Description:format!("Adapter for session {} had no stdin pipe", SessionID) }
				})?;
				let Stdout = Child.stdout.take().ok_or_else(|| {
					CommonError::IPCError {
						Description:format!("Adapter for session {} had no stdout pipe", SessionID),
					}
				})?;
				let Stderr = Child.stderr.take().ok_or_else(|| {
					CommonError::IPCError {
						Description:format!("Adapter for session {} had no stderr pipe", SessionID),
					}
				})?;

				let (Sender, mut Receiver) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();

				// Stdin writer task: drains the mpsc channel into the
				// adapter's stdin. Closes when the channel's sender is
				// dropped (UnregisterDebugSession) which propagates EOF
				// to the adapter and triggers its shutdown.
				let StdinSessionId = SessionID.clone();
				tokio::spawn(async move {
					use tokio::io::AsyncWriteExt;
					let mut Pipe = Stdin;
					while let Some(Frame) = Receiver.recv().await {
						if let Err(Error) = Pipe.write_all(&Frame).await {
							crate::dev_log!(
								"exthost",
								"warn: [DebugAdapter] stdin write failed for session {}: {}",
								StdinSessionId,
								Error
							);
							break;
						}
						if let Err(Error) = Pipe.flush().await {
							crate::dev_log!(
								"exthost",
								"warn: [DebugAdapter] stdin flush failed for session {}: {}",
								StdinSessionId,
								Error
							);
							break;
						}
					}
					let _ = Pipe.shutdown().await;
				});

				// Stdout reader task: parses DAP frames
				// (`Content-Length: <n>\r\n\r\n<json>`) and re-emits each
				// JSON message on `sky://debug/dap-message` so the
				// renderer / Cocoon-side reverse-RPC can route it to the
				// originating session listener. Errors break the read
				// loop and trigger session cleanup.
				let StdoutSessionId = SessionID.clone();
				let StdoutHandle = self.ApplicationHandle.clone();
				let StdoutSidecar = TargetSideCar.clone();
				tokio::spawn(async move {
					use tokio::io::{AsyncBufReadExt, AsyncReadExt, BufReader};
					let mut Reader = BufReader::new(Stdout);
					let mut Header = String::new();
					loop {
						Header.clear();
						let mut ContentLength:usize = 0;
						loop {
							Header.clear();
							match Reader.read_line(&mut Header).await {
								Ok(0) => return, // EOF
								Ok(_) => {},
								Err(Error) => {
									crate::dev_log!(
										"exthost",
										"warn: [DebugAdapter] stdout read failed for session {}: {}",
										StdoutSessionId,
										Error
									);
									return;
								},
							}
							let Trimmed = Header.trim_end_matches("\r\n").trim_end_matches('\n');
							if Trimmed.is_empty() {
								break;
							}
							if let Some(Rest) = Trimmed.strip_prefix("Content-Length:") {
								if let Ok(N) = Rest.trim().parse::<usize>() {
									ContentLength = N;
								}
							}
						}
						if ContentLength == 0 {
							continue;
						}
						let mut Body = vec![0u8; ContentLength];
						if let Err(Error) = Reader.read_exact(&mut Body).await {
							crate::dev_log!(
								"exthost",
								"warn: [DebugAdapter] stdout body read failed for session {}: {}",
								StdoutSessionId,
								Error
							);
							return;
						}
						let Parsed:Value = serde_json::from_slice(&Body).unwrap_or(Value::Null);
						let _ = StdoutHandle.emit(
							"sky://debug/dap-message",
							json!({
								"sessionId": StdoutSessionId,
								"sidecarId": StdoutSidecar,
								"message": Parsed,
							}),
						);
					}
				});

				// Stderr drain: emit each line as a `[DebugAdapter] stderr`
				// dev_log line so adapter crash reasons surface alongside
				// other Mountain logs.
				let StderrSessionId = SessionID.clone();
				tokio::spawn(async move {
					use tokio::io::{AsyncBufReadExt, BufReader};
					let mut Lines = BufReader::new(Stderr).lines();
					while let Ok(Some(Line)) = Lines.next_line().await {
						crate::dev_log!("exthost", "[DebugAdapter] stderr session={}: {}", StderrSessionId, Line);
					}
				});

				AdapterStdinSender = Some(Sender);
				AdapterChildPid = Pid;
				dev_log!(
					"exthost",
					"[DebugProvider] Spawned executable adapter for session '{}' pid={:?} command={:?}",
					SessionID,
					Pid,
					Command
				);
			},
			"server" | "pipeServer" => {
				dev_log!(
					"exthost",
					"warn: [DebugProvider] Adapter type '{}' not yet wired (session '{}'). Reverse-RPC dispatch only.",
					DescriptorType,
					SessionID
				);
				AdapterStdinSender = None;
				AdapterChildPid = None;
			},
			"implementation" => {
				dev_log!(
					"exthost",
					"[DebugProvider] Inline implementation adapter for session '{}' - DAP frames travel via Cocoon \
					 reverse-RPC.",
					SessionID
				);
				AdapterStdinSender = None;
				AdapterChildPid = None;
			},
			_ => {
				dev_log!(
					"exthost",
					"warn: [DebugProvider] Unknown adapter descriptor type '{}' for session '{}' - registering \
					 session without spawn.",
					DescriptorType,
					SessionID
				);
				AdapterStdinSender = None;
				AdapterChildPid = None;
			},
		}

		// Persist the session in ApplicationState so SendCommand can
		// resolve it. Without this, every subsequent DAP command from the
		// workbench would land on the "session not found" path even though
		// the adapter is alive and listening.
		if let Err(RegError) = self.ApplicationState.Feature.Debug.RegisterDebugSession(
			crate::ApplicationState::State::FeatureState::Debug::DebugState::DebugSessionEntry {
				SessionId:SessionID.clone(),
				DebugType:DebugType.clone(),
				SideCarIdentifier:TargetSideCar.clone(),
				StdinSender:AdapterStdinSender,
				ChildPid:AdapterChildPid,
			},
		) {
			dev_log!(
				"exthost",
				"warn: [DebugProvider] Failed to register session '{}' in DebugState: {}",
				SessionID,
				RegError
			);
		}

		// Notify Cocoon that the session has started so any
		// `vscode.debug.onDidStartDebugSession` listeners (registered
		// from extensions through `DebugNamespace.ts:124`) fire. The
		// payload mirrors VS Code's wire shape - extensions read
		// `id`, `type`, `name`, and `configuration` off the session
		// object passed to the listener. Until full session tracking
		// lands in ApplicationState we synthesise from the resolved
		// configuration so extensions can observe activation even
		// while the adapter spawn path is still a stub.
		let StartedMethod = format!("{}$onDidStartDebugSession", ProxyTarget::ExtHostDebug.GetTargetPrefix());
		let StartedSession = json!({
			"id": SessionID.clone(),
			"type": DebugType.clone(),
			"name": ResolvedConfig.get("name").and_then(Value::as_str).unwrap_or(&DebugType),
			"configuration": ResolvedConfig.clone(),
		});
		if let Err(error) = IPCProvider
			.SendNotificationToSideCar(TargetSideCar.clone(), StartedMethod, json!([StartedSession]))
			.await
		{
			dev_log!(
				"exthost",
				"warn: [DebugProvider] StartDebugging notification failed for '{}': {:?}",
				SessionID,
				error
			);
		}

		// Sky-side debug viewlet observers consume this stream so the
		// debug toolbar / call stack panel light up without waiting on
		// the typed `DebugService::ActiveSessions` snapshot. Mirrors
		// `WebviewLifecycle.rs`'s pattern of dual-emitting to Cocoon
		// (typed RPC) and Sky (renderer event).
		let _ = self.ApplicationHandle.emit(
			"sky://debug/sessionStart",
			json!({
				"sessionId": SessionID.clone(),
				"type": DebugType.clone(),
				"configuration": ResolvedConfig.clone(),
			}),
		);

		dev_log!("exthost", "[DebugProvider] Debug session '{}' started (simulation).", SessionID);
		Ok(SessionID)
	}

	async fn SendCommand(&self, SessionID:String, Command:String, Arguments:Value) -> Result<Value, CommonError> {
		dev_log!(
			"exthost",
			"[DebugProvider] SendCommand for session '{}' (command: '{}', args: {:?})",
			SessionID,
			Command,
			Arguments
		);

		// Resolve the active session. Missing entries fall through to the
		// reverse-RPC path below so commands targeting an inline-impl
		// adapter (DebugAdapterInlineImplementation - JS-only adapters
		// running inside Cocoon) still reach their handler.
		let SessionEntry = self.ApplicationState.Feature.Debug.GetDebugSession(&SessionID);

		// DAP framing: producer must wrap the JSON message in a
		// `Content-Length: <n>\r\n\r\n<body>` header. Sequence numbers
		// are caller-allocated (the workbench's `RawDebugSession` keeps
		// its own `_currentReqId`); we don't reorder. Wire the request
		// shape that VS Code's `mainThreadDebugService.ts` produces:
		// `{ seq, type: "request", command, arguments }`. Mountain
		// doesn't currently track per-session seq numbers - upstream
		// VS Code increments request_seq on the WORKBENCH side and we
		// just forward verbatim - so we emit `0` here as a placeholder
		// when the caller hasn't supplied one in `Arguments.seq`.
		let RequestSeq = Arguments.get("seq").and_then(Value::as_u64).unwrap_or(0);
		let RequestArguments = Arguments.get("arguments").cloned().unwrap_or(Arguments.clone());
		let DapRequest = json!({
			"seq": RequestSeq,
			"type": "request",
			"command": Command,
			"arguments": RequestArguments,
		});

		if let Some(Entry) = SessionEntry.as_ref() {
			if let Some(Sender) = Entry.StdinSender.as_ref() {
				let Body = serde_json::to_vec(&DapRequest).map_err(|Error| {
					CommonError::IPCError {
						Description:format!("Failed to serialize DAP request for session {}: {}", SessionID, Error),
					}
				})?;
				let Header = format!("Content-Length: {}\r\n\r\n", Body.len());
				let mut Frame = Vec::with_capacity(Header.len() + Body.len());
				Frame.extend_from_slice(Header.as_bytes());
				Frame.extend_from_slice(&Body);
				Sender.send(Frame).map_err(|Error| {
					CommonError::IPCError {
						Description:format!("Adapter stdin channel for session {} closed: {}", SessionID, Error),
					}
				})?;
				// stdio adapters reply asynchronously through the
				// stdout reader task, which fans the response out via
				// `sky://debug/dap-message`. Returning an ack now lets
				// the workbench's request sequencer continue; the actual
				// response is correlated by `request_seq` on the
				// renderer side.
				return Ok(json!({
					"success": true,
					"sessionId": SessionID,
					"command": Command,
					"transport": "stdio",
				}));
			}
		}

		// No live stdin pipe: route via reverse-RPC into the owning
		// sidecar. This covers (1) sessions created with
		// `DebugAdapterInlineImplementation` where the adapter runs
		// inside the extension host, (2) `server` / `pipeServer`
		// descriptors awaiting their connection wiring, and (3)
		// commands fired before `RegisterDebugSession` has landed
		// (rare race during spawn). The Cocoon-side handler dispatches
		// based on session-id stored in `extHostDebug.ts`'s session map.
		let TargetSidecar = SessionEntry
			.as_ref()
			.map(|E| E.SideCarIdentifier.clone())
			.unwrap_or_else(|| "cocoon-main".to_string());
		let SendDapMethod = format!("{}$sendDAPRequest", ProxyTarget::ExtHostDebug.GetTargetPrefix());
		let IPCProvider:Arc<dyn IPCProvider> = self.Require();
		match IPCProvider
			.SendRequestToSideCar(
				TargetSidecar,
				SendDapMethod,
				json!([{ "sessionId": SessionID, "request": DapRequest }]),
				15000,
			)
			.await
		{
			Ok(Response) => Ok(Response),
			Err(Error) => {
				dev_log!(
					"exthost",
					"warn: [DebugProvider] reverse-RPC SendCommand failed for session {}: {:?}",
					SessionID,
					Error
				);
				Err(Error)
			},
		}
	}

	async fn StopDebugging(&self, SessionID:String) -> Result<(), CommonError> {
		dev_log!("exthost", "[DebugProvider] StopDebugging request for session '{}'", SessionID);

		// Try a graceful DAP `disconnect` first so the adapter can flush
		// pending state and let the debuggee detach cleanly. Failures
		// are logged-and-tolerated; the unregister below force-closes
		// the stdin pipe regardless.
		if let Some(Entry) = self.ApplicationState.Feature.Debug.GetDebugSession(&SessionID) {
			if let Some(Sender) = Entry.StdinSender.as_ref() {
				let DisconnectRequest = json!({
					"seq": 0,
					"type": "request",
					"command": "disconnect",
					"arguments": { "restart": false, "terminateDebuggee": true },
				});
				if let Ok(Body) = serde_json::to_vec(&DisconnectRequest) {
					let Header = format!("Content-Length: {}\r\n\r\n", Body.len());
					let mut Frame = Vec::with_capacity(Header.len() + Body.len());
					Frame.extend_from_slice(Header.as_bytes());
					Frame.extend_from_slice(&Body);
					let _ = Sender.send(Frame);
				}
			}
		}
		// Drop the entry. The drained `Sender` clone in the in-flight
		// stdin writer task will see the channel close on its next `recv`
		// and shut the adapter's stdin, which most adapters interpret
		// as a graceful disconnect.
		let _ = self.ApplicationState.Feature.Debug.UnregisterDebugSession(&SessionID);

		let IPCProvider:Arc<dyn IPCProvider> = self.Require();
		let TerminateMethod = format!("{}$onDidTerminateDebugSession", ProxyTarget::ExtHostDebug.GetTargetPrefix());
		if let Err(error) = IPCProvider
			.SendNotificationToSideCar("cocoon-main".to_string(), TerminateMethod, json!([{ "id": SessionID.clone() }]))
			.await
		{
			dev_log!(
				"exthost",
				"warn: [DebugProvider] StopDebugging notification failed for '{}': {:?}",
				SessionID,
				error
			);
		}
		let _ = self
			.ApplicationHandle
			.emit("sky://debug/sessionEnd", json!({ "sessionId": SessionID.clone() }));
		Ok(())
	}
}