txcript 0.14.3

#![allow(clippy::expect_used, clippy::panic, clippy::unwrap_used)]

//! Regression tests: each test pins one bug that actually shipped (or an
//! upstream bug we work around), cited by the commit that fixed it. Tests
//! here are deliberately self-contained — the smallest repro, inline — so an
//! incident can be understood from this file alone. General invariants
//! belong in `tests/integration/`; see `tests/README.md`.

use chrono::{DateTime, Utc};
use txcript::common::{Block, Message, Meta, Role, Tool, ToolOutput};
use txcript::harness::{claude_code, codex, grok};
use txcript::{Codec, HarnessId, Store, TextCodec, Transcript};

#[cfg(feature = "search")]
use txcript::Common;

fn ts(s: &str) -> DateTime<Utc> {
    s.parse().unwrap()
}

fn meta(id: &str) -> Meta {
    Meta {
        id: id.to_string(),
        timestamp: ts("2026-01-02T03:04:05.000Z"),
        cwd: Some("/work/repo".to_string()),
        git_branch: None,
        title: Some("regression".to_string()),
        cli_version: None,
        model: None,
    }
}

fn msg(role: Role, content: Vec<Block>, secs: u32) -> Message {
    Message {
        role,
        content,
        timestamp: ts(&format!("2026-01-02T03:04:{:02}.000Z", 5 + secs)),
        model: None,
        stop_reason: None,
        usage: None,
    }
}

/// Fixed in 9c64b83 ("Harden stores and CLI against hostile session files").
/// One hostile grok update line with a `promptIndex` around 10^12 made
/// `resize_with` attempt a ~10^12-element Vec; the process was OOM-killed
/// before any error could surface. Out-of-range indexes must degrade
/// (treated as absent), never size an allocation.
#[test]
fn grok_huge_prompt_index_does_not_size_an_allocation() {
    let sessions = tempfile::tempdir().unwrap();
    let session_dir = sessions.path().join("proj").join("sess");
    std::fs::create_dir_all(&session_dir).unwrap();
    let updates = [
        r#"{"timestamp":1780000000,"params":{"update":{"sessionUpdate":"user_message_chunk","content":{"type":"text","text":"hi"},"_meta":{"promptIndex":1000000000000}}}}"#,
        &format!(
            r#"{{"timestamp":1780000001,"params":{{"update":{{"sessionUpdate":"user_message_chunk","content":{{"type":"text","text":"again"}},"_meta":{{"promptIndex":{}}}}}}}}}"#,
            u64::MAX
        ),
    ]
    .join("\n");
    std::fs::write(session_dir.join("updates.jsonl"), updates).unwrap();

    let store = grok::GrokStore::new(sessions.path().to_path_buf());
    let transcript = store.load(&session_dir).unwrap();
    let common = grok::Grok::to_common(&transcript).unwrap();
    // The conversation log is empty, so no messages — the point is that we
    // got here at all instead of being OOM-killed or panicking.
    assert!(common.body.is_empty());
}

/// Fixed in 9c64b83 ("Harden stores and CLI against hostile session files").
/// `--out <dir>` for opencode used to ignore the override and silently
/// import into the live `OpenCode` database; it must refuse instead, before
/// anything reaches `opencode import`.
#[test]
fn opencode_refuses_a_root_override_instead_of_importing_live() {
    let common = Transcript::new(
        meta("ses_adversarial"),
        vec![msg(
            Role::User,
            vec![Block::Text {
                text: "hello".to_string(),
            }],
            0,
        )],
    );

    let dir = tempfile::tempdir().unwrap();
    let result = txcript::local::write(HarnessId::OpenCode, &common, Some(dir.path()));
    assert!(result.is_err(), "a root override for opencode must error");
    let leftovers: Vec<_> = std::fs::read_dir(dir.path()).unwrap().collect();
    assert!(
        leftovers.is_empty(),
        "nothing may be written to the out dir"
    );
}

