//! End-to-end CLI tests (offline).

//!

//! These tests invoke the compiled `pi` binary directly and verify that

//! offline flags/subcommands behave as expected, with verbose logging

//! and artifact capture for debugging failures.

mod common;

#[cfg(unix)]

use asupersync::runtime::RuntimeBuilder;

use common::TestHarness;

use pi::config::Config;

#[cfg(unix)]

use pi::extensions::{ExtensionManager, JsExtensionLoadSpec, JsExtensionRuntimeHandle};

#[cfg(unix)]

use pi::extensions_js::PiJsRuntimeConfig;

#[cfg(unix)]

use pi::package_manager::{PackageManager, PackageScope, ResolveRoots};

use pi::session::encode_cwd;

use pi::tools::ToolRegistry;

use serde_json::json;

use std::cell::Cell;

use std::collections::BTreeMap;

use std::ffi::OsStr;

use std::fs;

use std::io::{Read as _, Write as _};

#[cfg(unix)]

use std::os::unix::fs::PermissionsExt;

use std::path::{Path, PathBuf};

use std::process::{Command, Stdio};

#[cfg(unix)]

use std::sync::Arc;

use std::time::{Duration, Instant};

const DEFAULT_CLI_TIMEOUT_SECS: u64 = 120;

struct CliResult {

exit_code: i32,

stdout: String,

stderr: String,

duration: Duration,

}

struct CliTestHarness {

harness: TestHarness,

binary_path: PathBuf,

#[allow(dead_code)]

env_root: PathBuf,

env: BTreeMap<String, String>,

run_seq: Cell<usize>,

}

