"CLI-Anything: Making ALL Software Agent-Native" -- CLI-Hub: https://clianything.cc/
Python
fix: keep lldb dap responsive while running
aimidi77321f997abc
diff --git a/lldb/agent-harness/cli_anything/lldb/README.md b/lldb/agent-harness/cli_anything/lldb/README.mdindex 5a1a82cee..2ec0c393a 100644--- a/lldb/agent-harness/cli_anything/lldb/README.md+++ b/lldb/agent-harness/cli_anything/lldb/README.md@@ -117,6 +117,22 @@ Variables support expandable child references for structs/classes/arrays, and`setVariable` can update stopped-frame locals or child values when LLDB allowsthe assignment.+For long-running GUI targets, DAP `continue` responds before the blocking LLDB+`SBProcess.Continue()` call completes, then waits on a background thread for the+next stop. DAP `pause` uses `SBProcess.SendAsyncInterrupt()` so the adapter stays+responsive while the debuggee is running. If `setBreakpoints` or+`setFunctionBreakpoints` arrives during an active continue, the adapter first+requests an async interrupt, waits for the continue thread to observe a stopped+state, and only then mutates LLDB breakpoints. If the process does not stop in+time, the request fails clearly instead of hanging the DAP loop.++`launch` and `attach` accept the non-standard boolean argument+`autoContinueInternalBreakpoints`. When enabled, the adapter auto-continues+known internal JIT/startup breakpoint stops such as NVIDIA+`__jit_debug_register_code` / `jit-debug-register` and Windows+`Exception 0x80000003` at ``ntdll.dll`DbgBreakPoint``, while writing a DAP+`output` event explaining the auto-continue.+The persistent session daemon now speaks a localhost JSON socket protocol andstores its session token in an owner-scoped state file. `memory find` scans in64 KiB chunks and caps each request at 1 MiB.diff --git a/lldb/agent-harness/cli_anything/lldb/core/session.py b/lldb/agent-harness/cli_anything/lldb/core/session.pyindex 70acc2f2b..3ea6eccb0 100644--- a/lldb/agent-harness/cli_anything/lldb/core/session.py+++ b/lldb/agent-harness/cli_anything/lldb/core/session.py@@ -199,6 +199,13 @@ class LLDBSession:raise RuntimeError(f"Interrupt failed: {error}")return self._process_info()+ def interrupt_async(self) -> Dict[str, Any]:+ self._require_process()+ error = self.process.SendAsyncInterrupt()+ if error is not None and not error.Success():+ raise RuntimeError(f"Async interrupt failed: {error}")+ return {"status": "interrupt_requested"}+def backtrace(self, limit: int = 50) -> Dict[str, Any]:thread = self._current_thread()frames = []diff --git a/lldb/agent-harness/cli_anything/lldb/dap.py b/lldb/agent-harness/cli_anything/lldb/dap.pyindex 79daceb29..94468ac16 100644--- a/lldb/agent-harness/cli_anything/lldb/dap.py+++ b/lldb/agent-harness/cli_anything/lldb/dap.py@@ -8,6 +8,7 @@ import jsonimport osimport shleximport sys+import threadingfrom pathlib import Pathfrom typing import Any, BinaryIO, Callable@@ -80,6 +81,13 @@ class LLDBDebugAdapter:self._variable_refs: dict[int, dict[str, Any]] = {}self._next_ref = 1self._log_file = Path(log_file).expanduser() if log_file else None+ self._protocol_lock = threading.Lock()+ self._lldb_api_lock = threading.RLock()+ self._continue_state = threading.Condition()+ self._continue_active = False+ self._auto_continue_internal_breakpoints = False+ self._pause_requested = False+ self._mutation_stop_timeout = 10.0def run(self, instream: BinaryIO | None = None, outstream: BinaryIO | None = None) -> int:instream = instream or sys.stdin.buffer@@ -157,6 +165,7 @@ class LLDBDebugAdapter:"stop_at_entry": bool(args.get("stopOnEntry", False)),"suppress_stdio": True,}+ self._auto_continue_internal_breakpoints = bool(args.get("autoContinueInternalBreakpoints", False))self._pending_attach = Nonereturn {}, None@@ -174,6 +183,7 @@ class LLDBDebugAdapter:"name": str(name) if name else None,"wait_for": bool(args.get("waitFor", False)),}+ self._auto_continue_internal_breakpoints = bool(args.get("autoContinueInternalBreakpoints", False))self._pending_launch = Nonereturn {}, None@@ -220,51 +230,55 @@ class LLDBDebugAdapter:if not path:raise RuntimeError("setBreakpoints requires source.path")+ self._ensure_stopped_for_target_mutation("setBreakpoints")session = self._ensure_session()source_key = str(Path(path))- for bp_id in self._source_breakpoints.get(source_key, []):- try:- session.breakpoint_delete(bp_id)- except Exception:- pass-- dap_breakpoints = []- created_ids = []- for item in args.get("breakpoints") or []:- line = int(item.get("line"))- payload = session.breakpoint_set(- file=source_key,- line=line,- condition=item.get("condition"),- allow_pending=True,- )- created_ids.append(payload["id"])- dap_breakpoints.append(self._to_dap_breakpoint(payload, source_key, requested_line=line))+ with self._lldb_api_lock:+ for bp_id in self._source_breakpoints.get(source_key, []):+ try:+ session.breakpoint_delete(bp_id)+ except Exception:+ pass++ dap_breakpoints = []+ created_ids = []+ for item in args.get("breakpoints") or []:+ line = int(item.get("line"))+ payload = session.breakpoint_set(+ file=source_key,+ line=line,+ condition=item.get("condition"),+ allow_pending=True,+ )+ created_ids.append(payload["id"])+ dap_breakpoints.append(self._to_dap_breakpoint(payload, source_key, requested_line=line))self._source_breakpoints[source_key] = created_idsreturn {"breakpoints": dap_breakpoints}, Nonedef _handle_setFunctionBreakpoints(self, args: dict[str, Any]):+ self._ensure_stopped_for_target_mutation("setFunctionBreakpoints")session = self._ensure_session()- for bp_id in self._function_breakpoints:- try:- session.breakpoint_delete(bp_id)- except Exception:- pass-- self._function_breakpoints = []- result = []- for item in args.get("breakpoints") or []:- name = item.get("name")- if not name:- continue- payload = session.breakpoint_set(- function=str(name),- condition=item.get("condition"),- allow_pending=True,- )- self._function_breakpoints.append(payload["id"])- result.append(self._to_dap_breakpoint(payload))+ with self._lldb_api_lock:+ for bp_id in self._function_breakpoints:+ try:+ session.breakpoint_delete(bp_id)+ except Exception:+ pass++ self._function_breakpoints = []+ result = []+ for item in args.get("breakpoints") or []:+ name = item.get("name")+ if not name:+ continue+ payload = session.breakpoint_set(+ function=str(name),+ condition=item.get("condition"),+ allow_pending=True,+ )+ self._function_breakpoints.append(payload["id"])+ result.append(self._to_dap_breakpoint(payload))return {"breakpoints": result}, Nonedef _handle_threads(self, _args: dict[str, Any]):@@ -357,16 +371,20 @@ class LLDBDebugAdapter:def post_send():self._reset_refs_for_resume()self._send_continued_event()- self._ensure_session().continue_exec()- self._emit_breakpoint_updates()- self._emit_execution_event(default_reason="breakpoint")+ self._start_continue_thread(+ name="cli-anything-lldb-dap-continue",+ default_reason="breakpoint",+ )return {"allThreadsContinued": True}, post_senddef _handle_pause(self, _args: dict[str, Any]):def post_send():- self._ensure_session().interrupt()- self._emit_execution_event(default_reason="pause")+ self._pause_requested = True+ self._request_async_interrupt()+ if not self._is_continue_active():+ with self._lldb_api_lock:+ self._emit_execution_event(default_reason="pause")return {}, post_send@@ -448,11 +466,72 @@ class LLDBDebugAdapter:def post_send():self._reset_refs_for_resume()self._send_continued_event()- step_fn()- self._emit_execution_event(default_reason="step")+ with self._lldb_api_lock:+ step_fn()+ self._emit_execution_event(default_reason="step")return post_send+ def _start_continue_thread(self, *, name: str, default_reason: str):+ with self._continue_state:+ if self._continue_active:+ self._log("continue requested while a continue operation is already active")+ return+ self._continue_active = True+ threading.Thread(+ target=self._continue_until_stop,+ kwargs={"default_reason": default_reason},+ name=name,+ daemon=True,+ ).start()++ def _continue_until_stop(self, *, default_reason: str):+ try:+ self._ensure_session().continue_exec()+ except Exception as exc:+ self._log(f"continue failed: {exc}")+ self._send_event("output", {"category": "stderr", "output": f"continue failed: {exc}\n"})+ self._send_event("terminated")+ return+ finally:+ self._mark_continue_inactive()++ with self._lldb_api_lock:+ self._emit_breakpoint_updates()+ self._emit_execution_event(default_reason=default_reason)++ def _mark_continue_inactive(self):+ with self._continue_state:+ self._continue_active = False+ self._continue_state.notify_all()++ def _is_continue_active(self) -> bool:+ with self._continue_state:+ return self._continue_active++ def _ensure_stopped_for_target_mutation(self, operation: str):+ if not self._is_continue_active():+ return+ self._log(f"{operation}: interrupting running debuggee before target mutation")+ self._request_async_interrupt()+ with self._continue_state:+ stopped = self._continue_state.wait_for(+ lambda: not self._continue_active,+ timeout=self._mutation_stop_timeout,+ )+ if not stopped:+ raise RuntimeError(+ f"Timed out waiting for debuggee to stop before {operation}. "+ "Send a pause request and retry after the stopped event."+ )++ def _request_async_interrupt(self):+ session = self._ensure_session()+ interrupt = getattr(session, "interrupt_async", None)+ if interrupt is not None:+ return interrupt()+ return session.interrupt()+def _emit_execution_event(self, default_reason: str | None = None):info = self._ensure_session().process_info()state = info.get("state")@@ -471,6 +550,9 @@ class LLDBDebugAdapter:reason = "entry" if default_reason == "entry" else (stop.get("reason") or default_reason or "pause")if reason in {"signal", "crashed"}:reason = "exception"+ if self._pause_requested:+ self._pause_requested = False+ reason = "pause"body = {"reason": reason,"threadId": info.get("selected_thread_id"),@@ -482,8 +564,38 @@ class LLDBDebugAdapter:if stop.get("description"):body["description"] = stop["description"]body["text"] = stop["description"]+ if self._should_auto_continue_internal_stop(body):+ self._send_event(+ "output",+ {+ "category": "console",+ "output": f"auto-continued internal breakpoint: {self._summarize_stop(body)}\n",+ },+ )+ self._send_continued_event(info.get("selected_thread_id"))+ self._start_continue_thread(+ name="cli-anything-lldb-dap-auto-continue",+ default_reason=default_reason or "breakpoint",+ )+ returnself._send_event("stopped", body)+ def _should_auto_continue_internal_stop(self, body: dict[str, Any]) -> bool:+ if not self._auto_continue_internal_breakpoints:+ return False+ if body.get("reason") == "pause":+ return False+ text = str(body.get("description") or body.get("text") or "")+ if "jit-debug-register" in text or "__jit_debug_register_code" in text:+ return True+ if "Exception 0x80000003" in text and "ntdll.dll`DbgBreakPoint" in text:+ return True+ return False++ def _summarize_stop(self, body: dict[str, Any]) -> str:+ text = str(body.get("description") or body.get("text") or body.get("reason") or "unknown")+ return text.splitlines()[0] if text else "unknown"+def _send_continued_event(self, thread_id: int | None = None):body: dict[str, Any] = {"allThreadsContinued": True}if thread_id is not None:@@ -616,24 +728,26 @@ class LLDBDebugAdapter:success: bool = True,message: str | None = None,):- payload: dict[str, Any] = {- "seq": self._next_seq(),- "type": "response",- "request_seq": request_seq,- "success": success,- "command": command,- }- if body is not None:- payload["body"] = body- if message:- payload["message"] = message- self._write(payload)+ with self._protocol_lock:+ payload: dict[str, Any] = {+ "seq": self._next_seq(),+ "type": "response",+ "request_seq": request_seq,+ "success": success,+ "command": command,+ }+ if body is not None:+ payload["body"] = body+ if message:+ payload["message"] = message+ self._write(payload)def _send_event(self, event: str, body: dict[str, Any] | None = None):- payload: dict[str, Any] = {"seq": self._next_seq(), "type": "event", "event": event}- if body is not None:- payload["body"] = body- self._write(payload)+ with self._protocol_lock:+ payload: dict[str, Any] = {"seq": self._next_seq(), "type": "event", "event": event}+ if body is not None:+ payload["body"] = body+ self._write(payload)def _next_seq(self) -> int:seq = self._seqdiff --git a/lldb/agent-harness/cli_anything/lldb/skills/SKILL.md b/lldb/agent-harness/cli_anything/lldb/skills/SKILL.mdindex c1902c6c3..65e80a565 100644--- a/lldb/agent-harness/cli_anything/lldb/skills/SKILL.md+++ b/lldb/agent-harness/cli_anything/lldb/skills/SKILL.md@@ -73,6 +73,19 @@ DAP variables can expose child references for structs/classes/arrays. Use`setVariable` only while stopped; LLDB may reject writes to optimized-out orread-only values.+For long-running GUI debuggees, DAP `continue` is non-blocking from the client's+point of view: the adapter sends the response and `continued` event first, then+waits for LLDB on a background thread. DAP `pause` uses LLDB async interrupt.+If an agent needs to change breakpoints while the debuggee is running, the+adapter interrupts first and waits for a stopped state before mutating LLDB+breakpoints; if the target does not stop in time, retry after an explicit+`pause`/`stopped` cycle.++For GUI apps that stop on debugger-internal startup or shader-JIT breakpoints,+`launch` and `attach` accept the non-standard boolean argument+`autoContinueInternalBreakpoints`. Enable it only when those internal stops are+noise for the task; the adapter emits an `output` event before auto-continuing.+## Command Groups### target@@ -133,6 +146,8 @@ cli-anything-lldb --json core load --path /path/to/core- Use REPL when a human-like interactive shell is more convenient, not because persistence requires it.- Unresolved CLI breakpoints fail by default; pass `--allow-pending` only when a future module/symbol load is expected.- DAP unresolved breakpoints use protocol semantics: `verified: false` until resolved.+- DAP `continue` is non-blocking for long-running GUI processes, and DAP `pause` uses async interrupt.+- DAP breakpoint changes during an active continue first interrupt and wait for a stopped state before mutating LLDB.- `memory find` uses a chunked scan capped at 1 MiB per call.- Call `target create` before process or core commands.- Expect structured errors: `{"error": "...", "type": "..."}`diff --git a/lldb/agent-harness/cli_anything/lldb/tests/TEST.md b/lldb/agent-harness/cli_anything/lldb/tests/TEST.mdindex cec211ec5..e2ec7c697 100644--- a/lldb/agent-harness/cli_anything/lldb/tests/TEST.md+++ b/lldb/agent-harness/cli_anything/lldb/tests/TEST.md@@ -42,7 +42,10 @@- Validate frame/variable references are cleared on resume- Validate EOF cleanup destroys the LLDB session- Validate running-state execution events emit `continued`, not a false `stopped`-- Validate DAP `pause` calls the interrupt path and emits a pause stop event+- Validate DAP `pause` calls the async interrupt path and emits a pause stop event+- Validate DAP breakpoint mutation during an active continue requests async interrupt and waits for stopped state+- Validate DAP breakpoint mutation reports a clear timeout when the target does not stop+- Validate DAP auto-continues known internal JIT/startup breakpoint stops when explicitly enabled- Validate DAP transcript response/event ordering for initialize, launch, breakpoint setup, and configuration completion- Validate DAP `modules` and `exceptionInfo` response shapes- Validate DAP `readMemory` base64 encoding and expandable variable references@@ -157,9 +160,9 @@ python -m pytest cli_anything/lldb/tests -q### Result summary-- `test_core.py`: 40 passed+- `test_core.py`: 44 passed- `test_full_e2e.py`: 7 passed, 2 warnings from LLDB SWIG bindings-- combined default run: 47 passed, 2 warnings from LLDB SWIG bindings+- combined default run: 51 passed, 2 warnings from LLDB SWIG bindings- skip situation: 0 skipped in the current local run; older runs could skip the optional core-load negative-path scenario when `LLDB_TEST_CORE` was unset, but the fixture now creates a local placeholder core path for that negative-path test### Notes@@ -179,3 +182,4 @@ python -m pytest cli_anything/lldb/tests -q- Added a real DAP source-line breakpoint E2E scenario- Added DAP `loadedSources` and `readMemory` coverage while keeping the harness at version 1.0.0- Added DAP variable child expansion, `setVariable`, `modules`, `exceptionInfo`, and transcript ordering coverage while keeping the harness at version 1.0.0+- Added non-blocking DAP continue, async pause, guarded running-state breakpoint mutation, and internal breakpoint auto-continue coveragediff --git a/lldb/agent-harness/cli_anything/lldb/tests/test_core.py b/lldb/agent-harness/cli_anything/lldb/tests/test_core.pyindex 2bd7d6e92..01558952f 100644--- a/lldb/agent-harness/cli_anything/lldb/tests/test_core.py+++ b/lldb/agent-harness/cli_anything/lldb/tests/test_core.py@@ -12,6 +12,7 @@ import ioimport subprocessimport sysimport stat+import threadingfrom pathlib import Pathfrom unittest.mock import MagicMock, patch@@ -199,7 +200,96 @@ class TestDAPProtocol:assert response["success"] is Trueassert event["event"] == "stopped"assert event["body"]["reason"] == "pause"- fake_session.interrupt.assert_called_once()+ fake_session.interrupt_async.assert_called_once()++ def test_set_breakpoints_interrupts_active_continue_before_mutation(self):+ from cli_anything.lldb.dap import LLDBDebugAdapter++ fake_session = MagicMock()+ fake_session.breakpoint_set.return_value = {+ "id": 7,+ "resolved": True,+ "locations": 1,+ "location_details": [{"file": "C:/tmp/main.c", "line": 12}],+ }+ adapter = LLDBDebugAdapter(session_factory=lambda: fake_session)+ adapter._ensure_session()+ adapter._mutation_stop_timeout = 1.0+ with adapter._continue_state:+ adapter._continue_active = True++ release = threading.Timer(0.01, adapter._mark_continue_inactive)+ release.start()+ try:+ body, post_send = adapter._handle_setBreakpoints(+ {+ "source": {"path": "C:/tmp/main.c"},+ "breakpoints": [{"line": 12}],+ }+ )+ finally:+ release.join()++ assert post_send is None+ assert body["breakpoints"][0]["verified"] is True+ fake_session.interrupt_async.assert_called_once()+ fake_session.breakpoint_set.assert_called_once()++ def test_set_breakpoints_reports_timeout_if_running_target_will_not_stop(self):+ from cli_anything.lldb.dap import LLDBDebugAdapter++ fake_session = MagicMock()+ adapter = LLDBDebugAdapter(session_factory=lambda: fake_session)+ adapter._ensure_session()+ adapter._mutation_stop_timeout = 0.01+ with adapter._continue_state:+ adapter._continue_active = True++ try:+ with pytest.raises(RuntimeError, match="Timed out waiting for debuggee to stop"):+ adapter._handle_setBreakpoints(+ {+ "source": {"path": "C:/tmp/main.c"},+ "breakpoints": [{"line": 12}],+ }+ )+ finally:+ adapter._mark_continue_inactive()++ fake_session.interrupt_async.assert_called_once()+ fake_session.breakpoint_set.assert_not_called()++ def test_auto_continue_internal_breakpoint_emits_output_and_resumes(self):+ from cli_anything.lldb.dap import LLDBDebugAdapter, read_message++ fake_session = MagicMock()+ fake_session.process_info.return_value = {+ "state": "stopped",+ "selected_thread_id": 99,+ "stop": {+ "reason": "breakpoint",+ "description": "frame #0: nvgpucomp64.dll`__jit_debug_register_code",+ "hit_breakpoint_ids": [],+ },+ "exit_status": 0,+ }+ out = io.BytesIO()+ adapter = LLDBDebugAdapter(session_factory=lambda: fake_session)+ adapter._out = out+ adapter._auto_continue_internal_breakpoints = True+ adapter._start_continue_thread = MagicMock()++ adapter._emit_execution_event(default_reason="breakpoint")+ out.seek(0)+ output_event = read_message(out)+ continued_event = read_message(out)+ stopped_event = read_message(out)++ assert output_event["event"] == "output"+ assert "auto-continued internal breakpoint" in output_event["body"]["output"]+ assert continued_event["event"] == "continued"+ assert stopped_event is None+ adapter._start_continue_thread.assert_called_once()def test_stack_trace_reports_total_frames(self):from cli_anything.lldb.dap import LLDBDebugAdapter, read_message@@ -573,6 +663,20 @@ class TestSessionLifecycle:process.Stop.assert_called_once()assert payload["pid"] == 123+ def test_interrupt_async_requests_async_interrupt(self):+ from cli_anything.lldb.core.session import LLDBSession++ session = self._make_session()+ process = MagicMock()+ process.IsValid.return_value = True+ process.SendAsyncInterrupt.return_value = MagicMock(Success=lambda: True)+ session.process = process++ payload = LLDBSession.interrupt_async(session)++ process.SendAsyncInterrupt.assert_called_once()+ assert payload == {"status": "interrupt_requested"}+def test_session_status_reports_target_and_process(self):from cli_anything.lldb.core.session import LLDBSessiondiff --git a/lldb/agent-harness/cli_anything/lldb/utils/session_server.py b/lldb/agent-harness/cli_anything/lldb/utils/session_server.pyindex 3745a0ed8..6233e6f85 100644--- a/lldb/agent-harness/cli_anything/lldb/utils/session_server.py+++ b/lldb/agent-harness/cli_anything/lldb/utils/session_server.py@@ -38,6 +38,7 @@ _ALLOWED_SESSION_METHODS = {"step_out","continue_exec","interrupt",+ "interrupt_async","backtrace","locals","local_values",diff --git a/skills/cli-anything-lldb/SKILL.md b/skills/cli-anything-lldb/SKILL.mdindex e0604688d..8c6dc32cb 100644--- a/skills/cli-anything-lldb/SKILL.md+++ b/skills/cli-anything-lldb/SKILL.md@@ -73,6 +73,19 @@ DAP variables can expose child references for structs/classes/arrays. Use`setVariable` only while stopped; LLDB may reject writes to optimized-out orread-only values.+For long-running GUI debuggees, DAP `continue` is non-blocking from the client's+point of view: the adapter sends the response and `continued` event first, then+waits for LLDB on a background thread. DAP `pause` uses LLDB async interrupt.+If an agent needs to change breakpoints while the debuggee is running, the+adapter interrupts first and waits for a stopped state before mutating LLDB+breakpoints; if the target does not stop in time, retry after an explicit+`pause`/`stopped` cycle.++For GUI apps that stop on debugger-internal startup or shader-JIT breakpoints,+`launch` and `attach` accept the non-standard boolean argument+`autoContinueInternalBreakpoints`. Enable it only when those internal stops are+noise for the task; the adapter emits an `output` event before auto-continuing.+## Command Groups### target@@ -133,6 +146,8 @@ cli-anything-lldb --json core load --path /path/to/core- Use REPL when a human-like interactive shell is more convenient, not because persistence requires it.- Unresolved CLI breakpoints fail by default; pass `--allow-pending` only when a future module/symbol load is expected.- DAP unresolved breakpoints use protocol semantics: `verified: false` until resolved.+- DAP `continue` is non-blocking for long-running GUI processes, and DAP `pause` uses async interrupt.+- DAP breakpoint changes during an active continue first interrupt and wait for a stopped state before mutating LLDB.- `memory find` uses a chunked scan capped at 1 MiB per call.- Call `target create` before process or core commands.- Expect structured errors: `{"error": "...", "type": "..."}`