crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_debugger/adapters.py

@@ -0,0 +1,332 @@
+"""Debug adapter discovery and launch configuration helpers."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.subprocess_utils import (
+    resolve_executable_command,
+    subprocess_group_options,
+)
+
+
+_EXTENSION_LANGUAGE_MAP: dict[str, str] = {
+    ".c": "cpp",
+    ".cc": "cpp",
+    ".cpp": "cpp",
+    ".cxx": "cpp",
+    ".h": "cpp",
+    ".hh": "cpp",
+    ".hpp": "cpp",
+    ".hxx": "cpp",
+    ".rs": "rust",
+    ".py": "python",
+    ".pyi": "python",
+    ".go": "go",
+    ".java": "java",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+}
+
+
+@dataclass(frozen=True)
+class AdapterCandidate:
+    """A DAP adapter candidate for a language."""
+
+    language: str
+    adapter_id: str
+    label: str
+    command: list[str]
+    install_hint: str
+    official: bool = True
+    probe_command: list[str] | None = None
+
+
+@dataclass
+class AdapterStatus:
+    """Availability status for an adapter candidate."""
+
+    language: str
+    adapter_id: str
+    label: str
+    command: list[str]
+    available: bool
+    reason: str
+    install_hint: str
+    official: bool = True
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "language": self.language,
+            "adapter_id": self.adapter_id,
+            "label": self.label,
+            "command": self.command,
+            "available": self.available,
+            "reason": self.reason,
+            "install_hint": self.install_hint,
+            "official": self.official,
+        }
+
+
+def infer_language(path_or_language: str | None) -> str | None:
+    """Infer a normalized language name from a language or file path."""
+    if not path_or_language:
+        return None
+    value = path_or_language.strip().lower()
+    aliases = {
+        "c": "cpp",
+        "c++": "cpp",
+        "cc": "cpp",
+        "cxx": "cpp",
+        "py": "python",
+        "js": "javascript",
+        "node": "javascript",
+        "ts": "typescript",
+    }
+    if value in aliases:
+        return aliases[value]
+    if value in {
+        "cpp",
+        "rust",
+        "python",
+        "go",
+        "java",
+        "typescript",
+        "javascript",
+    }:
+        return value
+    suffix = Path(value).suffix.lower()
+    return _EXTENSION_LANGUAGE_MAP.get(suffix)
+
+
+class AdapterRegistry:
+    """Finds configured and built-in DAP adapters."""
+
+    def __init__(self, config: dict[str, Any] | None = None) -> None:
+        self._config = config or {}
+        self._timeout = float(self._config.get("adapter_probe_timeout_seconds", 2))
+
+    def status(self, language: str | None = None) -> list[AdapterStatus]:
+        """Return adapter status for one language or all supported languages."""
+        candidates = self._configured_candidates() + self._builtin_candidates()
+        wanted = infer_language(language) if language else None
+        results: list[AdapterStatus] = []
+        seen: set[tuple[str, str, tuple[str, ...]]] = set()
+        for candidate in candidates:
+            if wanted and candidate.language != wanted:
+                continue
+            key = (candidate.language, candidate.adapter_id, tuple(candidate.command))
+            if key in seen:
+                continue
+            seen.add(key)
+            results.append(self._probe(candidate))
+        return results
+
+    def resolve(self, language: str, adapter_id: str | None = None) -> AdapterStatus | None:
+        """Return the preferred available adapter for a language."""
+        normalized = infer_language(language)
+        if not normalized:
+            return None
+        statuses = self.status(normalized)
+        available = [s for s in statuses if s.available]
+        if adapter_id:
+            for status in available:
+                if status.adapter_id == adapter_id:
+                    return status
+            return None
+        return available[0] if available else None
+
+    def install_hints(self, language: str | None = None) -> dict[str, list[str]]:
+        hints: dict[str, list[str]] = {}
+        for status in self.status(language):
+            if not status.available:
+                hints.setdefault(status.language, [])
+                if status.install_hint not in hints[status.language]:
+                    hints[status.language].append(status.install_hint)
+        return hints
+
+    def _configured_candidates(self) -> list[AdapterCandidate]:
+        adapters = self._config.get("adapters", {})
+        if not isinstance(adapters, dict):
+            return []
+        candidates: list[AdapterCandidate] = []
+        for language, raw in adapters.items():
+            normalized = infer_language(str(language))
+            if not normalized or not isinstance(raw, dict):
+                continue
+            command = raw.get("command")
+            if not isinstance(command, list) or not command:
+                continue
+            command = [str(part) for part in command]
+            candidates.append(
+                AdapterCandidate(
+                    language=normalized,
+                    adapter_id=str(raw.get("adapter_id", "configured")),
+                    label=str(raw.get("label", f"Configured {normalized} adapter")),
+                    command=command,
+                    install_hint="Configured in tool_settings.Debugger.adapters.",
+                    official=bool(raw.get("official", False)),
+                    probe_command=[str(part) for part in raw.get("probe_command", [])]
+                    if isinstance(raw.get("probe_command"), list)
+                    else None,
+                )
+            )
+        return candidates
+
+    def _probe(self, candidate: AdapterCandidate) -> AdapterStatus:
+        executable = candidate.command[0]
+        if not shutil.which(executable):
+            return AdapterStatus(
+                language=candidate.language,
+                adapter_id=candidate.adapter_id,
+                label=candidate.label,
+                command=candidate.command,
+                available=False,
+                reason=f"executable not found: {executable}",
+                install_hint=candidate.install_hint,
+                official=candidate.official,
+            )
+        probe = candidate.probe_command
+        if probe:
+            try:
+                result = subprocess.run(
+                    resolve_executable_command(probe),
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    timeout=self._timeout,
+                    check=False,
+                    **subprocess_group_options(),
+                )
+            except Exception as exc:
+                return AdapterStatus(
+                    language=candidate.language,
+                    adapter_id=candidate.adapter_id,
+                    label=candidate.label,
+                    command=candidate.command,
+                    available=False,
+                    reason=f"probe failed: {exc}",
+                    install_hint=candidate.install_hint,
+                    official=candidate.official,
+                )
+            if result.returncode != 0:
+                return AdapterStatus(
+                    language=candidate.language,
+                    adapter_id=candidate.adapter_id,
+                    label=candidate.label,
+                    command=candidate.command,
+                    available=False,
+                    reason=f"probe exited with {result.returncode}",
+                    install_hint=candidate.install_hint,
+                    official=candidate.official,
+                )
+        return AdapterStatus(
+            language=candidate.language,
+            adapter_id=candidate.adapter_id,
+            label=candidate.label,
+            command=candidate.command,
+            available=True,
+            reason="available",
+            install_hint=candidate.install_hint,
+            official=candidate.official,
+        )
+
+    @staticmethod
+    def _builtin_candidates() -> list[AdapterCandidate]:
+        return [
+            AdapterCandidate(
+                language="python",
+                adapter_id="debugpy",
+                label="debugpy",
+                command=["python", "-m", "debugpy.adapter"],
+                probe_command=["python", "-c", "import debugpy.adapter"],
+                install_hint="Install Python debugpy: python -m pip install debugpy",
+            ),
+            AdapterCandidate(
+                language="python",
+                adapter_id="debugpy-python3",
+                label="debugpy via python3",
+                command=["python3", "-m", "debugpy.adapter"],
+                probe_command=["python3", "-c", "import debugpy.adapter"],
+                install_hint="Install Python debugpy: python3 -m pip install debugpy",
+            ),
+            AdapterCandidate(
+                language="go",
+                adapter_id="delve",
+                label="Delve DAP",
+                command=["dlv", "dap"],
+                install_hint="Install Delve: go install github.com/go-delve/delve/cmd/dlv@latest",
+            ),
+            AdapterCandidate(
+                language="cpp",
+                adapter_id="lldb-dap",
+                label="LLVM lldb-dap",
+                command=["lldb-dap"],
+                install_hint="Install LLVM lldb-dap from your LLVM/LLDB toolchain.",
+            ),
+            AdapterCandidate(
+                language="cpp",
+                adapter_id="lldb-vscode",
+                label="LLVM lldb-vscode",
+                command=["lldb-vscode"],
+                install_hint="Install LLVM/LLDB; older distributions expose lldb-vscode.",
+            ),
+            AdapterCandidate(
+                language="cpp",
+                adapter_id="gdb-dap",
+                label="GDB DAP",
+                command=["gdb", "--interpreter=dap"],
+                install_hint="Install a GDB build with DAP support.",
+            ),
+            AdapterCandidate(
+                language="rust",
+                adapter_id="lldb-dap",
+                label="LLVM lldb-dap",
+                command=["lldb-dap"],
+                install_hint="Install LLVM lldb-dap and build Rust binaries with debug symbols.",
+            ),
+            AdapterCandidate(
+                language="rust",
+                adapter_id="lldb-vscode",
+                label="LLVM lldb-vscode",
+                command=["lldb-vscode"],
+                install_hint="Install LLVM/LLDB and build Rust binaries with debug symbols.",
+            ),
+            AdapterCandidate(
+                language="java",
+                adapter_id="vscode-java-debug",
+                label="Java Debug Server",
+                command=["java-debug-adapter"],
+                install_hint=(
+                    "Install the official vscode-java-debug adapter and configure "
+                    "tool_settings.Debugger.adapters.java.command if it is not on PATH."
+                ),
+            ),
+            AdapterCandidate(
+                language="javascript",
+                adapter_id="vscode-js-debug",
+                label="Microsoft vscode-js-debug",
+                command=["js-debug-adapter"],
+                install_hint=(
+                    "Install Microsoft vscode-js-debug and configure "
+                    "tool_settings.Debugger.adapters.javascript.command if it is not on PATH."
+                ),
+            ),
+            AdapterCandidate(
+                language="typescript",
+                adapter_id="vscode-js-debug",
+                label="Microsoft vscode-js-debug",
+                command=["js-debug-adapter"],
+                install_hint=(
+                    "Install Microsoft vscode-js-debug and configure "
+                    "tool_settings.Debugger.adapters.typescript.command if it is not on PATH."
+                ),
+            ),
+        ]

crabcode_debugger/dap.py

@@ -0,0 +1,304 @@
+"""Small async Debug Adapter Protocol client."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import time
+from dataclasses import dataclass
+from typing import Any
+
+from crabcode_core.subprocess_utils import (
+    resolve_executable_command,
+    managed_process_command,
+    subprocess_group_options,
+    terminate_process_tree,
+)
+
+
+class DAPError(Exception):
+    """Raised when a DAP request fails."""
+
+
+@dataclass
+class DAPEvent:
+    event: str
+    body: dict[str, Any]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"event": self.event, "body": self.body}
+
+
+class DAPClient:
+    """Communicates with a debug adapter over stdio."""
+
+    def __init__(
+        self,
+        command: list[str],
+        *,
+        cwd: str,
+        env: dict[str, str] | None = None,
+        timeout: float = 30.0,
+        max_events: int = 10_000,
+    ) -> None:
+        self.command = command
+        self.cwd = cwd
+        self.env = {**os.environ, **(env or {})}
+        if os.name == "nt":
+            self.env = {key.upper(): value for key, value in self.env.items()}
+        self.timeout = timeout
+        self._process: asyncio.subprocess.Process | None = None
+        self._reader_task: asyncio.Task[None] | None = None
+        self._stderr_task: asyncio.Task[None] | None = None
+        self._seq = 0
+        self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._pending_commands: dict[int, str] = {}
+        self._write_lock = asyncio.Lock()
+        self.events: asyncio.Queue[DAPEvent] = asyncio.Queue(maxsize=max(1, int(max_events)))
+        self._dropped_events = 0
+
+    async def start(self) -> None:
+        if self._process is not None:
+            if self._process.returncode is None:
+                return
+            raise DAPError(f"debug adapter exited with code {self._process.returncode}")
+        launch_command = resolve_executable_command(self.command, env=self.env, cwd=self.cwd)
+        self._process = await asyncio.create_subprocess_exec(
+            *managed_process_command(launch_command),
+            cwd=self.cwd,
+            env=self.env,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            **subprocess_group_options(),
+        )
+        self._reader_task = asyncio.create_task(self._reader_loop())
+        self._stderr_task = asyncio.create_task(self._drain_stderr())
+
+    async def close(self) -> None:
+        for future in list(self._pending.values()):
+            if not future.done():
+                future.cancel()
+            elif not future.cancelled():
+                future.exception()
+        self._pending.clear()
+        self._pending_commands.clear()
+
+        if self._reader_task and not self._reader_task.done():
+            self._reader_task.cancel()
+            try:
+                await self._reader_task
+            except asyncio.CancelledError:
+                pass
+        self._reader_task = None
+
+        if self._stderr_task and not self._stderr_task.done():
+            self._stderr_task.cancel()
+            try:
+                await self._stderr_task
+            except asyncio.CancelledError:
+                pass
+        self._stderr_task = None
+
+        if self._process and self._process.returncode is None:
+            await terminate_process_tree(self._process)
+        self._process = None
+
+    async def request(
+        self,
+        command: str,
+        arguments: dict[str, Any] | None = None,
+        *,
+        timeout: float | None = None,
+    ) -> dict[str, Any]:
+        seq = await self.start_request(command, arguments)
+        return await self.wait_response(seq, timeout=timeout)
+
+    async def start_request(
+        self,
+        command: str,
+        arguments: dict[str, Any] | None = None,
+    ) -> int:
+        """Send a DAP request and return its sequence without waiting.
+
+        Some DAP requests, notably launch/attach, may not respond until after
+        the client sends configurationDone. The session manager uses this to
+        keep those requests pending while breakpoints are configured.
+        """
+        await self.start()
+        if not self._process or not self._process.stdin:
+            raise DAPError("debug adapter process is not running")
+
+        self._seq += 1
+        seq = self._seq
+        payload = {
+            "seq": seq,
+            "type": "request",
+            "command": command,
+            "arguments": arguments or {},
+        }
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[dict[str, Any]] = loop.create_future()
+        self._pending[seq] = future
+        self._pending_commands[seq] = command
+        await self._send(payload)
+        return seq
+
+    async def wait_response(
+        self,
+        seq: int,
+        *,
+        timeout: float | None = None,
+    ) -> dict[str, Any]:
+        future = self._pending.get(seq)
+        if future is None:
+            raise DAPError(f"unknown pending DAP request: {seq}")
+        command = self._pending_commands.get(seq, f"seq {seq}")
+        try:
+            response = await asyncio.wait_for(future, timeout=timeout or self.timeout)
+        finally:
+            self._pending.pop(seq, None)
+            self._pending_commands.pop(seq, None)
+        if not response.get("success", False):
+            error = response.get("body", {}).get("error", {})
+            message = response.get("message") or error.get("format")
+            raise DAPError(str(message or f"DAP request failed: {command}"))
+        body = response.get("body", {})
+        return body if isinstance(body, dict) else {"value": body}
+
+    async def drain_events(self) -> list[DAPEvent]:
+        drained: list[DAPEvent] = []
+        if self._dropped_events:
+            drained.append(
+                DAPEvent(
+                    event="output",
+                    body={
+                        "category": "console",
+                        "output": f"CrabCode dropped {self._dropped_events} buffered DAP events.\n",
+                    },
+                )
+            )
+            self._dropped_events = 0
+        while True:
+            try:
+                drained.append(self.events.get_nowait())
+            except asyncio.QueueEmpty:
+                break
+        return drained
+
+    async def wait_for_event(
+        self,
+        event_name: str,
+        *,
+        timeout: float | None = None,
+    ) -> DAPEvent | None:
+        deadline = time.monotonic() + (timeout if timeout is not None else self.timeout)
+        unmatched: list[DAPEvent] = []
+        try:
+            while True:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    return None
+                event = await asyncio.wait_for(self.events.get(), timeout=remaining)
+                if event.event == event_name:
+                    return event
+                unmatched.append(event)
+        except asyncio.TimeoutError:
+            return None
+        finally:
+            for event in unmatched:
+                self._queue_event(event)
+
+    async def _send(self, payload: dict[str, Any]) -> None:
+        if not self._process or not self._process.stdin:
+            raise DAPError("debug adapter process is not running")
+        body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+        header = f"Content-Length: {len(body)}\r\n\r\n".encode("ascii")
+        async with self._write_lock:
+            self._process.stdin.write(header + body)
+            await self._process.stdin.drain()
+
+    async def _reader_loop(self) -> None:
+        if not self._process or not self._process.stdout:
+            return
+        reader = self._process.stdout
+        while True:
+            try:
+                headers: dict[str, str] = {}
+                while True:
+                    line = await reader.readline()
+                    if not line:
+                        raise EOFError("debug adapter closed stdout")
+                    if line in {b"\r\n", b"\n"}:
+                        break
+                    text = line.decode("ascii", errors="replace").strip()
+                    if ":" in text:
+                        key, value = text.split(":", 1)
+                        headers[key.lower()] = value.strip()
+                length_raw = headers.get("content-length")
+                if not length_raw:
+                    continue
+                body = await reader.readexactly(int(length_raw))
+                message = json.loads(body.decode("utf-8", errors="replace"))
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                for future in list(self._pending.values()):
+                    if not future.done():
+                        future.set_exception(DAPError(f"DAP reader failed: {exc}"))
+                return
+            await self._handle_message(message)
+
+    async def _handle_message(self, message: dict[str, Any]) -> None:
+        msg_type = message.get("type")
+        if msg_type == "response":
+            request_seq = message.get("request_seq")
+            future = self._pending.get(request_seq)
+            if future and not future.done():
+                future.set_result(message)
+            return
+        if msg_type == "event":
+            event = str(message.get("event", ""))
+            body = message.get("body", {})
+            event_body = body if isinstance(body, dict) else {}
+            self._queue_event(DAPEvent(event=event, body=event_body))
+
+    def _queue_event(self, event: DAPEvent) -> None:
+        try:
+            self.events.put_nowait(event)
+            return
+        except asyncio.QueueFull:
+            pass
+
+        if event.event == "output":
+            self._dropped_events += 1
+            return
+
+        retained: list[DAPEvent] = []
+        discarded = False
+        while True:
+            try:
+                queued = self.events.get_nowait()
+            except asyncio.QueueEmpty:
+                break
+            if not discarded and queued.event == "output":
+                self._dropped_events += 1
+                discarded = True
+                continue
+            retained.append(queued)
+
+        if not discarded and retained:
+            retained.pop(0)
+            self._dropped_events += 1
+        for queued in retained:
+            self.events.put_nowait(queued)
+        self.events.put_nowait(event)
+
+    async def _drain_stderr(self) -> None:
+        if not self._process or not self._process.stderr:
+            return
+        while True:
+            line = await self._process.stderr.readline()
+            if not line:
+                return