impl CliTestHarness {

fn new(name: &str) -> Self {

let harness = TestHarness::new(name);

let binary_path = PathBuf::from(env!("CARGO_BIN_EXE_pi"));

let mut env = BTreeMap::new();

let env_root = harness.temp_path("pi-env");

let _ = std::fs::create_dir_all(&env_root);

// Fully isolate global/project state for determinism.

env.insert(

"HOME".to_string(),

env_root.join("home").display().to_string(),

);

env.insert(

"PI_CODING_AGENT_DIR".to_string(),

env_root.join("agent").display().to_string(),

);

env.insert(

"PI_CONFIG_PATH".to_string(),

env_root.join("settings.json").display().to_string(),

);

env.insert(

"PI_SESSIONS_DIR".to_string(),

env_root.join("sessions").display().to_string(),

);

env.insert(

"PI_PACKAGE_DIR".to_string(),

env_root.join("packages").display().to_string(),

);

// Make npm deterministic and offline-friendly for tests:

// - disable audit/fund network calls

// - isolate cache and global prefix inside the harness temp dir

env.insert("npm_config_audit".to_string(), "false".to_string());

env.insert("npm_config_fund".to_string(), "false".to_string());

env.insert(

"npm_config_update_notifier".to_string(),

"false".to_string(),

);

env.insert(

"npm_config_cache".to_string(),

env_root.join("npm-cache").display().to_string(),

);

env.insert(

"npm_config_prefix".to_string(),

env_root.join("npm-prefix").display().to_string(),

);

Self {

harness,

binary_path,

env_root,

env,

run_seq: Cell::new(0),

}

}

#[cfg(unix)]

fn global_settings_path(&self) -> PathBuf {

self.env.get("PI_CONFIG_PATH").map_or_else(

|| {

PathBuf::from(

self.env

.get("PI_CODING_AGENT_DIR")

.expect("PI_CODING_AGENT_DIR must be set"),

)

.join("settings.json")

},

PathBuf::from,

)

}

#[cfg(unix)]

fn project_settings_path(&self) -> PathBuf {

self.harness.temp_dir().join(".pi").join("settings.json")

}

#[cfg(unix)]

fn snapshot_path(&self, source: &Path, artifact_name: &str) {

if !source.exists() {

return;

}

let dest = self.harness.temp_path(artifact_name);

std::fs::copy(source, &dest).expect("copy snapshot");

self.harness.record_artifact(artifact_name, &dest);

}

#[cfg(unix)]

fn snapshot_settings(&self, label: &str) {

self.snapshot_path(

&self.global_settings_path(),

&format!("settings.global.{label}.json"),

);

self.snapshot_path(

&self.project_settings_path(),

&format!("settings.project.{label}.json"),

);

}

fn run(&self, args: &[&str]) -> CliResult {

self.run_with_stdin(args, None)

}

fn cli_timeout() -> Duration {

std::env::var("PI_E2E_CLI_TIMEOUT_SECS")

.ok()

.and_then(|value| value.parse::<u64>().ok())

.filter(|value| *value > 0)

.map_or_else(

|| Duration::from_secs(DEFAULT_CLI_TIMEOUT_SECS),

Duration::from_secs,

)

}

#[allow(clippy::too_many_lines)]

fn run_with_stdin(&self, args: &[&str], stdin: Option<&[u8]>) -> CliResult {

self.harness

.log()

.info("action", format!("Running CLI: {}", args.join(" ")));

self.harness.log().info_ctx("action", "CLI env", |ctx| {

for (key, value) in &self.env {

ctx.push((key.clone(), value.clone()));

}

});

if let Some(bytes) = stdin {

self.harness.log().info_ctx("action", "CLI stdin", |ctx| {

ctx.push(("bytes".to_string(), bytes.len().to_string()));

});

}

let start = Instant::now();

let mut command = Command::new(&self.binary_path);

command.env_remove("ANTHROPIC_API_KEY");

command.env_remove("OPENAI_API_KEY");

command.env_remove("GEMINI_API_KEY");

command.env_remove("GROQ_API_KEY");

command.env_remove("KIMI_API_KEY");

command.env_remove("AZURE_OPENAI_API_KEY");

command

.args(args)

.envs(self.env.clone())

.current_dir(self.harness.temp_dir())

.stdout(Stdio::piped())

.stderr(Stdio::piped());

if stdin.is_some() {

command.stdin(Stdio::piped());

} else {

command.stdin(Stdio::null());

}

let mut child = command.spawn().expect("run pi");

let child_pid = child.id();

let mut child_stdout = child.stdout.take().expect("child stdout piped");

let mut child_stderr = child.stderr.take().expect("child stderr piped");

let stdout_handle = std::thread::spawn(move || {

let mut buf = Vec::new();

let _ = child_stdout.read_to_end(&mut buf);

buf

});

let stderr_handle = std::thread::spawn(move || {

let mut buf = Vec::new();

let _ = child_stderr.read_to_end(&mut buf);

buf

});

if let Some(input) = stdin {

if let Some(mut child_stdin) = child.stdin.take() {

child_stdin.write_all(input).expect("write stdin");

}

}

let timeout = Self::cli_timeout();

let mut timed_out = false;

let status = loop {

match child.try_wait() {

Ok(Some(status)) => break status,

Ok(None) => {}

Err(err) => panic!("try_wait failed: {err}"),

}

if start.elapsed() > timeout {

timed_out = true;

break child

.kill()

.ok()

.and_then(|()| child.wait().ok())

.unwrap_or_else(|| panic!("timed out after {timeout:?}; failed to kill/wait"));

}

std::thread::sleep(Duration::from_millis(25));

};

let stdout_bytes = stdout_handle.join().unwrap_or_default();

let stderr_bytes = stderr_handle.join().unwrap_or_default();

let duration = start.elapsed();

let stdout = String::from_utf8_lossy(&stdout_bytes).to_string();

let mut stderr = String::from_utf8_lossy(&stderr_bytes).to_string();

let exit_code = if timed_out {

stderr =

format!("ERROR: pi CLI timed out after {timeout:?} (pid={child_pid}).\n{stderr}");

-1

} else {

status.code().unwrap_or(-1)

};

self.harness

.log()

.info_ctx("result", "CLI completed", |ctx| {

ctx.push(("exit_code".to_string(), exit_code.to_string()));

ctx.push(("duration_ms".to_string(), duration.as_millis().to_string()));

ctx.push(("stdout_len".to_string(), stdout.len().to_string()));

ctx.push(("stderr_len".to_string(), stderr.len().to_string()));

ctx.push(("timed_out".to_string(), timed_out.to_string()));

});

let seq = self.run_seq.get();

self.run_seq.set(seq.saturating_add(1));

let stdout_name = format!("stdout.{seq}.txt");

let stderr_name = format!("stderr.{seq}.txt");

let stdout_path = self.harness.temp_path(&stdout_name);

let stderr_path = self.harness.temp_path(&stderr_name);

let _ = std::fs::write(&stdout_path, &stdout);

let _ = std::fs::write(&stderr_path, &stderr);

self.harness.record_artifact(stdout_name, &stdout_path);

self.harness.record_artifact(stderr_name, &stderr_path);

CliResult {

exit_code,

stdout,

stderr,

duration,

}

}

}

