Files
marqdo/src/view/debug_api.rs
T
cflmyandCursor 88dc6d5a54 feat(core): Artifact Metadata Binding (${env|arg|sys|secret})
Load-time resolve of frontmatter bindings into Module.metadata; Secret
masking; sys.meta / --bind; llm ctor prefers meta over env_get.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-24 19:51:24 +08:00

205 lines
7.0 KiB
Rust

//! Live-view debug session APIs (tree-walk only).
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, OnceLock};
use std::thread;
use std::time::Duration;
use crate::debug::{snapshot_json, DebugAction, DebugController, DebugSnapshot};
use crate::host::HostContext;
use crate::input_feed::{effective_stdin, split_stdin_text};
use crate::interp::Interpreter;
use crate::load::load_module;
use crate::RunOptions;
struct Session {
ctrl: Arc<DebugController>,
#[allow(dead_code)]
path: PathBuf,
}
fn sessions() -> &'static Mutex<HashMap<String, Arc<Session>>> {
static S: OnceLock<Mutex<HashMap<String, Arc<Session>>>> = OnceLock::new();
S.get_or_init(|| Mutex::new(HashMap::new()))
}
fn new_id() -> String {
use std::time::{SystemTime, UNIX_EPOCH};
let t = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
format!("dbg-{t}")
}
fn parse_breakpoints(v: &serde_json::Value) -> HashSet<u32> {
v.get("breakpoints")
.and_then(|b| b.as_array())
.map(|arr| {
arr.iter()
.filter_map(|x| x.as_u64().map(|n| n as u32))
.collect()
})
.unwrap_or_default()
}
pub fn api_debug_start(root: &Path, body: &str) -> serde_json::Value {
let v: serde_json::Value = serde_json::from_str(body).unwrap_or(serde_json::Value::Null);
let rel = v.get("path").and_then(|p| p.as_str()).unwrap_or("");
if rel.is_empty() {
return serde_json::json!({ "ok": false, "error": "missing path" });
}
let abs = root.join(rel.replace('/', std::path::MAIN_SEPARATOR_STR));
if !abs.is_file() {
return serde_json::json!({ "ok": false, "error": format!("file not found: {rel}") });
}
let bps = parse_breakpoints(&v);
let stdin_raw = v.get("stdin").and_then(|s| s.as_str()).unwrap_or("");
let stdin_lines = split_stdin_text(stdin_raw);
let ctrl = DebugController::new(bps.clone());
if bps.is_empty() {
// No breakpoints: pause on the first statement so Debug is always useful.
ctrl.request_step();
}
ctrl.set_running();
let id = new_id();
let session = Arc::new(Session {
ctrl: ctrl.clone(),
path: abs.clone(),
});
sessions().lock().unwrap().insert(id.clone(), session);
let opts = RunOptions {
sleep_limit_ms: Some(0),
fs_root: Some(root.to_path_buf()),
..RunOptions::default()
};
let path_for_thread = abs;
let root_for_thread = root.to_path_buf();
let ctrl_t = ctrl.clone();
thread::spawn(move || {
let source = match std::fs::read_to_string(&path_for_thread) {
Ok(s) => s,
Err(e) => {
ctrl_t.set_done(false, String::new(), format!("read: {e}"));
return;
}
};
let stdin = effective_stdin(&source, &stdin_lines);
let module = match load_module(&path_for_thread) {
Ok(m) => m,
Err(e) => {
ctrl_t.set_done(false, String::new(), e.to_string());
return;
}
};
let mut host = HostContext::for_capture(Some(&path_for_thread), opts.host_caps());
host.fs_root = Some(root_for_thread);
host.entry_metadata = module.metadata.clone();
if let Some(lim) = opts.sleep_limit_ms {
host.sleep_limit_ms = Some(lim);
}
let mut interp = Interpreter::with_capture(Some(&path_for_thread), false)
.with_stdin(stdin)
.with_host(host)
.with_debug(ctrl_t.clone());
match interp.run_module(&module) {
Ok(_) => {
ctrl_t.set_done(true, interp.captured_stdout.clone(), String::new());
}
Err(e) => {
let msg = e.to_string();
if msg.contains("debug stopped") {
ctrl_t.set_done(true, interp.captured_stdout.clone(), "stopped".into());
} else {
ctrl_t.set_done(false, interp.captured_stdout.clone(), msg);
}
}
}
});
let snap = ctrl.wait_until_paused_or_done(Duration::from_secs(30));
wrap_ok(&id, &snap)
}
pub fn api_debug_action(body: &str, action: DebugAction) -> serde_json::Value {
let v: serde_json::Value = serde_json::from_str(body).unwrap_or(serde_json::Value::Null);
let id = v.get("session").and_then(|s| s.as_str()).unwrap_or("");
let sessions = sessions().lock().unwrap();
let Some(sess) = sessions.get(id) else {
return serde_json::json!({ "ok": false, "error": "unknown session" });
};
let ctrl = sess.ctrl.clone();
drop(sessions);
if v.get("breakpoints").map(|b| b.is_array()).unwrap_or(false) {
ctrl.set_breakpoints(parse_breakpoints(&v));
}
match ctrl.snapshot() {
DebugSnapshot::Done { .. } => return wrap_ok(id, &ctrl.snapshot()),
DebugSnapshot::Paused(_) => {}
other => {
return serde_json::json!({
"ok": false,
"error": format!("session not paused (status={})", status_name(&other)),
"session": id,
});
}
}
ctrl.send_action(action);
let snap = ctrl.wait_until_paused_or_done(Duration::from_secs(30));
wrap_ok(id, &snap)
}
pub fn api_debug_stop(body: &str) -> serde_json::Value {
let v: serde_json::Value = serde_json::from_str(body).unwrap_or(serde_json::Value::Null);
let id = v.get("session").and_then(|s| s.as_str()).unwrap_or("");
let mut map = sessions().lock().unwrap();
if let Some(sess) = map.remove(id) {
sess.ctrl.send_action(DebugAction::Stop);
return serde_json::json!({ "ok": true, "status": "stopped", "session": id });
}
serde_json::json!({ "ok": false, "error": "unknown session" })
}
pub fn api_debug_set_breakpoints(body: &str) -> serde_json::Value {
let v: serde_json::Value = serde_json::from_str(body).unwrap_or(serde_json::Value::Null);
let id = v.get("session").and_then(|s| s.as_str()).unwrap_or("");
let bps = parse_breakpoints(&v);
let map = sessions().lock().unwrap();
let Some(sess) = map.get(id) else {
return serde_json::json!({ "ok": false, "error": "unknown session" });
};
sess.ctrl.set_breakpoints(bps.clone());
let mut lines: Vec<u32> = bps.into_iter().collect();
lines.sort_unstable();
serde_json::json!({
"ok": true,
"session": id,
"breakpoints": lines,
})
}
fn wrap_ok(id: &str, snap: &DebugSnapshot) -> serde_json::Value {
let mut out = snapshot_json(snap);
if let Some(obj) = out.as_object_mut() {
obj.insert("ok".into(), serde_json::Value::Bool(true));
obj.insert("session".into(), serde_json::Value::String(id.to_string()));
}
out
}
fn status_name(s: &DebugSnapshot) -> &'static str {
match s {
DebugSnapshot::Idle => "idle",
DebugSnapshot::Running => "running",
DebugSnapshot::Paused(_) => "paused",
DebugSnapshot::Done { .. } => "done",
}
}