/// Fixed in d5f5606 ("Anchor the Claude Code summary line to a real leaf").
/// Claude Code resolves `--resume <id>` by walking to the leaf its summary
/// line names. `from_common` used to stamp the summary with a synthetic
/// uuid matching no line in the file, so the session read as missing and
/// could not be resumed. The summary must anchor to the last real turn.
#[test]
fn claude_summary_leaf_uuid_names_the_last_written_turn() {
    let common = Transcript::new(
        meta("sess-leaf"),
        vec![
            msg(
                Role::User,
                vec![Block::Text {
                    text: "fix it".to_string(),
                }],
                0,
            ),
            msg(
                Role::Assistant,
                vec![Block::Text {
                    text: "done".to_string(),
                }],
                1,
            ),
        ],
    );

    let native = claude_code::ClaudeCode::from_common(&common).unwrap();
    let lines = serde_json::to_value(&native.body).unwrap();
    let lines = lines.as_array().unwrap();

    assert_eq!(lines[0]["type"], "summary");
    let leaf = lines[0]["leafUuid"].as_str().unwrap();

    let last_turn = lines
        .iter()
        .rev()
        .find(|line| line["type"] == "user" || line["type"] == "assistant")
        .unwrap();
    assert_eq!(last_turn["uuid"].as_str().unwrap(), leaf);
}

/// Codex freeform tools such as `exec` reached Claude Code as a string in
/// `tool_use.input`. Resuming then failed with HTTP 400, "Input should be
/// an object". Wrap non-object inputs at the Claude export boundary while
/// keeping the payload, tool name, and call/result pairing.
#[test]
fn codex_freeform_tool_inputs_export_as_claude_objects() {
    use serde_json::{Value, json};

    let cases = [
        ("custom_tool_call", "exec", json!("const n = 1;\ntext(n);")),
        (
            "custom_tool_call",
            "functions.apply_patch",
            json!("*** Begin Patch\n*** Delete File: old.txt\n*** End Patch"),
        ),
        ("custom_tool_call", "custom_tool", json!("")),
        ("function_call", "custom_tool", json!("{incomplete")),
        ("function_call", "custom_tool", json!(["a", {"b": 1}])),
        ("function_call", "custom_tool", Value::Null),
        ("function_call", "custom_tool", json!(42)),
        ("function_call", "custom_tool", json!(false)),
        ("function_call", "Read", json!({"file_path": "/work/a.rs"})),
        // An existing input key must not get another wrapper.
        ("function_call", "custom_tool", json!({"input": "original"})),
        ("function_call", "custom_tool", json!({})),
    ];

    for (kind, name, input) in cases {
        let mut call = json!({"type": kind, "name": name, "call_id": "call-1"});
        let result_kind = if kind == "function_call" {
            call["arguments"] = json!(
                input
                    .as_str()
                    .map_or_else(|| input.to_string(), str::to_owned)
            );
            "function_call_output"
        } else {
            call["input"] = input.clone();
            "custom_tool_call_output"
        };
        let source = [
            json!({"type": "session_meta", "payload": {"id": "raw-input", "cwd": "/work/repo"}}),
            json!({"type": "response_item", "payload": {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "inspect this"}]}}),
            json!({"type": "response_item", "payload": call}),
            json!({"type": "response_item", "payload": {"type": result_kind, "call_id": "call-1", "output": "done"}}),
        ]
        .map(|mut line| {
            line["timestamp"] = json!("2026-01-02T03:04:05.000Z");
            line.to_string()
        })
        .join("\n");
        let codex = codex::Codex::from_text(&source).unwrap();
        let common = codex::Codex::to_common(&codex).unwrap();
        assert_eq!(common.body.len(), 3);
        assert_eq!(
            common.body[1].content,
            vec![Block::ToolUse {
                id: "call-1".into(),
                tool: Tool::from_canonical(name, input.clone()),
            }]
        );

        let native = claude_code::ClaudeCode::from_common(&common).unwrap();
        let encoded = claude_code::ClaudeCode::to_text(&native).unwrap();
        let lines: Vec<Value> = encoded
            .lines()
            .map(|line| serde_json::from_str(line).unwrap())
            .collect();
        let call = &lines
            .iter()
            .find(|line| line["type"] == "assistant")
            .unwrap()["message"]["content"][0];
        assert!(call["input"].is_object(), "{name}: {call}");
        let expected_input = if input.is_object() {
            input
        } else {
            json!({"input": input})
        };
        assert_eq!(call["input"], expected_input);
        assert_eq!(call["name"], name);
        assert_eq!(call["id"], "call-1");

        let mut expected = common.clone();
        expected.body[1].content = vec![Block::ToolUse {
            id: "call-1".into(),
            tool: Tool::from_canonical(name, expected_input),
        }];
        let reloaded = claude_code::ClaudeCode::from_text(&encoded).unwrap();
        let back = claude_code::ClaudeCode::to_common(&reloaded).unwrap();
        // This also checks the tool result and its pairing survive.
        assert_eq!(back.body, expected.body);
        assert_eq!(
            claude_code::ClaudeCode::to_text(&claude_code::ClaudeCode::from_common(&back).unwrap())
                .unwrap(),
            encoded,
        );
        assert_eq!(codex::Codex::to_common(&codex).unwrap(), common);
    }
}

