use std::collections::BTreeMap;
use std::fs::{self, OpenOptions};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::time::{SystemTime, UNIX_EPOCH};
use rusqlite::params;
use serde_json::{json, Value};
use supercode::{
harness_support_registry, DiscoveryQuery, HarnessCatalog, HarnessHomes, HarnessId,
HarnessSessionService, Session, SessionFollower, SessionFormat,
};
const CLAUDE: &str = "claude_code_session.jsonl";
const CODEX: &str = "codex_session.jsonl";
const PI: &str = "pi_session_live_corpus.jsonl";
const OPENCODE: &str = "opencode_fixture/opencode.db";
const GROK: &str = "grok_session/chat_history.jsonl";
fn fixture_root() -> PathBuf {
Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures")
}
fn fresh_dir() -> PathBuf {
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("system clock")
.as_nanos();
let path = std::env::temp_dir().join(format!(
"supercode-support-probe-{}-{nanos}",
std::process::id()
));
fs::create_dir_all(&path).expect("create probe directory");
path
}
fn copy_fixture(root: &Path, relative: &str, target: &Path) -> PathBuf {
let destination = target.join(Path::new(relative).file_name().unwrap());
fs::copy(root.join(relative), &destination).expect("copy fixture");
destination
}
fn event_kind(event: &supercode::SessionWatchEvent) -> &'static str {
match event {
supercode::SessionWatchEvent::SessionSnapshot { .. } => "session_snapshot",
supercode::SessionWatchEvent::MessagesAppended { .. } => "messages_appended",
supercode::SessionWatchEvent::WatchError { .. } => "watch_error",
}
}
fn append_text(path: &Path, line: &str) {
let mut file = OpenOptions::new()
.append(true)
.open(path)
.expect("open append");
file.write_all(line.as_bytes()).expect("append fixture");
file.write_all(b"\n").expect("append newline");
file.flush().expect("flush fixture");
}
fn mutate_jsonl(harness: &str, path: &Path) {
match harness {
HarnessId::CLAUDE_CODE => append_text(
path,
r#"{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"support probe append"}]},"uuid":"support-probe-a","parentUuid":"support-probe-u","sessionId":"support-probe"}"#,
),
HarnessId::CODEX => append_text(
path,
r#"{"timestamp":"2099-01-01T00:00:00Z","type":"response_item","payload":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"support probe append"}],"phase":"final_answer"}}"#,
),
HarnessId::PI => append_text(
path,
r#"{"type":"message","id":"support-probe-message","parentId":"dda32458","timestamp":"2099-01-01T00:00:00Z","message":{"role":"user","content":"support probe append","timestamp":4070908800000}}"#,
),
HarnessId::GROK => append_text(
path,
r#"{"type":"assistant","content":"support probe append","tool_calls":[],"model_id":"grok-code-fixture"}"#,
),
_ => unreachable!(),
}
}
fn mutate_opencode(path: &Path) {
let connection = rusqlite::Connection::open(path).expect("open copied OpenCode fixture");
let session_id = "ses_fixtureAAAAAAAAAAAAAAA1";
let message_id = "msg_supportProbe000000001";
connection
.execute(
"INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?1, ?2, ?3, ?3, ?4)",
params![
message_id,
session_id,
4_070_908_800_000_i64,
r#"{"role":"user","time":{"created":4070908800000},"agent":"build"}"#
],
)
.expect("insert OpenCode message");
connection
.execute(
"INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?1, ?2, ?3, ?4, ?4, ?5)",
params![
"prt_supportProbe000000001",
message_id,
session_id,
4_070_908_800_000_i64,
r#"{"type":"text","text":"support probe append"}"#
],
)
.expect("insert OpenCode part");
connection
.execute(
"UPDATE session SET time_updated = ?1 WHERE id = ?2",
params![4_070_908_800_000_i64, session_id],
)
.expect("update OpenCode session");
}
fn format_name(format: SessionFormat) -> &'static str {
match format {
SessionFormat::ClaudeCode => HarnessId::CLAUDE_CODE,
SessionFormat::Codex => HarnessId::CODEX,
SessionFormat::OpenCode => HarnessId::OPENCODE,
SessionFormat::Pi => HarnessId::PI,
SessionFormat::Grok => HarnessId::GROK,
}
}
fn fixture_probe(harness: &str, path: &Path, format: SessionFormat) -> Value {
let loaded = match Session::load(path) {
Ok(session) => session,
Err(error) => return json!({"load": {"status": "failed", "error": error.to_string()}}),
};
let mut translations = BTreeMap::new();
for target in [
SessionFormat::ClaudeCode,
SessionFormat::Codex,
SessionFormat::OpenCode,
SessionFormat::Pi,
SessionFormat::Grok,
] {
let outcome = loaded.to_jsonl(target).and_then(|encoded| {
Session::load_str(&encoded, target).map(|reloaded| (encoded, reloaded))
});
translations.insert(
format_name(target),
match outcome {
Ok((encoded, reloaded)) => json!({
"status": "exercised",
"bytes": encoded.len(),
"source_messages": loaded.messages.len(),
"reloaded_messages": reloaded.messages.len(),
"message_count_preserved": loaded.messages.len() == reloaded.messages.len(),
}),
Err(error) => json!({"status": "failed", "error": error.to_string()}),
},
);
}
let mut follower = SessionFollower::open(path, None).expect("fixture follower opens");
let initial = follower
.poll()
.expect("initial poll")
.expect("initial event");
if harness == HarnessId::OPENCODE {
mutate_opencode(path);
} else {
mutate_jsonl(harness, path);
}
let mutation = follower.poll().expect("mutation poll");
json!({
"load": {
"status": "verified",
"source": format_name(format),
"messages": loaded.messages.len(),
},
"follow": {
"status": if mutation.is_some() { "verified" } else { "failed" },
"initial_event": event_kind(&initial),
"mutation_event": mutation.as_ref().map(event_kind),
},
"translations": translations,
})
}
fn main() {
let registry = harness_support_registry();
let mut service = HarnessSessionService::new();
let service_response = service.handle(json!({
"jsonrpc": "2.0",
"id": 1,
"method": "harness.v1.support.report",
"params": {},
}));
let service_ids = service_response["result"]["harnesses"]
.as_array()
.into_iter()
.flatten()
.filter_map(|entry| entry["id"].as_str())
.collect::<Vec<_>>();
let registry_ids = registry
.harnesses
.iter()
.map(|entry| entry.id.as_str().to_owned())
.collect::<Vec<_>>();
let root = fixture_root();
let temp = fresh_dir();
let claude_dir = temp.join("claude");
let codex_dir = temp.join("codex");
let pi_dir = temp.join("pi");
let opencode_dir = temp.join("opencode");
let grok_dir = temp.join("grok");
let grok_session_dir = grok_dir
.join("%2Ftmp%2Fsupport-probe-grok")
.join("support-probe-grok-session");
for directory in [
&claude_dir,
&codex_dir,
&pi_dir,
&opencode_dir,
&grok_session_dir,
] {
fs::create_dir_all(directory).expect("create harness fixture directory");
}
let paths = BTreeMap::from([
(
HarnessId::CLAUDE_CODE,
copy_fixture(&root, CLAUDE, &claude_dir),
),
(HarnessId::CODEX, copy_fixture(&root, CODEX, &codex_dir)),
(HarnessId::PI, copy_fixture(&root, PI, &pi_dir)),
(
HarnessId::OPENCODE,
copy_fixture(&root, OPENCODE, &opencode_dir),
),
(
HarnessId::GROK,
copy_fixture(&root, GROK, &grok_session_dir),
),
]);
let homes = HarnessHomes {
claude_code: claude_dir,
codex: codex_dir,
pi: pi_dir,
opencode: opencode_dir,
grok: grok_dir,
};
let discovered = HarnessCatalog::new()
.discover(&DiscoveryQuery {
homes,
..DiscoveryQuery::default()
})
.expect("fixture discovery");
let mut discovered_by_harness = BTreeMap::<String, usize>::new();
for descriptor in discovered {
*discovered_by_harness
.entry(descriptor.locator.harness.0)
.or_default() += 1;
}
let formats = BTreeMap::from([
(HarnessId::CLAUDE_CODE, SessionFormat::ClaudeCode),
(HarnessId::CODEX, SessionFormat::Codex),
(HarnessId::OPENCODE, SessionFormat::OpenCode),
(HarnessId::PI, SessionFormat::Pi),
(HarnessId::GROK, SessionFormat::Grok),
]);
let mut harnesses = serde_json::Map::new();
for descriptor in registry.harnesses {
let id = descriptor.id.0.clone();
let fixture = match (paths.get(id.as_str()), formats.get(id.as_str())) {
(Some(path), Some(format)) => fixture_probe(&id, path, *format),
_ => json!({
"load": {"status": "gap", "reason": "no committed native fixture"},
"follow": {"status": "gap", "reason": "no native persistence implementation"},
"translations": {},
}),
};
harnesses.insert(
id.clone(),
json!({
"registry": descriptor,
"discovery": {
"status": if discovered_by_harness.get(&id).copied().unwrap_or(0) > 0 {
"verified"
} else {
"failed"
},
"sessions": discovered_by_harness.get(&id).copied().unwrap_or(0),
},
"fixture": fixture,
}),
);
}
println!(
"{}",
serde_json::to_string_pretty(&json!({
"schema": "supercode.behavioral-support-probe.v1",
"scope": "committed-fixtures",
"live_executables_contacted": false,
"surfaces": {
"core": {"status": "verified", "operation": "harness_support_registry"},
"service": {
"status": if service_ids == registry_ids { "verified" } else { "failed" },
"operation": "harness.v1.support.report",
"harnesses": service_ids,
},
},
"harnesses": harnesses,
}))
.expect("serialize support probe")
);
fs::remove_dir_all(temp).ok();
}