/// Canonicalize a path and strip the Windows `\\?\` prefix if present.

fn canon(p: &Path) -> PathBuf {

let c = fs::canonicalize(p).unwrap_or_else(|_| p.to_path_buf());

pi::extensions::strip_unc_prefix(c)

}

fn assert_contains(harness: &TestHarness, haystack: &str, needle: &str) {

harness.assert_log(format!("assert contains: {needle}").as_str());

assert!(

haystack.contains(needle),

"expected output to contain '{needle}'"

);

}

fn assert_contains_case_insensitive(harness: &TestHarness, haystack: &str, needle: &str) {

harness.assert_log(format!("assert contains (ci): {needle}").as_str());

assert!(

haystack.to_lowercase().contains(&needle.to_lowercase()),

"expected output to contain (case-insensitive) '{needle}'"

);

}

fn assert_exit_code(harness: &TestHarness, result: &CliResult, expected: i32) {

harness.assert_log(format!("assert exit_code == {expected}").as_str());

assert_eq!(result.exit_code, expected);

}

#[cfg(unix)]

fn read_json_value(path: &Path) -> serde_json::Value {

let content = fs::read_to_string(path).expect("read json file");

serde_json::from_str(&content).expect("parse json")

}

#[cfg(unix)]

fn run_async<T>(future: impl std::future::Future<Output = T>) -> T {

let runtime = RuntimeBuilder::current_thread()

.build()

.expect("build asupersync runtime");

runtime.block_on(future)

}

#[cfg(unix)]

fn write_jsonl_artifacts(harness: &TestHarness, logs_name: &str, artifacts_name: &str) {

let logs_path = harness.temp_path(logs_name);

harness

.write_jsonl_logs_normalized(&logs_path)

.expect("write normalized jsonl logs");

harness.record_artifact(logs_name.to_string(), &logs_path);

let artifact_index = harness.temp_path(artifacts_name);

harness

.write_artifact_index_jsonl_normalized(&artifact_index)

.expect("write normalized artifact index");

harness.record_artifact(artifacts_name.to_string(), &artifact_index);

}

#[cfg(unix)]

fn resolve_roots_for_cli_harness(harness: &CliTestHarness) -> ResolveRoots {

let global_base_dir = PathBuf::from(

harness

.env

.get("PI_CODING_AGENT_DIR")

.expect("PI_CODING_AGENT_DIR set by CliTestHarness::new"),

);

ResolveRoots {

project_settings_enabled: true,

global_settings_path: harness.global_settings_path(),

project_settings_path: harness.project_settings_path(),

global_base_dir,

project_base_dir: harness.harness.temp_dir().join(".pi"),

}

}

fn write_minimal_session(path: &Path, cwd: &Path) -> (String, String, String, String) {

let session_id = "session-test-123";

let timestamp = "2026-02-04T00:00:00.000Z";

let message = "Hello export";

let cwd_str = cwd.display().to_string();

let header = json!({

"type": "session",

"version": 3,

"id": session_id,

"timestamp": timestamp,

"cwd": cwd_str,

"provider": "anthropic",

"modelId": "claude-3-opus-20240229"

});

let entry = json!({

"type": "message",

"timestamp": "2026-02-04T00:00:01.000Z",

"message": {

"role": "user",

"content": message

}

});

let content = format!("{header}\n{entry}\n");

fs::write(path, content).expect("write session jsonl");

(

session_id.to_string(),

timestamp.to_string(),

cwd.display().to_string(),

message.to_string(),

)

}