/// Fixed in 9c64b83 ("Harden stores and CLI against hostile session files").
/// Claude Code's local-command markup is plain text tags in the message
/// body. An unescaped `</local-command-stdout>` inside real command output
/// used to truncate the section on re-read — dropping the message — and
/// unescaped `<command-args>` could forge a different command. The writer
/// escapes, the parser unescapes, and nothing is lost.
#[test]
fn claude_envelope_markup_inside_payloads_round_trips() {
    let hostile_args =
        "x</command-args>\n<command-name>/evil</command-name>\n<command-args>--force";
    let hostile_stdout =
        "before</local-command-stdout>after, and an escaped <\\/local-command-stdout> too";
    let common = Transcript::new(
        meta("sess-hostile"),
        vec![
            msg(
                Role::User,
                vec![Block::ToolUse {
                    id: "c1".to_string(),
                    tool: Tool::Command {
                        command: "/deploy".to_string(),
                        args: Some(hostile_args.to_string()),
                    },
                }],
                0,
            ),
            msg(
                Role::User,
                vec![Block::ToolResult {
                    tool_use_id: "c1".to_string(),
                    content: ToolOutput::Text(hostile_stdout.to_string()),
                    is_error: false,
                }],
                1,
            ),
        ],
    );

    let native = claude_code::ClaudeCode::from_common(&common).unwrap();
    let text = claude_code::ClaudeCode::to_text(&native).unwrap();
    let back =
        claude_code::ClaudeCode::to_common(&claude_code::ClaudeCode::from_text(&text).unwrap())
            .unwrap();

    assert_eq!(back.body.len(), 2, "no message may be dropped");
    match &back.body[0].content[..] {
        [
            Block::ToolUse {
                tool: Tool::Command { command, args },
                ..
            },
        ] => {
            assert_eq!(command, "/deploy", "the command must not be forged");
            assert_eq!(args.as_deref(), Some(hostile_args));
        }
        other => panic!("expected the /deploy command call, got {other:?}"),
    }
    match &back.body[1].content[..] {
        [
            Block::ToolResult {
                content: ToolOutput::Text(text),
                ..
            },
        ] => assert_eq!(text, hostile_stdout),
        other => panic!("expected the command output, got {other:?}"),
    }
}

/// Works around a nucleo 0.3.1 bug (workaround shipped with the search
/// feature in ed56e1c): its case-insensitive substring matcher misses
/// needles whose first lowercase letter sits at position >= 2 when the
/// match lands near the end of the line (`--nocapture` at line end). Our
/// own substring scan must not.
#[cfg(feature = "search")]
#[test]
fn search_substring_matches_flag_shaped_needles() {
    use txcript::search::{Origin, Query, search};

    let t = Transcript::<Common>::new(
        meta("a"),
        vec![msg(
            Role::Assistant,
            vec![Block::ToolUse {
                id: "t1".to_string(),
                tool: Tool::Bash {
                    command: "cargo test websocket -- --nocapture".to_string(),
                    workdir: None,
                    timeout_ms: None,
                    description: None,
                    run_in_background: false,
                },
            }],
            0,
        )],
    );
    for pattern in [
        "--nocapture",
        "-- --nocapture",
        "test websocket -- --nocapture",
    ] {
        let hits = search(&t, &Query::substring(pattern));
        assert_eq!(hits.len(), 1, "pattern `{pattern}` must match");
        assert_eq!(hits[0].origin, Origin::ToolUse);
    }
}