use crate::{
APP_NAME, PROJECT_SCOPE_NAME,
core::{
self, auth,
changelog::VERSION,
compaction,
crash_log::CrashRecord,
login_registry,
provider::{AgentMessage, ModelConfig},
session_manager::Session,
settings_manager::agent_dir,
},
error::Result,
utils::{
time::{now_iso, now_ms},
zip::{ZipEntry, write_zip},
},
};
use regex::Regex;
use serde_json::{Map, Value, json};
use std::{path::Path, sync::OnceLock};
use url::Url;
pub const BUG_REPORT_CUSTOM_ENTRY_TYPE: &str = concat!(env!("CARGO_PKG_NAME"), ".bug-report");
pub const BUG_REPORT_SCHEMA_VERSION: u32 = 1;
pub const REDACTED: &str = "<redacted>";
pub const BUG_SUMMARY_SYSTEM_PROMPT: &str = "You are helping a user file a bug report about prux, the coding agent they are talking to. You will be shown the conversation transcript. Write a report for the prux developers describing what the user was doing and what went wrong.
Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the report.";
pub const BUG_SUMMARY_INSTRUCTIONS: &str = "Write the bug report in Markdown with these sections:
## What the user was doing
One short paragraph.
## What went wrong
Concrete description of the failure: wrong output, errors, hangs, tool failures, unexpected behavior. Quote error messages and tool output verbatim where they exist.
## Steps to reproduce
Numbered list, as specific as the transcript allows.
## Relevant details
Tool calls involved, files touched, model behavior, anything else that helps a developer reproduce or locate the problem.
Do not include file contents, secrets, or credentials from the transcript; refer to files by path only. Keep the report factual and concise.";
fn sensitive_key_re() -> &'static Regex {
static RE: OnceLock<Regex> = OnceLock::new();
RE.get_or_init(|| {
Regex::new(r"(?i)(?:^|[-_])(api[-_]?key|secret|token|password|passwd|credential|authorization|cookie)(?:$|[-_])")
.expect("valid sensitive key regex")
})
}
pub fn is_sensitive_key(key: &str) -> bool {
let camel_split = Regex::new(r"([a-z0-9])([A-Z])")
.map(|re| re.replace_all(key, "${1}_${2}").to_string())
.unwrap_or_else(|_| key.to_string());
for candidate in [key, camel_split.as_str()] {
let padded = format!("_{}_", candidate.trim_matches(['_', '-']).to_lowercase());
if sensitive_key_re().is_match(&padded) {
return true;
}
}
false
}
pub fn redact_url(value: &str) -> String {
let Ok(mut url) = Url::parse(value) else {
return value.to_string();
};
let mut changed = false;
if !url.username().is_empty() || url.password().is_some() {
let _ = url.set_username("");
let _ = url.set_password(None);
changed = true;
}
let sensitive: Vec<String> = url
.query_pairs()
.filter(|(k, _)| is_sensitive_key(k))
.map(|(k, _)| k.to_string())
.collect();
if !sensitive.is_empty() {
let pairs: Vec<(String, String)> = url
.query_pairs()
.map(|(k, v)| {
if sensitive.iter().any(|s| *s == k) {
(k.to_string(), REDACTED.to_string())
} else {
(k.to_string(), v.to_string())
}
})
.collect();
url.query_pairs_mut().clear().extend_pairs(pairs);
changed = true;
}
if changed {
url.to_string()
} else {
value.to_string()
}
}
pub fn redact_json_value(value: &Value) -> Value {
match value {
Value::Object(map) => Value::Object(
map.iter()
.map(|(k, v)| {
if is_sensitive_key(k) {
(k.clone(), Value::String(REDACTED.to_string()))
} else {
(k.clone(), redact_json_value(v))
}
})
.collect::<Map<String, Value>>(),
),
Value::Array(items) => Value::Array(items.iter().map(redact_json_value).collect()),
Value::String(s) => Value::String(redact_url(s)),
other => other.clone(),
}
}
pub fn collect_environment() -> Value {
let env = |name: &str| std::env::var(name).ok().filter(|v| !v.is_empty());
let mut prux_vars: Vec<String> = std::env::vars_os()
.filter_map(|(k, _)| k.to_string_lossy().to_string().into())
.filter(|k| k.starts_with("PRUX_"))
.collect();
prux_vars.sort();
json!({
"app": APP_NAME,
"version": VERSION,
"runtime": "rust",
"platform": std::env::consts::OS,
"arch": std::env::consts::ARCH,
"shell": env("SHELL").map(|s| {
s.rsplit(['/', '\\']).next().unwrap_or(&s).to_string()
}),
"terminal": {
"term": env("TERM"),
"program": env("TERM_PROGRAM"),
"programVersion": env("TERM_PROGRAM_VERSION"),
"colorterm": env("COLORTERM"),
"tmux": env("TMUX").is_some(),
"ssh": env("SSH_CONNECTION").is_some() || env("SSH_CLIENT").is_some() || env("SSH_TTY").is_some(),
"ci": env("CI").is_some(),
},
"pruxEnvironmentVariables": prux_vars,
})
}
fn describe_model(model: &ModelConfig) -> Value {
json!({
"provider": model.provider,
"id": model.model_id,
"api": model.api,
"baseUrl": redact_url(&model.base_url),
"reasoning": model.reasoning,
"input": model.input,
"contextWindow": model.context_window,
"maxTokens": model.max_tokens,
"samplingParams": model.sampling_params.as_ref().map(redact_json_value),
"providerRouting": model.provider_routing.as_ref().map(redact_json_value),
"thinkingLevelMap": model.thinking_level_map,
"allowedFallbackModels": model
.allowed_fallback_models
.iter()
.map(|f| json!({ "provider": f.provider, "model": f.model }))
.collect::<Vec<Value>>(),
})
}
fn describe_provider(provider: &str) -> Value {
let info = login_registry::LOGIN_PROVIDERS
.iter()
.find(|p| p.id == provider);
let mut auth_types: Vec<&str> = Vec::new();
if info.is_some_and(|p| p.supports_api_key) {
auth_types.push("api_key");
}
if info.is_some_and(|p| p.is_subscription) {
auth_types.push("oauth");
}
json!({
"id": provider,
"name": info.map(|p| p.name),
"baseUrl": info.map(|p| redact_url(p.base_url)),
"authTypes": auth_types,
"configured": auth::resolve_api_key(provider, None).is_some(),
"usingOAuth": auth::read_oauth_credential(provider).is_some(),
})
}
fn describe_extensions() -> Value {
Value::Array(
core::extensions::panel_entries()
.into_iter()
.map(|(name, enabled, modes)| {
json!({
"name": name,
"enabled": enabled,
"modes": modes.iter().map(|m| m.as_str()).collect::<Vec<_>>(),
})
})
.collect(),
)
}
fn redacted_settings_file(path: &Path) -> Value {
let Ok(text) = std::fs::read_to_string(path) else {
return Value::Null;
};
match serde_json::from_str::<Value>(&text) {
Ok(mut v) => {
if let Some(obj) = v.as_object_mut() {
obj.remove("deviceId");
}
redact_json_value(&v)
}
Err(_) => Value::String("<unparseable>".to_string()),
}
}
pub struct BugReportContext<'a> {
pub hint: Option<String>,
pub session_id: String,
pub cwd: String,
pub session_file: Option<String>,
pub include_session: bool,
pub include_summary: bool,
pub message_count: usize,
pub model: &'a ModelConfig,
pub thinking_level: Option<String>,
}
pub fn collect_metadata(ctx: &BugReportContext<'_>) -> Value {
let hint = ctx
.hint
.as_deref()
.map(|h| h.trim())
.filter(|h| !h.is_empty())
.map(|h| h.to_string());
let mut session = json!({
"id": ctx.session_id,
"included": ctx.include_session,
"summaryIncluded": ctx.include_summary,
"messageCount": ctx.message_count,
"file": ctx.session_file.as_deref().map(redact_url),
});
if ctx.include_session
&& let Some(obj) = session.as_object_mut()
{
obj.insert("cwd".to_string(), json!(ctx.cwd));
}
json!({
"schemaVersion": BUG_REPORT_SCHEMA_VERSION,
"id": new_report_id(),
"createdAt": now_iso(),
"hint": hint,
"environment": collect_environment(),
"session": session,
"model": describe_model(ctx.model),
"provider": describe_provider(&ctx.model.provider),
"thinkingLevel": ctx.thinking_level,
"extensions": describe_extensions(),
"settings": {
"global": redacted_settings_file(&agent_dir().join("settings.json")),
"project": redacted_settings_file(&Path::new(&ctx.cwd).join(PROJECT_SCOPE_NAME).join("settings.json")),
},
})
}
pub fn collect_diagnostics(session: Option<&Session>, crashes: &[CrashRecord]) -> Value {
let session_id = session
.map(|s| s.session_id.clone())
.unwrap_or_else(|| "<none>".to_string());
let entries: Vec<Value> = session.map(|s| s.get_entries()).unwrap_or_default();
let mut assistant: Vec<Value> = Vec::new();
let mut assistant_message_count = 0usize;
for entry in &entries {
if entry.get("type").and_then(|v| v.as_str()) != Some("message") {
continue;
}
let msg = entry.get("message").cloned().unwrap_or(Value::Null);
if msg.get("role").and_then(|v| v.as_str()) != Some("assistant") {
continue;
}
assistant_message_count += 1;
let diagnostics = msg
.get("diagnostics")
.cloned()
.filter(|v| !v.is_null())
.unwrap_or(Value::Null);
let stop_reason = msg.get("stopReason").and_then(|v| v.as_str());
let error_message = msg.get("errorMessage").and_then(|v| v.as_str());
let interesting = !diagnostics.is_null()
|| matches!(stop_reason, Some("error") | Some("aborted"))
|| error_message.is_some_and(|m| !m.is_empty());
if !interesting {
continue;
}
let mut item = json!({
"entryId": entry.get("id"),
"timestamp": entry.get("timestamp"),
"provider": msg.get("provider"),
"model": msg.get("model"),
"api": msg.get("api"),
"stopReason": stop_reason,
"diagnostics": diagnostics,
});
if let Some(obj) = item.as_object_mut() {
if let Some(raw) = msg.get("rawStopReason")
&& !raw.is_null()
{
obj.insert("rawStopReason".to_string(), raw.clone());
}
if let Some(em) = error_message {
obj.insert("errorMessage".to_string(), json!(em));
}
}
assistant.push(item);
}
json!({
"schemaVersion": BUG_REPORT_SCHEMA_VERSION,
"sessionId": session_id,
"entryCount": entries.len(),
"assistantMessageCount": assistant_message_count,
"assistant": assistant,
"crashes": crashes
.iter()
.map(|c| {
let mut v = serde_json::to_value(c).unwrap_or(Value::Null);
if let Some(obj) = v.as_object_mut() {
obj.remove("notified"); }
v
})
.collect::<Vec<_>>(),
})
}
pub fn serialize_session_branch(session: &Session) -> String {
session.serialize_branch_jsonl()
}
pub fn build_summary_request(
messages: &[AgentMessage],
hint: Option<&str>,
model: &ModelConfig,
) -> (String, String, Option<u32>) {
let context_window = if model.context_window > 0 {
model.context_window
} else {
128_000
};
let budget = (context_window as f64 * 0.6).floor() as u32;
let selected = select_recent_messages(messages, budget);
let conversation = compaction::serialize_conversation(&selected);
let mut parts: Vec<String> = Vec::new();
if selected.len() < messages.len() {
parts.push(format!(
"Note: only the last {} of {} messages are shown.",
selected.len(),
messages.len()
));
}
parts.push(format!("<conversation>\n{conversation}\n</conversation>"));
if let Some(hint) = hint.map(|h| h.trim()).filter(|h| !h.is_empty()) {
parts.push(format!("<user-report>\n{hint}\n</user-report>"));
}
parts.push(BUG_SUMMARY_INSTRUCTIONS.to_string());
let max_tokens = Some(model.max_tokens.unwrap_or(u32::MAX).min(4096));
(
BUG_SUMMARY_SYSTEM_PROMPT.to_string(),
parts.join("\n\n"),
max_tokens,
)
}
fn select_recent_messages(messages: &[AgentMessage], budget: u32) -> Vec<AgentMessage> {
let mut selected: Vec<AgentMessage> = Vec::new();
let mut tokens = 0u32;
for message in messages.iter().rev() {
let next = compaction::estimate_tokens(message);
if !selected.is_empty() && tokens.saturating_add(next) > budget {
break;
}
selected.push(message.clone());
tokens = tokens.saturating_add(next);
}
selected.reverse();
selected
}
pub struct BugReportBundle {
pub metadata: Value,
pub diagnostics: Value,
pub session_jsonl: Option<String>,
pub summary: Option<String>,
}
pub struct BundleInput<'a> {
pub ctx: BugReportContext<'a>,
pub session: Option<&'a Session>,
pub crashes: &'a [CrashRecord],
pub summary: Option<String>,
}
pub fn build_bundle(input: BundleInput<'_>) -> BugReportBundle {
let BundleInput {
ctx,
session,
crashes,
summary,
} = input;
BugReportBundle {
metadata: collect_metadata(&ctx),
diagnostics: collect_diagnostics(session, crashes),
session_jsonl: if ctx.include_session {
session.map(serialize_session_branch)
} else {
None
},
summary,
}
}
pub fn archive_file_name(id: &str) -> String {
format!("{APP_NAME}-bug-report-{id}.zip")
}
pub fn bundle_entries(bundle: &BugReportBundle) -> Vec<ZipEntry> {
let pretty = |v: &Value| format!("{}\n", serde_json::to_string_pretty(v).unwrap_or_default());
let mut entries = vec![
ZipEntry::text("report.json", pretty(&bundle.metadata)),
ZipEntry::text("diagnostics.json", pretty(&bundle.diagnostics)),
];
if let Some(jsonl) = &bundle.session_jsonl {
entries.push(ZipEntry::text("session.jsonl", jsonl.clone()));
}
if let Some(summary) = &bundle.summary {
let text = if summary.ends_with('\n') {
summary.clone()
} else {
format!("{summary}\n")
};
entries.push(ZipEntry::text("summary.md", text));
}
entries
}
pub fn write_bug_report_archive(bundle: &BugReportBundle, path: &Path) -> Result<()> {
write_zip(path, &bundle_entries(bundle))
}
pub fn new_report_id() -> String {
let mut b = [0u8; 4];
if getrandom::fill(&mut b).is_err() {
b.copy_from_slice(&(now_ms() as u32).to_be_bytes());
}
let hex: String = b.iter().map(|x| format!("{x:02x}")).collect();
format!("bug-{}-{}", now_ms(), hex)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::core::provider::ContentBlock;
#[test]
fn sensitive_keys_match_camel_and_snake_forms() {
for key in [
"apiKey",
"api_key",
"API-KEY",
"apikey",
"sessionToken",
"access-token",
"password",
"passwd",
"credential",
"Authorization",
"cookie",
"mySecret",
] {
assert!(is_sensitive_key(key), "{key} 应判为敏感");
}
for key in [
"key",
"theme",
"model",
"tokens",
"inputTokens",
"cursor",
"keybindings",
] {
assert!(!is_sensitive_key(key), "{key} 不应判为敏感");
}
}
#[test]
fn redact_url_strips_userinfo_and_secrets() {
assert_eq!(
redact_url("https://user:pw@example.com/v1?api_key=abc&x=1"),
"https://example.com/v1?api_key=%3Credacted%3E&x=1"
);
assert_eq!(
redact_url("https://example.com/v1?x=1"),
"https://example.com/v1?x=1"
);
assert_eq!(redact_url("/tmp/some dir"), "/tmp/some dir");
}
#[test]
fn redact_json_recurses_and_keeps_structure() {
let v = json!({
"apiKey": "sk-live-123",
"nested": { "token": "t", "url": "https://x.example.com/?token=zz", "keep": 1 },
"list": [ { "cookie": "c" } ],
});
let out = redact_json_value(&v);
assert_eq!(out["apiKey"], REDACTED);
assert_eq!(out["nested"]["token"], REDACTED);
assert_eq!(
out["nested"]["url"],
"https://x.example.com/?token=%3Credacted%3E"
);
assert_eq!(out["nested"]["keep"], 1);
assert_eq!(out["list"][0]["cookie"], REDACTED);
}
#[test]
fn environment_contains_no_values() {
unsafe { std::env::set_var("PRUX_TEST_SECRET_VALUE", "hunter2") };
let env = collect_environment();
let text = env.to_string();
assert!(text.contains("PRUX_TEST_SECRET_VALUE"), "{text}");
assert!(!text.contains("hunter2"), "环境变量值不得进入报告");
assert_eq!(env["app"], APP_NAME);
assert_eq!(env["version"], VERSION);
assert!(env["pruxEnvironmentVariables"].is_array());
unsafe { std::env::remove_var("PRUX_TEST_SECRET_VALUE") };
}
#[test]
fn summary_request_selects_recent_messages_and_notes_truncation() {
let mut model = test_model();
let long = |n: u32| AgentMessage {
role: "user".into(),
thinking_level: None,
content: vec![ContentBlock::Text {
text: format!(
"{}marker{n}",
"the quick brown fox jumps over the lazy dog ".repeat(500)
),
text_signature: None,
}],
..AgentMessage::user_text("")
};
let messages = vec![long(1), long(2), AgentMessage::user_text("tail question")];
let (system, prompt, max_tokens) =
build_summary_request(&messages, Some("crash on start"), &model);
assert_eq!(system, BUG_SUMMARY_SYSTEM_PROMPT);
assert!(
prompt.contains("Note: only the last 1 of 3 messages are shown."),
"{prompt}"
);
assert!(prompt.contains("tail question"));
assert!(!prompt.contains("marker1"));
assert!(prompt.contains("<user-report>\ncrash on start\n</user-report>"));
assert!(prompt.contains("## Steps to reproduce"));
assert_eq!(max_tokens, Some(4096));
model.context_window = 10_000_000;
let (_, prompt, _) = build_summary_request(&messages, None, &model);
assert!(!prompt.contains("Note: only the last"));
assert!(!prompt.contains("<user-report>"));
assert!(prompt.contains("marker1") && prompt.contains("tail question"));
}
#[test]
fn bundle_entries_shape_and_archive() {
let metadata = json!({ "id": "bug-1-aaaa", "apiKey": "secret" });
let bundle = BugReportBundle {
metadata: redact_json_value(&metadata),
diagnostics: json!({ "entryCount": 0 }),
session_jsonl: Some("{\"type\":\"session\"}\n".to_string()),
summary: Some("no trailing newline".to_string()),
};
let entries = bundle_entries(&bundle);
let names: Vec<&str> = entries.iter().map(|e| e.name.as_str()).collect();
assert_eq!(
names,
vec![
"report.json",
"diagnostics.json",
"session.jsonl",
"summary.md"
]
);
let report = String::from_utf8(entries[0].data.clone()).unwrap();
assert!(report.contains(REDACTED));
assert!(!report.contains("secret"));
let summary = String::from_utf8(entries[3].data.clone()).unwrap();
assert!(summary.ends_with('\n'));
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join(archive_file_name("bug-1-aaaa"));
write_bug_report_archive(&bundle, &path).unwrap();
assert!(path.exists());
assert_eq!(
archive_file_name("x"),
format!("{APP_NAME}-bug-report-x.zip")
);
let bare = BugReportBundle {
metadata: json!({}),
diagnostics: json!({}),
session_jsonl: None,
summary: None,
};
assert_eq!(bundle_entries(&bare).len(), 2);
}
#[test]
fn report_id_is_unique_and_prefixed() {
let a = new_report_id();
let b = new_report_id();
assert!(a.starts_with("bug-"));
assert_ne!(a, b);
}
fn test_model() -> ModelConfig {
ModelConfig {
model_type: Default::default(),
provider: "anthropic".into(),
model_id: "claude-sonnet-4-5".into(),
base_url: "https://api.anthropic.com".into(),
api_key: String::new(),
api: "anthropic-messages".into(),
output: Vec::new(),
input: vec!["text".into()],
reasoning: false,
max_tokens: Some(64_000),
temperature: None,
context_window: 1000,
thinking_format: String::new(),
supports_reasoning_effort: false,
thinking_level_map: None,
auth_header: false,
image_resize: Default::default(),
allowed_fallback_models: Vec::new(),
supports_developer_role: false,
requires_reasoning_content_on_assistant_messages: false,
max_tokens_field: "max_tokens".into(),
cost: None,
max_retry_delay_ms: None,
thinking_budgets: None,
sampling_params: None,
sampling_params_by_thinking_level: None,
provider_routing: None,
session_id: None,
supports_usage_in_streaming: true,
supports_store: true,
supports_finish_reason: true,
requires_assistant_after_tool_result: false,
supports_strict_mode: false,
send_session_affinity_headers: None,
session_affinity_format: None,
}
}
#[test]
fn metadata_redacts_settings_and_describes_model() {
let _ad = crate::test_support::AgentDirGuard::temp();
std::fs::write(
agent_dir().join("settings.json"),
r#"{"theme":"dark","apiKey":"sk-live-1","nested":{"token":"t"},"defaultModel":"claude","deviceId":"3f2504e0-4f89-41d3-9a0c-0305e82c3301"}"#,
)
.unwrap();
let model = test_model();
let ctx = BugReportContext {
hint: Some(" boom ".to_string()),
session_id: "sess-1".to_string(),
cwd: "/tmp/proj".to_string(),
session_file: Some("/tmp/proj/s.jsonl".to_string()),
include_session: true,
include_summary: false,
message_count: 3,
model: &model,
thinking_level: Some("high".to_string()),
};
let meta = collect_metadata(&ctx);
assert!(meta["id"].as_str().unwrap().starts_with("bug-"));
assert_eq!(meta["hint"], "boom", "描述应 trim");
assert_eq!(meta["schemaVersion"], BUG_REPORT_SCHEMA_VERSION);
assert_eq!(meta["thinkingLevel"], "high");
assert_eq!(meta["session"]["cwd"], "/tmp/proj");
assert_eq!(meta["session"]["messageCount"], 3);
assert!(meta["session"]["summaryIncluded"] == false);
assert_eq!(meta["model"]["provider"], "anthropic");
assert_eq!(meta["model"]["id"], "claude-sonnet-4-5");
assert_eq!(meta["provider"]["id"], "anthropic");
assert_eq!(meta["provider"]["authTypes"][1], "oauth");
assert_eq!(meta["settings"]["global"]["apiKey"], REDACTED);
assert_eq!(meta["settings"]["global"]["nested"]["token"], REDACTED);
assert_eq!(meta["settings"]["global"]["theme"], "dark");
assert!(meta["settings"]["global"].get("deviceId").is_none());
assert_eq!(meta["settings"]["project"], Value::Null);
assert!(!meta.to_string().contains("sk-live-1"));
let ctx2 = BugReportContext {
include_session: false,
..ctx
};
let meta2 = collect_metadata(&ctx2);
assert!(meta2["session"].get("cwd").is_none());
assert_eq!(meta2["session"]["included"], false);
}
#[test]
fn branch_jsonl_roundtrips_and_diagnostics_only_lists_failures() {
let _ad = crate::test_support::AgentDirGuard::temp();
let dir = tempfile::tempdir().unwrap();
let mut session = crate::core::session_manager::Session::create(
"/tmp/proj",
Some(dir.path().into()),
true,
)
.unwrap();
session.append_message(&AgentMessage::user_text("hello"));
let ok = {
let mut m = AgentMessage::user_text("");
m.role = "assistant".into();
m.content = vec![ContentBlock::Text {
text: "fine".into(),
text_signature: None,
}];
m.provider = Some("anthropic".into());
m.model = Some("claude-sonnet-4-5".into());
m.api = Some("anthropic-messages".into());
m.stop_reason = Some("endTurn".into());
m
};
session.append_message(&ok);
let failed = {
let mut m = AgentMessage::user_text("");
m.role = "assistant".into();
m.content = vec![ContentBlock::Text {
text: "".into(),
text_signature: None,
}];
m.provider = Some("anthropic".into());
m.model = Some("claude-sonnet-4-5".into());
m.stop_reason = Some("error".into());
m.error_message = Some("provider exploded".into());
m
};
session.append_message(&failed);
let jsonl = serialize_session_branch(&session);
let lines: Vec<&str> = jsonl.lines().collect();
assert_eq!(lines.len(), 5, "{jsonl}");
assert!(lines[0].contains("\"kind\":\"header\""), "{}", lines[0]);
assert!(lines[4].contains("\"kind\":\"lane\""), "{}", lines[4]);
for line in &lines {
serde_json::from_str::<Value>(line).expect("每行都是合法 JSON");
}
let path = dir.path().join("branch.jsonl");
std::fs::write(&path, &jsonl).unwrap();
let reopened = crate::core::session_manager::Session::open(path.to_str().unwrap()).unwrap();
assert_eq!(reopened.get_entries().len(), 3, "还原后 entry 数一致");
let diag = collect_diagnostics(Some(&session), &[]);
assert_eq!(diag["sessionId"], session.session_id);
assert_eq!(diag["entryCount"], 3);
assert_eq!(diag["assistantMessageCount"], 2);
let assistant = diag["assistant"].as_array().unwrap();
assert_eq!(assistant.len(), 1, "{diag}");
assert_eq!(assistant[0]["stopReason"], "error");
assert_eq!(assistant[0]["errorMessage"], "provider exploded");
assert_eq!(assistant[0]["provider"], "anthropic");
assert!(assistant[0]["entryId"].is_string());
let empty = collect_diagnostics(None, &[]);
assert_eq!(empty["sessionId"], "<none>");
assert_eq!(empty["entryCount"], 0);
}
#[test]
fn build_bundle_assembles_all_parts_and_writes_archive() {
let _ad = crate::test_support::AgentDirGuard::temp();
let dir = tempfile::tempdir().unwrap();
let mut session = crate::core::session_manager::Session::create(
"/tmp/proj",
Some(dir.path().into()),
true,
)
.unwrap();
session.append_message(&AgentMessage::user_text("hello"));
let crash = CrashRecord {
timestamp: crate::utils::time::now_iso(),
version: VERSION.to_string(),
kind: "uncaught_exception".to_string(),
message: "panic!".to_string(),
stack: Some("src/main.rs:1:1".to_string()),
session_file: None,
cwd: "/tmp/proj".to_string(),
notified: true,
};
let model = test_model();
let ctx = BugReportContext {
hint: Some("crash".to_string()),
session_id: session.session_id.clone(),
cwd: "/tmp/proj".to_string(),
session_file: None,
include_session: true,
include_summary: true,
message_count: 1,
model: &model,
thinking_level: None,
};
let bundle = build_bundle(BundleInput {
ctx,
session: Some(&session),
crashes: std::slice::from_ref(&crash),
summary: Some("# summary".to_string()),
});
let names: Vec<String> = bundle_entries(&bundle)
.iter()
.map(|e| e.name.clone())
.collect();
assert_eq!(
names,
vec![
"report.json".to_string(),
"diagnostics.json".to_string(),
"session.jsonl".to_string(),
"summary.md".to_string()
]
);
assert!(
bundle
.session_jsonl
.as_deref()
.unwrap()
.contains("\"kind\":\"header\"")
);
assert_eq!(bundle.diagnostics["crashes"][0]["message"], "panic!");
assert!(bundle.diagnostics["crashes"][0].get("notified").is_none());
assert_eq!(bundle.metadata["session"]["summaryIncluded"], true);
let path = dir
.path()
.join(archive_file_name(bundle.metadata["id"].as_str().unwrap()));
write_bug_report_archive(&bundle, &path).unwrap();
assert!(path.exists());
if std::process::Command::new("unzip")
.arg("-v")
.output()
.is_ok()
{
let out = std::process::Command::new("unzip")
.arg("-l")
.arg(&path)
.output()
.unwrap();
let listing = String::from_utf8_lossy(&out.stdout);
for name in [
"report.json",
"diagnostics.json",
"session.jsonl",
"summary.md",
] {
assert!(listing.contains(name), "{listing}");
}
}
}
}