fn count_jsonl_files(path: &Path) -> usize {

let mut count = 0usize;

let Ok(entries) = fs::read_dir(path) else {

return 0;

};

for entry in entries.flatten() {

let entry_path = entry.path();

if entry_path.is_dir() {

count += count_jsonl_files(&entry_path);

} else if entry_path

.extension()

.and_then(OsStr::to_str)

.is_some_and(|ext| ext == "jsonl")

{

println!("FOUND JSONL: {}", entry_path.display());

count += 1;

}

}

count

}

#[cfg(unix)]

fn sh_escape(value: &str) -> String {

// POSIX shell escape using single quotes.

let mut out = String::with_capacity(value.len() + 2);

out.push('\'');

for ch in value.chars() {

if ch == '\'' {

out.push_str("'\"'\"'");

} else {

out.push(ch);

}

}

out.push('\'');

out

}

#[cfg(unix)]

struct TmuxInstance {

socket_name: String,

session_name: String,

}

#[cfg(unix)]

impl TmuxInstance {

fn tmux_available() -> bool {

Command::new("tmux")

.arg("-V")

.stdout(Stdio::null())

.stderr(Stdio::null())

.status()

.is_ok()

}

fn new(harness: &TestHarness) -> Self {

let pid = std::process::id();

let seed = harness.deterministic_seed();

Self {

socket_name: format!("pi-e2e-{pid}-{seed:x}"),

session_name: format!("pi-e2e-{pid}-{seed:x}"),

}

}

fn tmux_base(&self) -> Command {

let mut command = Command::new("tmux");

command

.arg("-L")

.arg(&self.socket_name)

.arg("-f")

.arg("/dev/null");

command

}

fn tmux_output(&self, args: &[&str]) -> std::process::Output {

self.tmux_base()

.args(args)

.stdout(Stdio::piped())

.stderr(Stdio::piped())

.output()

.expect("tmux output")

}

fn run_checked(&self, args: &[&str], label: &str) -> std::process::Output {

let output = self.tmux_output(args);

assert!(

output.status.success(),

"tmux {label} failed\nstdout:\n{}\nstderr:\n{}",

String::from_utf8_lossy(&output.stdout),

String::from_utf8_lossy(&output.stderr),

);

output

}

fn start_session(&self, workdir: &Path, script_path: &Path) {

let workdir_str = workdir.display().to_string();

let script_str = script_path.display().to_string();

self.run_checked(

&[

"new-session",

"-d",

"-x",

"80",

"-y",

"24",

"-s",

&self.session_name,

"-c",

&workdir_str,

&script_str,

],

"new-session",

);

}

fn target_pane(&self) -> String {

format!("{}:0.0", self.session_name)

}

fn send_literal(&self, text: &str) {

let target = self.target_pane();

self.run_checked(&["send-keys", "-t", &target, "-l", text], "send-keys -l");

}

fn send_key(&self, key: &str) {

let target = self.target_pane();

self.run_checked(&["send-keys", "-t", &target, key], "send-keys");

}

fn capture_pane(&self) -> String {

let target = self.target_pane();

// Capture some scrollback so long outputs (like `/help`) include their header.

let output = self.run_checked(

&["capture-pane", "-t", &target, "-p", "-S", "-2000"],

"capture-pane",

);

String::from_utf8_lossy(&output.stdout).to_string()

}

fn wait_for_pane_contains(&self, needle: &str, timeout: Duration) -> String {

let start = Instant::now();

loop {

let pane = self.capture_pane();

if pane.contains(needle) {

return pane;

}

if start.elapsed() > timeout {

return pane;

}

std::thread::sleep(Duration::from_millis(50));

}

}

fn wait_for_pane_contains_any(&self, needles: &[&str], timeout: Duration) -> String {

assert!(!needles.is_empty(), "needles must not be empty");

let start = Instant::now();

loop {

let pane = self.capture_pane();

if needles.iter().any(|needle| pane.contains(needle)) {

return pane;

}

if start.elapsed() > timeout {

return pane;

}

std::thread::sleep(Duration::from_millis(50));

}

}

fn session_exists(&self) -> bool {

self.tmux_base()

.args(["has-session", "-t", &self.session_name])

.stdout(Stdio::null())

.stderr(Stdio::null())

.status()

.is_ok_and(|status| status.success())

}

fn kill_server(&self) {

let _ = self

.tmux_base()

.args(["kill-server"])

.stdout(Stdio::null())

.stderr(Stdio::null())

.status();

}

}

