From 1a2fa1581ef961fcccb7b21cafeeb590eee5462d Mon Sep 17 00:00:00 2001 From: Yeachan-Heo Date: Sun, 5 Apr 2026 16:41:02 +0000 Subject: [PATCH] Keep status JSON machine-readable for automation The global --output-format json flag already reached prompt-mode responses, but status and sandbox still bypassed that path and printed human-readable tables. This change threads the selected output format through direct command aliases and resumed slash-command execution so status queries emit valid structured JSON instead of mixed prose. It also adds end-to-end regression coverage for direct status/sandbox JSON and resumed /status JSON so shell automation can rely on stable parsing. Constraint: Global output formatting must stay compatible with existing text-mode reports Rejected: Require callers to scrape text status tables | fragile and breaks automation Confidence: high Scope-risk: narrow Directive: New direct commands that honor --output-format should thread the format through CliAction and resumed slash execution paths Tested: cargo build -p rusty-claude-cli Tested: cargo test -p rusty-claude-cli -- --nocapture Tested: cargo test --workspace Tested: cargo run -q -p rusty-claude-cli -- --output-format json status Tested: cargo run -q -p rusty-claude-cli -- --output-format json sandbox Not-tested: cargo clippy --workspace --all-targets -- -D warnings (fails in pre-existing runtime files unrelated to this change) --- rust/crates/rusty-claude-cli/src/main.rs | 518 +++++++++++++----- .../tests/cli_flags_and_config_defaults.rs | 59 ++ .../tests/resume_slash_commands.rs | 47 ++ 3 files changed, 502 insertions(+), 122 deletions(-) diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rs index 8170072..3d19976 100644 --- a/rust/crates/rusty-claude-cli/src/main.rs +++ b/rust/crates/rusty-claude-cli/src/main.rs @@ -49,7 +49,7 @@ use runtime::{ UsageTracker, }; use serde::Deserialize; -use serde_json::json; +use serde_json::{json, Value}; use tools::{GlobalToolRegistry, RuntimeToolDefinition, ToolSearchOutput}; const DEFAULT_MODEL: &str = "claude-opus-4-6"; @@ -117,12 +117,14 @@ fn run() -> Result<(), Box> { CliAction::ResumeSession { session_path, commands, - } => resume_session(&session_path, &commands), + output_format, + } => resume_session(&session_path, &commands, output_format), CliAction::Status { model, permission_mode, - } => print_status_snapshot(&model, permission_mode)?, - CliAction::Sandbox => print_sandbox_status_snapshot()?, + output_format, + } => print_status_snapshot(&model, permission_mode, output_format)?, + CliAction::Sandbox { output_format } => print_sandbox_status_snapshot(output_format)?, CliAction::Prompt { prompt, model, @@ -165,12 +167,16 @@ enum CliAction { ResumeSession { session_path: PathBuf, commands: Vec, + output_format: CliOutputFormat, }, Status { model: String, permission_mode: PermissionMode, + output_format: CliOutputFormat, + }, + Sandbox { + output_format: CliOutputFormat, }, - Sandbox, Prompt { prompt: String, model: String, @@ -339,9 +345,10 @@ fn parse_args(args: &[String]) -> Result { }); } if rest.first().map(String::as_str) == Some("--resume") { - return parse_resume_args(&rest[1..]); + return parse_resume_args(&rest[1..], output_format); } - if let Some(action) = parse_single_word_command_alias(&rest, &model, permission_mode_override) + if let Some(action) = + parse_single_word_command_alias(&rest, &model, permission_mode_override, output_format) { return action; } @@ -392,6 +399,7 @@ fn parse_single_word_command_alias( rest: &[String], model: &str, permission_mode_override: Option, + output_format: CliOutputFormat, ) -> Option> { if rest.len() != 1 { return None; @@ -403,8 +411,9 @@ fn parse_single_word_command_alias( "status" => Some(Ok(CliAction::Status { model: model.to_string(), permission_mode: permission_mode_override.unwrap_or_else(default_permission_mode), + output_format, })), - "sandbox" => Some(Ok(CliAction::Sandbox)), + "sandbox" => Some(Ok(CliAction::Sandbox { output_format })), other => bare_slash_command_guidance(other).map(Err), } } @@ -698,7 +707,7 @@ fn parse_system_prompt_args(args: &[String]) -> Result { Ok(CliAction::PrintSystemPrompt { cwd, date }) } -fn parse_resume_args(args: &[String]) -> Result { +fn parse_resume_args(args: &[String], output_format: CliOutputFormat) -> Result { let (session_path, command_tokens): (PathBuf, &[String]) = match args.first() { None => (PathBuf::from(LATEST_SESSION_REFERENCE), &[]), Some(first) if looks_like_slash_command_token(first) => { @@ -738,6 +747,7 @@ fn parse_resume_args(args: &[String]) -> Result { Ok(CliAction::ResumeSession { session_path, commands, + output_format, }) } @@ -928,7 +938,7 @@ fn print_version() { println!("{}", render_version_report()); } -fn resume_session(session_path: &Path, commands: &[String]) { +fn resume_session(session_path: &Path, commands: &[String], output_format: CliOutputFormat) { let resolved_path = if session_path.exists() { session_path.to_path_buf() } else { @@ -950,15 +960,31 @@ fn resume_session(session_path: &Path, commands: &[String]) { }; if commands.is_empty() { - println!( - "Restored session from {} ({} messages).", - resolved_path.display(), - session.messages.len() - ); + match output_format { + CliOutputFormat::Text => { + println!( + "Restored session from {} ({} messages).", + resolved_path.display(), + session.messages.len() + ); + } + CliOutputFormat::Json => { + println!( + "{}", + serialize_json_output(&json!({ + "kind": "resume", + "session_file": resolved_path.display().to_string(), + "messages": session.messages.len(), + })) + .unwrap_or_else(|error| format!(r#"{{"kind":"error","message":"{error}"}}"#)) + ); + } + } return; } let mut session = session; + let mut json_outputs = Vec::new(); for raw_command in commands { let command = match SlashCommand::parse(raw_command) { Ok(Some(command)) => command, @@ -971,14 +997,19 @@ fn resume_session(session_path: &Path, commands: &[String]) { std::process::exit(2); } }; - match run_resume_command(&resolved_path, &session, &command) { + match run_resume_command(&resolved_path, &session, &command, output_format) { Ok(ResumeCommandOutcome { session: next_session, message, }) => { session = next_session; if let Some(message) = message { - println!("{message}"); + match output_format { + CliOutputFormat::Text => { + println!("{}", render_resume_text_output(&message)) + } + CliOutputFormat::Json => json_outputs.push(message), + } } } Err(error) => { @@ -987,12 +1018,27 @@ fn resume_session(session_path: &Path, commands: &[String]) { } } } + + if matches!(output_format, CliOutputFormat::Json) { + let payload = if json_outputs.len() == 1 { + json_outputs.pop().expect("single json output") + } else { + Value::Array(json_outputs) + }; + match serialize_json_output(&payload) { + Ok(rendered) => println!("{rendered}"), + Err(error) => { + eprintln!("failed to render json output: {error}"); + std::process::exit(2); + } + } + } } #[derive(Debug, Clone)] struct ResumeCommandOutcome { session: Session, - message: Option, + message: Option, } #[derive(Debug, Clone)] @@ -1317,16 +1363,28 @@ fn parse_git_status_metadata_for( (project_root, branch) } +fn serialize_json_output(value: &Value) -> Result { + serde_json::to_string_pretty(value) +} + +fn render_resume_text_output(value: &Value) -> String { + value.get("message").and_then(Value::as_str).map_or_else( + || serialize_json_output(value).unwrap_or_else(|_| value.to_string()), + ToString::to_string, + ) +} + #[allow(clippy::too_many_lines)] fn run_resume_command( session_path: &Path, session: &Session, command: &SlashCommand, + output_format: CliOutputFormat, ) -> Result> { match command { SlashCommand::Help => Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(render_repl_help()), + message: Some(json!({ "kind": "help", "message": render_repl_help() })), }), SlashCommand::Compact => { let result = runtime::compact_session( @@ -1342,16 +1400,20 @@ fn run_resume_command( result.compacted_session.save_to_path(session_path)?; Ok(ResumeCommandOutcome { session: result.compacted_session, - message: Some(format_compact_report(removed, kept, skipped)), + message: Some(json!({ + "kind": "compact", + "message": format_compact_report(removed, kept, skipped), + })), }) } SlashCommand::Clear { confirm } => { if !confirm { return Ok(ResumeCommandOutcome { session: session.clone(), - message: Some( - "clear: confirmation required; rerun with /clear --confirm".to_string(), - ), + message: Some(json!({ + "kind": "clear", + "message": "clear: confirmation required; rerun with /clear --confirm", + })), }); } let backup_path = write_session_clear_backup(session, session_path)?; @@ -1361,55 +1423,85 @@ fn run_resume_command( cleared.save_to_path(session_path)?; Ok(ResumeCommandOutcome { session: cleared, - message: Some(format!( - "Session cleared\n Mode resumed session reset\n Previous session {previous_session_id}\n Backup {}\n Resume previous claw --resume {}\n New session {new_session_id}\n Session file {}", - backup_path.display(), - backup_path.display(), - session_path.display() - )), + message: Some(json!({ + "kind": "clear", + "message": format!( + "Session cleared\n Mode resumed session reset\n Previous session {previous_session_id}\n Backup {}\n Resume previous claw --resume {}\n New session {new_session_id}\n Session file {}", + backup_path.display(), + backup_path.display(), + session_path.display() + ), + })), }) } SlashCommand::Status => { let tracker = UsageTracker::from_session(session); let usage = tracker.cumulative_usage(); + let status_usage = StatusUsage { + message_count: session.messages.len(), + turns: tracker.turns(), + latest: tracker.current_turn_usage(), + cumulative: usage, + estimated_tokens: 0, + }; + let context = status_context(Some(session_path))?; + let status_json = status_report_json( + "restored-session", + status_usage, + default_permission_mode().as_str(), + &context, + ); Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(format_status_report( - "restored-session", - StatusUsage { - message_count: session.messages.len(), - turns: tracker.turns(), - latest: tracker.current_turn_usage(), - cumulative: usage, - estimated_tokens: 0, - }, - default_permission_mode().as_str(), - &status_context(Some(session_path))?, - )), + message: Some(match output_format { + CliOutputFormat::Text => json!({ + "kind": "status-text", + "message": format_status_report( + "restored-session", + status_usage, + default_permission_mode().as_str(), + &context, + ), + }), + CliOutputFormat::Json => status_json, + }), }) } SlashCommand::Sandbox => { let cwd = env::current_dir()?; let loader = ConfigLoader::default_for(&cwd); let runtime_config = loader.load()?; + let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd); Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(format_sandbox_report(&resolve_sandbox_status( - runtime_config.sandbox(), - &cwd, - ))), + message: Some(match output_format { + CliOutputFormat::Text => json!({ + "kind": "sandbox-text", + "message": format_sandbox_report(&sandbox_status), + }), + CliOutputFormat::Json => json!({ + "kind": "sandbox", + "sandbox": sandbox_status_json(&sandbox_status), + }), + }), }) } SlashCommand::Cost => { let usage = UsageTracker::from_session(session).cumulative_usage(); Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(format_cost_report(usage)), + message: Some(json!({ + "kind": "cost", + "message": format_cost_report(usage), + })), }) } SlashCommand::Config { section } => Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(render_config_report(section.as_deref())?), + message: Some(json!({ + "kind": "config", + "message": render_config_report(section.as_deref())?, + })), }), SlashCommand::Mcp { action, target } => { let cwd = env::current_dir()?; @@ -1421,51 +1513,75 @@ fn run_resume_command( }; Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(handle_mcp_slash_command(args.as_deref(), &cwd)?), + message: Some(json!({ + "kind": "mcp", + "message": handle_mcp_slash_command(args.as_deref(), &cwd)?, + })), }) } SlashCommand::Memory => Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(render_memory_report()?), + message: Some(json!({ + "kind": "memory", + "message": render_memory_report()?, + })), }), SlashCommand::Init => Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(init_claude_md()?), + message: Some(json!({ + "kind": "init", + "message": init_claude_md()?, + })), }), SlashCommand::Diff => Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(render_diff_report_for( - session_path.parent().unwrap_or_else(|| Path::new(".")), - )?), + message: Some(json!({ + "kind": "diff", + "message": render_diff_report_for( + session_path.parent().unwrap_or_else(|| Path::new(".")), + )?, + })), }), SlashCommand::Version => Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(render_version_report()), + message: Some(json!({ + "kind": "version", + "message": render_version_report(), + })), }), SlashCommand::Export { path } => { let export_path = resolve_export_path(path.as_deref(), session)?; fs::write(&export_path, render_export_text(session))?; Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(format!( - "Export\n Result wrote transcript\n File {}\n Messages {}", - export_path.display(), - session.messages.len(), - )), + message: Some(json!({ + "kind": "export", + "message": format!( + "Export\n Result wrote transcript\n File {}\n Messages {}", + export_path.display(), + session.messages.len(), + ), + })), }) } SlashCommand::Agents { args } => { let cwd = env::current_dir()?; Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(handle_agents_slash_command(args.as_deref(), &cwd)?), + message: Some(json!({ + "kind": "agents", + "message": handle_agents_slash_command(args.as_deref(), &cwd)?, + })), }) } SlashCommand::Skills { args } => { let cwd = env::current_dir()?; Ok(ResumeCommandOutcome { session: session.clone(), - message: Some(handle_skills_slash_command(args.as_deref(), &cwd)?), + message: Some(json!({ + "kind": "skills", + "message": handle_skills_slash_command(args.as_deref(), &cwd)?, + })), }) } SlashCommand::Unknown(name) => Err(format_unknown_slash_command(name).into()), @@ -1751,37 +1867,38 @@ impl RuntimeMcpState { .into_iter() .filter(|server_name| !failed_server_names.contains(server_name)) .collect::>(); - let failed_servers = discovery - .failed_servers - .iter() - .map(|failure| runtime::McpFailedServer { - server_name: failure.server_name.clone(), - phase: runtime::McpLifecyclePhase::ToolDiscovery, - error: runtime::McpErrorSurface::new( - runtime::McpLifecyclePhase::ToolDiscovery, - Some(failure.server_name.clone()), - failure.error.clone(), - std::collections::BTreeMap::new(), - true, - ), - }) - .chain(discovery.unsupported_servers.iter().map(|server| { - runtime::McpFailedServer { - server_name: server.server_name.clone(), - phase: runtime::McpLifecyclePhase::ServerRegistration, + let failed_servers = + discovery + .failed_servers + .iter() + .map(|failure| runtime::McpFailedServer { + server_name: failure.server_name.clone(), + phase: runtime::McpLifecyclePhase::ToolDiscovery, error: runtime::McpErrorSurface::new( - runtime::McpLifecyclePhase::ServerRegistration, - Some(server.server_name.clone()), - server.reason.clone(), - std::collections::BTreeMap::from([( - "transport".to_string(), - format!("{:?}", server.transport).to_ascii_lowercase(), - )]), - false, + runtime::McpLifecyclePhase::ToolDiscovery, + Some(failure.server_name.clone()), + failure.error.clone(), + std::collections::BTreeMap::new(), + true, ), - } - })) - .collect::>(); + }) + .chain(discovery.unsupported_servers.iter().map(|server| { + runtime::McpFailedServer { + server_name: server.server_name.clone(), + phase: runtime::McpLifecyclePhase::ServerRegistration, + error: runtime::McpErrorSurface::new( + runtime::McpLifecyclePhase::ServerRegistration, + Some(server.server_name.clone()), + server.reason.clone(), + std::collections::BTreeMap::from([( + "transport".to_string(), + format!("{:?}", server.transport).to_ascii_lowercase(), + )]), + false, + ), + } + })) + .collect::>(); let degraded_report = (!failed_servers.is_empty()).then(|| { runtime::McpDegradedReport::new( working_servers, @@ -3179,22 +3296,31 @@ fn render_repl_help() -> String { fn print_status_snapshot( model: &str, permission_mode: PermissionMode, + output_format: CliOutputFormat, ) -> Result<(), Box> { - println!( - "{}", - format_status_report( - model, - StatusUsage { - message_count: 0, - turns: 0, - latest: TokenUsage::default(), - cumulative: TokenUsage::default(), - estimated_tokens: 0, - }, - permission_mode.as_str(), - &status_context(None)?, - ) - ); + let usage = StatusUsage { + message_count: 0, + turns: 0, + latest: TokenUsage::default(), + cumulative: TokenUsage::default(), + estimated_tokens: 0, + }; + let context = status_context(None)?; + match output_format { + CliOutputFormat::Text => println!( + "{}", + format_status_report(model, usage, permission_mode.as_str(), &context) + ), + CliOutputFormat::Json => println!( + "{}", + serialize_json_output(&status_report_json( + model, + usage, + permission_mode.as_str(), + &context, + ))? + ), + } Ok(()) } @@ -3292,6 +3418,61 @@ fn format_status_report( ) } +fn status_report_json( + model: &str, + usage: StatusUsage, + permission_mode: &str, + context: &StatusContext, +) -> Value { + json!({ + "kind": "status", + "model": model, + "permission_mode": permission_mode, + "messages": usage.message_count, + "turns": usage.turns, + "estimated_tokens": usage.estimated_tokens, + "usage": { + "latest": token_usage_json(usage.latest), + "cumulative": token_usage_json(usage.cumulative), + }, + "workspace": { + "cwd": context.cwd.display().to_string(), + "project_root": context.project_root.as_ref().map(|path| path.display().to_string()), + "git_branch": context.git_branch.clone(), + "git_state": context.git_summary.headline(), + "changed_files": context.git_summary.changed_files, + "staged_files": context.git_summary.staged_files, + "unstaged_files": context.git_summary.unstaged_files, + "untracked_files": context.git_summary.untracked_files, + "session": status_session_label(context.session_path.as_deref()), + "config_files": { + "loaded": context.loaded_config_files, + "discovered": context.discovered_config_files, + }, + "memory_files": context.memory_file_count, + "suggested_flow": ["/status", "/diff", "/commit"], + }, + "sandbox": sandbox_status_json(&context.sandbox_status), + }) +} + +fn token_usage_json(usage: TokenUsage) -> Value { + json!({ + "input_tokens": usage.input_tokens, + "output_tokens": usage.output_tokens, + "cache_creation_input_tokens": usage.cache_creation_input_tokens, + "cache_read_input_tokens": usage.cache_read_input_tokens, + "total_tokens": usage.total_tokens(), + }) +} + +fn status_session_label(session_path: Option<&Path>) -> String { + session_path.map_or_else( + || "live-repl".to_string(), + |path| path.display().to_string(), + ) +} + fn format_sandbox_report(status: &runtime::SandboxStatus) -> String { format!( "Sandbox @@ -3335,6 +3516,31 @@ fn format_sandbox_report(status: &runtime::SandboxStatus) -> String { ) } +fn sandbox_status_json(status: &runtime::SandboxStatus) -> Value { + json!({ + "enabled": status.enabled, + "active": status.active, + "supported": status.supported, + "namespace_supported": status.namespace_supported, + "namespace_active": status.namespace_active, + "network_supported": status.network_supported, + "network_active": status.network_active, + "filesystem_mode": status.filesystem_mode.as_str(), + "filesystem_active": status.filesystem_active, + "allowed_mounts": status.allowed_mounts.clone(), + "in_container": status.in_container, + "container_markers": status.container_markers.clone(), + "fallback_reason": status.fallback_reason.clone(), + "requested": { + "enabled": status.requested.enabled, + "namespace_restrictions": status.requested.namespace_restrictions, + "network_isolation": status.requested.network_isolation, + "filesystem_mode": status.requested.filesystem_mode.as_str(), + "allowed_mounts": status.requested.allowed_mounts.clone(), + } + }) +} + fn format_commit_preflight_report(branch: Option<&str>, summary: GitWorkspaceSummary) -> String { format!( "Commit @@ -3358,16 +3564,25 @@ fn format_commit_skipped_report() -> String { .to_string() } -fn print_sandbox_status_snapshot() -> Result<(), Box> { +fn print_sandbox_status_snapshot( + output_format: CliOutputFormat, +) -> Result<(), Box> { let cwd = env::current_dir()?; let loader = ConfigLoader::default_for(&cwd); let runtime_config = loader .load() .unwrap_or_else(|_| runtime::RuntimeConfig::empty()); - println!( - "{}", - format_sandbox_report(&resolve_sandbox_status(runtime_config.sandbox(), &cwd)) - ); + let sandbox_status = resolve_sandbox_status(runtime_config.sandbox(), &cwd); + match output_format { + CliOutputFormat::Text => println!("{}", format_sandbox_report(&sandbox_status)), + CliOutputFormat::Json => println!( + "{}", + serialize_json_output(&json!({ + "kind": "sandbox", + "sandbox": sandbox_status_json(&sandbox_status), + }))? + ), + } Ok(()) } @@ -5650,12 +5865,12 @@ mod tests { parse_git_status_branch, parse_git_status_metadata_for, parse_git_workspace_summary, permission_policy, print_help_to, push_output_block, render_config_report, render_diff_report, render_diff_report_for, render_memory_report, render_repl_help, - render_resume_usage, resolve_model_alias, resolve_session_reference, response_to_events, - resume_supported_slash_commands, run_resume_command, - slash_command_completion_candidates_with_sessions, status_context, validate_no_args, - write_mcp_server_fixture, CliAction, CliOutputFormat, CliToolExecutor, GitWorkspaceSummary, - InternalPromptProgressEvent, InternalPromptProgressState, LiveCli, SlashCommand, - StatusUsage, DEFAULT_MODEL, + render_resume_text_output, render_resume_usage, resolve_model_alias, + resolve_session_reference, response_to_events, resume_supported_slash_commands, + run_resume_command, slash_command_completion_candidates_with_sessions, status_context, + validate_no_args, write_mcp_server_fixture, CliAction, CliOutputFormat, CliToolExecutor, + GitWorkspaceSummary, InternalPromptProgressEvent, InternalPromptProgressState, LiveCli, + SlashCommand, StatusUsage, DEFAULT_MODEL, }; use api::{MessageResponse, OutputContentBlock, Usage}; use plugins::{ @@ -6063,11 +6278,36 @@ mod tests { CliAction::Status { model: DEFAULT_MODEL.to_string(), permission_mode: PermissionMode::DangerFullAccess, + output_format: CliOutputFormat::Text, } ); assert_eq!( parse_args(&["sandbox".to_string()]).expect("sandbox should parse"), - CliAction::Sandbox + CliAction::Sandbox { + output_format: CliOutputFormat::Text, + } + ); + } + + #[test] + fn parses_json_output_for_status_and_sandbox_aliases() { + let _guard = env_lock(); + std::env::remove_var("RUSTY_CLAUDE_PERMISSION_MODE"); + assert_eq!( + parse_args(&["--output-format=json".to_string(), "status".to_string()]) + .expect("json status should parse"), + CliAction::Status { + model: DEFAULT_MODEL.to_string(), + permission_mode: PermissionMode::DangerFullAccess, + output_format: CliOutputFormat::Json, + } + ); + assert_eq!( + parse_args(&["--output-format=json".to_string(), "sandbox".to_string()]) + .expect("json sandbox should parse"), + CliAction::Sandbox { + output_format: CliOutputFormat::Json, + } ); } @@ -6173,6 +6413,7 @@ mod tests { CliAction::ResumeSession { session_path: PathBuf::from("session.jsonl"), commands: vec!["/compact".to_string()], + output_format: CliOutputFormat::Text, } ); } @@ -6184,6 +6425,7 @@ mod tests { CliAction::ResumeSession { session_path: PathBuf::from("latest"), commands: vec![], + output_format: CliOutputFormat::Text, } ); assert_eq!( @@ -6192,6 +6434,7 @@ mod tests { CliAction::ResumeSession { session_path: PathBuf::from("latest"), commands: vec!["/status".to_string()], + output_format: CliOutputFormat::Text, } ); } @@ -6214,6 +6457,7 @@ mod tests { "/compact".to_string(), "/cost".to_string(), ], + output_format: CliOutputFormat::Text, } ); } @@ -6244,6 +6488,7 @@ mod tests { "/export notes.txt".to_string(), "/clear --confirm".to_string(), ], + output_format: CliOutputFormat::Text, } ); } @@ -6262,6 +6507,25 @@ mod tests { CliAction::ResumeSession { session_path: PathBuf::from("session.jsonl"), commands: vec!["/export /tmp/notes.txt".to_string(), "/status".to_string()], + output_format: CliOutputFormat::Text, + } + ); + } + + #[test] + fn parses_json_output_for_resumed_status_queries() { + let args = vec![ + "--output-format=json".to_string(), + "--resume".to_string(), + "session.jsonl".to_string(), + "/status".to_string(), + ]; + assert_eq!( + parse_args(&args).expect("json resume status should parse"), + CliAction::ResumeSession { + session_path: PathBuf::from("session.jsonl"), + commands: vec!["/status".to_string()], + output_format: CliOutputFormat::Json, } ); } @@ -6782,10 +7046,16 @@ UU conflicted.rs", let session = Session::load_from_path(&session_path).expect("session should load"); let outcome = with_current_dir(&root, || { - run_resume_command(&session_path, &session, &SlashCommand::Diff) - .expect("resume diff should work") + run_resume_command( + &session_path, + &session, + &SlashCommand::Diff, + CliOutputFormat::Text, + ) + .expect("resume diff should work") }); - let message = outcome.message.expect("diff message should exist"); + let message = + render_resume_text_output(&outcome.message.expect("diff message should exist")); assert!(message.contains("Unstaged changes:")); assert!(message.contains("tracked.txt")); @@ -7509,8 +7779,12 @@ UU conflicted.rs", let runtime_config = loader.load().expect("runtime config should load"); let state = build_runtime_plugin_state_with_loader(&workspace, &loader, &runtime_config) .expect("runtime plugin state should load"); - let mut executor = - CliToolExecutor::new(None, false, state.tool_registry.clone(), state.mcp_state.clone()); + let mut executor = CliToolExecutor::new( + None, + false, + state.tool_registry.clone(), + state.mcp_state.clone(), + ); let search_output = executor .execute("ToolSearch", r#"{"query":"remote","max_results":5}"#) diff --git a/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs b/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs index 9d574c4..a1f2422 100644 --- a/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs +++ b/rust/crates/rusty-claude-cli/tests/cli_flags_and_config_defaults.rs @@ -5,6 +5,7 @@ use std::sync::atomic::{AtomicU64, Ordering}; use std::time::{SystemTime, UNIX_EPOCH}; use runtime::Session; +use serde_json::Value; static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0); @@ -37,6 +38,64 @@ fn status_command_applies_model_and_permission_mode_flags() { fs::remove_dir_all(temp_dir).expect("cleanup temp dir"); } +#[test] +fn status_command_emits_structured_json_when_requested() { + // given + let temp_dir = unique_temp_dir("status-json"); + fs::create_dir_all(&temp_dir).expect("temp dir should exist"); + + // when + let output = Command::new(env!("CARGO_BIN_EXE_claw")) + .current_dir(&temp_dir) + .args([ + "--model", + "sonnet", + "--permission-mode", + "read-only", + "--output-format", + "json", + "status", + ]) + .output() + .expect("claw should launch"); + + // then + assert_success(&output); + let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8"); + let parsed: Value = serde_json::from_str(stdout.trim()).expect("status output should be json"); + assert_eq!(parsed["kind"], "status"); + assert_eq!(parsed["model"], "claude-sonnet-4-6"); + assert_eq!(parsed["permission_mode"], "read-only"); + assert_eq!(parsed["workspace"]["session"], "live-repl"); + assert!(parsed["sandbox"].is_object()); + + fs::remove_dir_all(temp_dir).expect("cleanup temp dir"); +} + +#[test] +fn sandbox_command_emits_structured_json_when_requested() { + // given + let temp_dir = unique_temp_dir("sandbox-json"); + fs::create_dir_all(&temp_dir).expect("temp dir should exist"); + + // when + let output = Command::new(env!("CARGO_BIN_EXE_claw")) + .current_dir(&temp_dir) + .args(["--output-format", "json", "sandbox"]) + .output() + .expect("claw should launch"); + + // then + assert_success(&output); + let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8"); + let parsed: Value = serde_json::from_str(stdout.trim()).expect("sandbox output should be json"); + assert_eq!(parsed["kind"], "sandbox"); + assert!(parsed["sandbox"].is_object()); + assert!(parsed["sandbox"]["requested"].is_object()); + + fs::remove_dir_all(temp_dir).expect("cleanup temp dir"); +} + #[test] fn resume_flag_loads_a_saved_session_and_dispatches_status() { // given diff --git a/rust/crates/rusty-claude-cli/tests/resume_slash_commands.rs b/rust/crates/rusty-claude-cli/tests/resume_slash_commands.rs index ccef95f..1d060c2 100644 --- a/rust/crates/rusty-claude-cli/tests/resume_slash_commands.rs +++ b/rust/crates/rusty-claude-cli/tests/resume_slash_commands.rs @@ -7,6 +7,7 @@ use std::time::{SystemTime, UNIX_EPOCH}; use runtime::ContentBlock; use runtime::Session; +use serde_json::Value; static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0); @@ -221,6 +222,52 @@ fn resume_latest_restores_the_most_recent_managed_session() { assert!(stdout.contains(newer_path.to_str().expect("utf8 path"))); } +#[test] +fn resumed_status_command_emits_structured_json_when_requested() { + // given + let temp_dir = unique_temp_dir("resume-status-json"); + fs::create_dir_all(&temp_dir).expect("temp dir should exist"); + let session_path = temp_dir.join("session.jsonl"); + + let mut session = Session::new(); + session + .push_user_text("resume status json fixture") + .expect("session write should succeed"); + session + .save_to_path(&session_path) + .expect("session should persist"); + + // when + let output = run_claw( + &temp_dir, + &[ + "--output-format", + "json", + "--resume", + session_path.to_str().expect("utf8 path"), + "/status", + ], + ); + + // then + assert!( + output.status.success(), + "stdout:\n{}\n\nstderr:\n{}", + String::from_utf8_lossy(&output.stdout), + String::from_utf8_lossy(&output.stderr) + ); + + let stdout = String::from_utf8(output.stdout).expect("stdout should be utf8"); + let parsed: Value = + serde_json::from_str(stdout.trim()).expect("resume status output should be json"); + assert_eq!(parsed["kind"], "status"); + assert_eq!(parsed["messages"], 1); + assert_eq!( + parsed["workspace"]["session"], + session_path.to_str().expect("utf8 path") + ); +} + fn run_claw(current_dir: &Path, args: &[&str]) -> Output { run_claw_with_env(current_dir, args, &[]) }