#[cfg(unix)]

impl Drop for TmuxInstance {

fn drop(&mut self) {

self.kill_server();

}

}

#[test]

fn e2e_cli_explain_extension_policy_outputs_remediation() {

let harness = CliTestHarness::new("e2e_cli_explain_extension_policy_outputs_remediation");

let result = harness.run(&[

"--explain-extension-policy",

"--extension-policy",

"balanced",

]);

assert_exit_code(&harness.harness, &result, 0);

assert!(result.stderr.trim().is_empty(), "stderr should be empty");

let payload: serde_json::Value =

serde_json::from_str(&result.stdout).expect("explain output should be valid JSON");

assert_eq!(payload["requested_profile"], "balanced");

assert_eq!(payload["effective_profile"], "balanced");

assert_eq!(payload["profile_source"], "cli");

assert_eq!(payload["profile_aliases"]["standard"], "balanced");

assert_eq!(

payload["dangerous_capability_opt_in"]["config_example"]["extensionPolicy"]["allowDangerous"],

true

);

assert_eq!(

payload["migration_guardrails"]["default_profile"],

"permissive"

);

assert!(

payload["migration_guardrails"]["override_cli"]["balanced_prompt_mode"]

.as_str()

.is_some_and(|value| value.contains("--extension-policy balanced"))

);

let profile_presets = payload["profile_presets"]

.as_array()

.expect("profile_presets should be array");

assert!(

profile_presets

.iter()

.any(|entry| entry["profile"] == "balanced"),

"balanced profile preset should be present"

);

let capability_decisions = payload["capability_decisions"]

.as_array()

.expect("capability_decisions should be array");

let exec_decision = capability_decisions

.iter()

.find(|entry| entry["capability"] == "exec")

.expect("exec decision should be present");

assert_eq!(exec_decision["decision"], "deny");

assert_eq!(exec_decision["reason"], "deny_caps");

let to_allow_cli = exec_decision["remediation"]["to_allow_cli"]

.as_array()

.expect("to_allow_cli should be array");

assert!(

to_allow_cli.iter().any(|entry| {

entry

.as_str()

.is_some_and(|text| text.contains("PI_EXTENSION_ALLOW_DANGEROUS=1"))

}),

"exec remediation should include allow-dangerous CLI guidance"

);

}

#[test]

fn e2e_cli_explain_extension_policy_supports_legacy_standard_alias() {

let harness =

CliTestHarness::new("e2e_cli_explain_extension_policy_supports_legacy_standard_alias");

let result = harness.run(&[

"--explain-extension-policy",

"--extension-policy",

"standard",

]);

assert_exit_code(&harness.harness, &result, 0);

let payload: serde_json::Value =

serde_json::from_str(&result.stdout).expect("explain output should be valid JSON");

assert_eq!(payload["requested_profile"], "standard");

assert_eq!(payload["effective_profile"], "balanced");

assert_eq!(payload["profile_source"], "cli");

}

#[test]

fn e2e_cli_explain_extension_policy_default_is_permissive_with_guardrails() {

let harness = CliTestHarness::new(

"e2e_cli_explain_extension_policy_default_is_permissive_with_guardrails",

);

let result = harness.run(&["--explain-extension-policy"]);

assert_exit_code(&harness.harness, &result, 0);

assert!(result.stderr.trim().is_empty(), "stderr should be empty");

let payload: serde_json::Value =

serde_json::from_str(&result.stdout).expect("explain output should be valid JSON");

assert_eq!(payload["requested_profile"], "permissive");

assert_eq!(payload["effective_profile"], "permissive");

assert_eq!(payload["profile_source"], "default");

assert_eq!(

payload["migration_guardrails"]["default_profile"],

"permissive"

);

assert_eq!(

payload["migration_guardrails"]["active_default_profile"],

true

);

}

#[test]

fn e2e_cli_explain_extension_policy_profile_matrix_decisions() {

let mut deny_counts: BTreeMap<&'static str, usize> = BTreeMap::new();

for profile in ["safe", "balanced", "permissive"] {

let harness = CliTestHarness::new(&format!(

"e2e_cli_explain_extension_policy_profile_matrix_{profile}"

));

let result = harness.run(&["--explain-extension-policy", "--extension-policy", profile]);

assert_exit_code(&harness.harness, &result, 0);

assert!(

result.stderr.trim().is_empty(),

"stderr should be empty for profile={profile}"

);

let payload: serde_json::Value =

serde_json::from_str(&result.stdout).expect("explain output should be valid JSON");

assert_eq!(payload["effective_profile"], profile);

let capability_decisions = payload["capability_decisions"]

.as_array()

.expect("capability_decisions should be array");

assert!(

!capability_decisions.is_empty(),

"capability_decisions should not be empty for profile={profile}"

);

let deny_count = capability_decisions

.iter()

.filter(|entry| entry["decision"] == "deny")

.count();

let prompt_count = capability_decisions

.iter()

.filter(|entry| entry["decision"] == "prompt")

.count();

let allow_count = capability_decisions

.iter()

.filter(|entry| entry["decision"] == "allow")

.count();

assert_eq!(

deny_count + prompt_count + allow_count,

capability_decisions.len(),

"every capability decision should be classified for profile={profile}"

);

match profile {

"safe" => {

assert!(

deny_count > 0,

"safe profile should deny at least one capability"

);

}

"balanced" => {

assert!(

prompt_count > 0,

"balanced profile should prompt for at least one capability"

);

}

"permissive" => {

assert_eq!(

deny_count, 0,

"permissive profile should not deny capabilities by default"

);

}

_ => unreachable!("covered profiles are exhaustive"),

}

deny_counts.insert(profile, deny_count);

}

assert!(

deny_counts["safe"] >= deny_counts["balanced"],

"safe should be at least as restrictive as balanced"

);

}

#[test]

fn e2e_cli_policy_preflight_matches_runtime_negative_events() {

let negative_events_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))

.join("tests/ext_conformance/reports/negative/negative_events.jsonl");

if !negative_events_path.exists() {

eprintln!(

"SKIP: negative_events.jsonl not found at {} (generated by conformance suite)",

negative_events_path.display()

);

return;

}

let negative_events_raw =

std::fs::read_to_string(&negative_events_path).expect("read negative_events.jsonl");

let mode_by_profile = [

("safe", "strict"),

("balanced", "prompt"),

("permissive", "permissive"),

];

for (profile, mode) in mode_by_profile {

let harness = CliTestHarness::new(&format!(

"e2e_cli_policy_preflight_matches_runtime_{profile}"

));

let explain = harness.run(&["--explain-extension-policy", "--extension-policy", profile]);

assert_exit_code(&harness.harness, &explain, 0);

assert!(

explain.stderr.trim().is_empty(),

"stderr should be empty for profile={profile}"

);

let payload: serde_json::Value =

serde_json::from_str(&explain.stdout).expect("explain output should be JSON");

let capability_decisions = payload["capability_decisions"]

.as_array()

.expect("capability_decisions should be array");

let mut preflight_map: BTreeMap<String, String> = BTreeMap::new();

for decision in capability_decisions {

let capability = decision["capability"]

.as_str()

.expect("capability should be string")

.to_string();

let action = decision["decision"]

.as_str()

.expect("decision should be string")

.to_ascii_lowercase();

preflight_map.insert(capability, action);

}

let mut checked = 0usize;

let mut mismatches = Vec::new();

for line in negative_events_raw

.lines()

.filter(|line| !line.trim().is_empty())

{

let event: serde_json::Value =

serde_json::from_str(line).expect("negative event should be JSON");

if event["mode"].as_str() != Some(mode) {

continue;

}

let capability = event["capability"]

.as_str()

.expect("capability should be string")

.trim()

.to_string();

if capability.is_empty() {

continue;

}

// The negative-conformance runtime fixture enforces an explicit deny-list

// for dangerous caps even in permissive mode. That context intentionally

// differs from `--explain-extension-policy`.

if profile == "permissive" && (capability == "exec" || capability == "env") {

continue;

}

let Some(preflight_decision) = preflight_map.get(&capability) else {

continue;

};

let runtime_decision = event["actual_decision"]

.as_str()

.expect("actual_decision should be string")

.to_ascii_lowercase();

checked += 1;

if preflight_decision != &runtime_decision {

mismatches.push(format!(

"profile={profile} mode={mode} capability={capability} preflight={} runtime={runtime_decision} test={}",

preflight_decision,

event["test_name"].as_str().unwrap_or("unknown"),

));

}

}

assert!(

checked > 0,

"expected at least one runtime decision comparison for profile={profile}"

);

assert!(

mismatches.is_empty(),

"preflight/runtime policy mismatches for profile={profile}:\n{}",

mismatches.join("\n")

);

}

}

#[test]

fn e2e_cli_extension_compat_ledger_logged_when_enabled() {

let mut harness = CliTestHarness::new("e2e_cli_extension_compat_ledger_logged_when_enabled");

harness

.env

.insert("PI_EXT_COMPAT_SCAN".to_string(), "1".to_string());

harness

.env

.insert("RUST_LOG".to_string(), "info".to_string());

let ext_path = harness.harness.temp_path("ext.ts");

std::fs::write(

&ext_path,

"import fs from 'fs';\nimport { spawn } from 'child_process';\npi.tool('read', { path: 'README.md' });\nnew Function('return 1');\neval('1');\n",

)

.expect("write ext.ts");

let ext_arg = ext_path.display().to_string();

let result = harness.run(&["--list-models", "--extension", ext_arg.as_str()]);

assert_exit_code(&harness.harness, &result, 0);

let combined = format!("{}\n{}", result.stdout, result.stderr);

assert_contains(&harness.harness, &combined, "pi.ext.compat_ledger.v1");

}

#[test]

fn e2e_cli_extension_compat_ledger_keeps_cli_extensions_with_no_extensions() {

let mut harness = CliTestHarness::new(

"e2e_cli_extension_compat_ledger_keeps_cli_extensions_with_no_extensions",

);

harness

.env

.insert("PI_EXT_COMPAT_SCAN".to_string(), "1".to_string());

harness

.env

.insert("RUST_LOG".to_string(), "info".to_string());

let ext_path = harness.harness.temp_path("ext.ts");

std::fs::write(

&ext_path,

"import fs from 'fs';\npi.tool('read', { path: 'README.md' });\n",

)

.expect("write ext.ts");

let ext_arg = ext_path.display().to_string();

let result = harness.run(&[

"--list-models",

"--no-extensions",

"--extension",

ext_arg.as_str(),

]);

assert_exit_code(&harness.harness, &result, 0);

let combined = format!("{}\n{}", result.stdout, result.stderr);

assert_contains(&harness.harness, &combined, "pi.ext.compat_ledger.v1");

let log_path = harness.harness.temp_path("extension-cli-log.jsonl");

harness

.harness

.write_jsonl_logs(&log_path)

.expect("write jsonl log");

harness

.harness

.record_artifact("extension-cli-log.jsonl", &log_path);

let artifact_index = harness.harness.temp_path("extension-cli-artifacts.jsonl");

harness

.harness

.write_artifact_index_jsonl(&artifact_index)

.expect("write artifact index");

harness

.harness

.record_artifact("extension-cli-artifacts.jsonl", &artifact_index);

}

#[test]

fn e2e_cli_version_flag() {

let harness = CliTestHarness::new("e2e_cli_version_flag");

let result = harness.run(&["--version"]);

assert_exit_code(&harness.harness, &result, 0);

assert_contains(&harness.harness, &result.stdout, "pi ");

assert_contains(&harness.harness, &result.stdout, env!("CARGO_PKG_VERSION"));

assert_contains(&harness.harness, &result.stdout, "\n");

}

#[test]

fn e2e_cli_help_flag() {

let harness = CliTestHarness::new("e2e_cli_help_flag");

let result = harness.run(&["--help"]);

assert_exit_code(&harness.harness, &result, 0);

assert_contains_case_insensitive(&harness.harness, &result.stdout, "usage");

assert_contains(&harness.harness, &result.stdout, "pi");

}

#[test]

fn e2e_cli_invalid_flag_is_error() {

let harness = CliTestHarness::new("e2e_cli_invalid_flag_is_error");

let result = harness.run(&["--invalid-flag"]);

harness

.harness

.assert_log("assert exit_code == 2 for invalid flag");

assert_exit_code(&harness.harness, &result, 2);

assert_contains_case_insensitive(&harness.harness, &result.stderr, "error");

}

#[test]