@hasna/terminal 2.0.5 → 2.3.0

package/temp/rtk/src/aws_cmd.rs

@@ -0,0 +1,880 @@
+//! AWS CLI output compression.
+//!
+//! Replaces verbose `--output table`/`text` with JSON, then compresses.
+//! Specialized filters for high-frequency commands (STS, S3, EC2, ECS, RDS, CloudFormation).
+
+use crate::json_cmd;
+use crate::tracking;
+use crate::utils::{join_with_overflow, truncate_iso_date};
+use anyhow::{Context, Result};
+use serde_json::Value;
+use std::process::Command;
+
+const MAX_ITEMS: usize = 20;
+const JSON_COMPRESS_DEPTH: usize = 4;
+
+/// Run an AWS CLI command with token-optimized output
+pub fn run(subcommand: &str, args: &[String], verbose: u8) -> Result<()> {
+    // Build the full sub-path: e.g. "sts" + ["get-caller-identity"] -> "sts get-caller-identity"
+    let full_sub = if args.is_empty() {
+        subcommand.to_string()
+    } else {
+        format!("{} {}", subcommand, args.join(" "))
+    };
+
+    // Route to specialized handlers
+    match subcommand {
+        "sts" if !args.is_empty() && args[0] == "get-caller-identity" => {
+            run_sts_identity(&args[1..], verbose)
+        }
+        "s3" if !args.is_empty() && args[0] == "ls" => run_s3_ls(&args[1..], verbose),
+        "ec2" if !args.is_empty() && args[0] == "describe-instances" => {
+            run_ec2_describe(&args[1..], verbose)
+        }
+        "ecs" if !args.is_empty() && args[0] == "list-services" => {
+            run_ecs_list_services(&args[1..], verbose)
+        }
+        "ecs" if !args.is_empty() && args[0] == "describe-services" => {
+            run_ecs_describe_services(&args[1..], verbose)
+        }
+        "rds" if !args.is_empty() && args[0] == "describe-db-instances" => {
+            run_rds_describe(&args[1..], verbose)
+        }
+        "cloudformation" if !args.is_empty() && args[0] == "list-stacks" => {
+            run_cfn_list_stacks(&args[1..], verbose)
+        }
+        "cloudformation" if !args.is_empty() && args[0] == "describe-stacks" => {
+            run_cfn_describe_stacks(&args[1..], verbose)
+        }
+        _ => run_generic(subcommand, args, verbose, &full_sub),
+    }
+}
+
+/// Returns true for operations that return structured JSON (describe-*, list-*, get-*).
+/// Mutating/transfer operations (s3 cp, s3 sync, s3 mb, etc.) emit plain text progress
+/// and do not accept --output json, so we must not inject it for them.
+fn is_structured_operation(args: &[String]) -> bool {
+    let op = args.first().map(|s| s.as_str()).unwrap_or("");
+    op.starts_with("describe-") || op.starts_with("list-") || op.starts_with("get-")
+}
+
+/// Generic strategy: force --output json for structured ops, compress via json_cmd schema
+fn run_generic(subcommand: &str, args: &[String], verbose: u8, full_sub: &str) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    let mut cmd = Command::new("aws");
+    cmd.arg(subcommand);
+
+    let mut has_output_flag = false;
+    for arg in args {
+        if arg == "--output" {
+            has_output_flag = true;
+        }
+        cmd.arg(arg);
+    }
+
+    // Only inject --output json for structured read operations.
+    // Mutating/transfer operations (s3 cp, s3 sync, s3 mb, cloudformation deploy…)
+    // emit plain-text progress and reject --output json.
+    if !has_output_flag && is_structured_operation(args) {
+        cmd.args(["--output", "json"]);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: aws {}", full_sub);
+    }
+
+    let output = cmd.output().context("Failed to run aws CLI")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+    if !output.status.success() {
+        timer.track(
+            &format!("aws {}", full_sub),
+            &format!("rtk aws {}", full_sub),
+            &stderr,
+            &stderr,
+        );
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let filtered = match json_cmd::filter_json_string(&raw, JSON_COMPRESS_DEPTH) {
+        Ok(schema) => {
+            println!("{}", schema);
+            schema
+        }
+        Err(_) => {
+            // Fallback: print raw (maybe not JSON)
+            print!("{}", raw);
+            raw.clone()
+        }
+    };
+
+    timer.track(
+        &format!("aws {}", full_sub),
+        &format!("rtk aws {}", full_sub),
+        &raw,
+        &filtered,
+    );
+
+    Ok(())
+}
+
+fn run_aws_json(
+    sub_args: &[&str],
+    extra_args: &[String],
+    verbose: u8,
+) -> Result<(String, String, std::process::ExitStatus)> {
+    let mut cmd = Command::new("aws");
+    for arg in sub_args {
+        cmd.arg(arg);
+    }
+
+    // Replace --output table/text with --output json
+    let mut skip_next = false;
+    for arg in extra_args {
+        if skip_next {
+            skip_next = false;
+            continue;
+        }
+        if arg == "--output" {
+            skip_next = true;
+            continue;
+        }
+        cmd.arg(arg);
+    }
+    cmd.args(["--output", "json"]);
+
+    let cmd_desc = format!("aws {}", sub_args.join(" "));
+    if verbose > 0 {
+        eprintln!("Running: {}", cmd_desc);
+    }
+
+    let output = cmd
+        .output()
+        .context(format!("Failed to run {}", cmd_desc))?;
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+    if !output.status.success() {
+        eprintln!("{}", stderr.trim());
+    }
+
+    Ok((stdout, stderr, output.status))
+}
+
+fn run_sts_identity(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let (raw, stderr, status) = run_aws_json(&["sts", "get-caller-identity"], extra_args, verbose)?;
+
+    if !status.success() {
+        timer.track(
+            "aws sts get-caller-identity",
+            "rtk aws sts get-caller-identity",
+            &stderr,
+            &stderr,
+        );
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    let filtered = match filter_sts_identity(&raw) {
+        Some(f) => f,
+        None => raw.clone(),
+    };
+    println!("{}", filtered);
+
+    timer.track(
+        "aws sts get-caller-identity",
+        "rtk aws sts get-caller-identity",
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_s3_ls(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+
+    // s3 ls doesn't support --output json, run as-is and filter text
+    let mut cmd = Command::new("aws");
+    cmd.args(["s3", "ls"]);
+    for arg in extra_args {
+        cmd.arg(arg);
+    }
+
+    if verbose > 0 {
+        eprintln!("Running: aws s3 ls {}", extra_args.join(" "));
+    }
+
+    let output = cmd.output().context("Failed to run aws s3 ls")?;
+    let raw = String::from_utf8_lossy(&output.stdout).to_string();
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        timer.track("aws s3 ls", "rtk aws s3 ls", &stderr, &stderr);
+        eprintln!("{}", stderr.trim());
+        std::process::exit(output.status.code().unwrap_or(1));
+    }
+
+    let filtered = filter_s3_ls(&raw);
+    println!("{}", filtered);
+
+    timer.track("aws s3 ls", "rtk aws s3 ls", &raw, &filtered);
+    Ok(())
+}
+
+fn run_ec2_describe(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let (raw, stderr, status) = run_aws_json(&["ec2", "describe-instances"], extra_args, verbose)?;
+
+    if !status.success() {
+        timer.track(
+            "aws ec2 describe-instances",
+            "rtk aws ec2 describe-instances",
+            &stderr,
+            &stderr,
+        );
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    let filtered = match filter_ec2_instances(&raw) {
+        Some(f) => f,
+        None => raw.clone(),
+    };
+    println!("{}", filtered);
+
+    timer.track(
+        "aws ec2 describe-instances",
+        "rtk aws ec2 describe-instances",
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_ecs_list_services(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let (raw, stderr, status) = run_aws_json(&["ecs", "list-services"], extra_args, verbose)?;
+
+    if !status.success() {
+        timer.track(
+            "aws ecs list-services",
+            "rtk aws ecs list-services",
+            &stderr,
+            &stderr,
+        );
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    let filtered = match filter_ecs_list_services(&raw) {
+        Some(f) => f,
+        None => raw.clone(),
+    };
+    println!("{}", filtered);
+
+    timer.track(
+        "aws ecs list-services",
+        "rtk aws ecs list-services",
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_ecs_describe_services(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let (raw, stderr, status) = run_aws_json(&["ecs", "describe-services"], extra_args, verbose)?;
+
+    if !status.success() {
+        timer.track(
+            "aws ecs describe-services",
+            "rtk aws ecs describe-services",
+            &stderr,
+            &stderr,
+        );
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    let filtered = match filter_ecs_describe_services(&raw) {
+        Some(f) => f,
+        None => raw.clone(),
+    };
+    println!("{}", filtered);
+
+    timer.track(
+        "aws ecs describe-services",
+        "rtk aws ecs describe-services",
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_rds_describe(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let (raw, stderr, status) =
+        run_aws_json(&["rds", "describe-db-instances"], extra_args, verbose)?;
+
+    if !status.success() {
+        timer.track(
+            "aws rds describe-db-instances",
+            "rtk aws rds describe-db-instances",
+            &stderr,
+            &stderr,
+        );
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    let filtered = match filter_rds_instances(&raw) {
+        Some(f) => f,
+        None => raw.clone(),
+    };
+    println!("{}", filtered);
+
+    timer.track(
+        "aws rds describe-db-instances",
+        "rtk aws rds describe-db-instances",
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_cfn_list_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let (raw, stderr, status) =
+        run_aws_json(&["cloudformation", "list-stacks"], extra_args, verbose)?;
+
+    if !status.success() {
+        timer.track(
+            "aws cloudformation list-stacks",
+            "rtk aws cloudformation list-stacks",
+            &stderr,
+            &stderr,
+        );
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    let filtered = match filter_cfn_list_stacks(&raw) {
+        Some(f) => f,
+        None => raw.clone(),
+    };
+    println!("{}", filtered);
+
+    timer.track(
+        "aws cloudformation list-stacks",
+        "rtk aws cloudformation list-stacks",
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+fn run_cfn_describe_stacks(extra_args: &[String], verbose: u8) -> Result<()> {
+    let timer = tracking::TimedExecution::start();
+    let (raw, stderr, status) =
+        run_aws_json(&["cloudformation", "describe-stacks"], extra_args, verbose)?;
+
+    if !status.success() {
+        timer.track(
+            "aws cloudformation describe-stacks",
+            "rtk aws cloudformation describe-stacks",
+            &stderr,
+            &stderr,
+        );
+        std::process::exit(status.code().unwrap_or(1));
+    }
+
+    let filtered = match filter_cfn_describe_stacks(&raw) {
+        Some(f) => f,
+        None => raw.clone(),
+    };
+    println!("{}", filtered);
+
+    timer.track(
+        "aws cloudformation describe-stacks",
+        "rtk aws cloudformation describe-stacks",
+        &raw,
+        &filtered,
+    );
+    Ok(())
+}
+
+// --- Filter functions (all use serde_json::Value for resilience) ---
+
+fn filter_sts_identity(json_str: &str) -> Option<String> {
+    let v: Value = serde_json::from_str(json_str).ok()?;
+    let account = v["Account"].as_str().unwrap_or("?");
+    let arn = v["Arn"].as_str().unwrap_or("?");
+    Some(format!("AWS: {} {}", account, arn))
+}
+
+fn filter_s3_ls(output: &str) -> String {
+    let lines: Vec<&str> = output.lines().collect();
+    let total = lines.len();
+    let mut result: Vec<&str> = lines.iter().take(MAX_ITEMS + 10).copied().collect();
+
+    if total > MAX_ITEMS + 10 {
+        result.truncate(MAX_ITEMS + 10);
+        result.push(""); // will be replaced
+        return format!(
+            "{}\n... +{} more items",
+            result[..result.len() - 1].join("\n"),
+            total - MAX_ITEMS - 10
+        );
+    }
+
+    result.join("\n")
+}
+
+fn filter_ec2_instances(json_str: &str) -> Option<String> {
+    let v: Value = serde_json::from_str(json_str).ok()?;
+    let reservations = v["Reservations"].as_array()?;
+
+    let mut instances: Vec<String> = Vec::new();
+    for res in reservations {
+        if let Some(insts) = res["Instances"].as_array() {
+            for inst in insts {
+                let id = inst["InstanceId"].as_str().unwrap_or("?");
+                let state = inst["State"]["Name"].as_str().unwrap_or("?");
+                let itype = inst["InstanceType"].as_str().unwrap_or("?");
+                let ip = inst["PrivateIpAddress"].as_str().unwrap_or("-");
+
+                // Extract Name tag
+                let name = inst["Tags"]
+                    .as_array()
+                    .and_then(|tags| tags.iter().find(|t| t["Key"].as_str() == Some("Name")))
+                    .and_then(|t| t["Value"].as_str())
+                    .unwrap_or("-");
+
+                instances.push(format!("{} {} {} {} ({})", id, state, itype, ip, name));
+            }
+        }
+    }
+
+    let total = instances.len();
+    let mut result = format!("EC2: {} instances\n", total);
+
+    for inst in instances.iter().take(MAX_ITEMS) {
+        result.push_str(&format!("  {}\n", inst));
+    }
+
+    if total > MAX_ITEMS {
+        result.push_str(&format!("  ... +{} more\n", total - MAX_ITEMS));
+    }
+
+    Some(result.trim_end().to_string())
+}
+
+fn filter_ecs_list_services(json_str: &str) -> Option<String> {
+    let v: Value = serde_json::from_str(json_str).ok()?;
+    let arns = v["serviceArns"].as_array()?;
+
+    let mut result = Vec::new();
+    let total = arns.len();
+
+    for arn in arns.iter().take(MAX_ITEMS) {
+        let arn_str = arn.as_str().unwrap_or("?");
+        // Extract short name from ARN: arn:aws:ecs:...:service/cluster/name -> name
+        let short = arn_str.rsplit('/').next().unwrap_or(arn_str);
+        result.push(short.to_string());
+    }
+
+    Some(join_with_overflow(&result, total, MAX_ITEMS, "services"))
+}
+
+fn filter_ecs_describe_services(json_str: &str) -> Option<String> {
+    let v: Value = serde_json::from_str(json_str).ok()?;
+    let services = v["services"].as_array()?;
+
+    let mut result = Vec::new();
+    let total = services.len();
+
+    for svc in services.iter().take(MAX_ITEMS) {
+        let name = svc["serviceName"].as_str().unwrap_or("?");
+        let status = svc["status"].as_str().unwrap_or("?");
+        let running = svc["runningCount"].as_i64().unwrap_or(0);
+        let desired = svc["desiredCount"].as_i64().unwrap_or(0);
+        let launch = svc["launchType"].as_str().unwrap_or("?");
+        result.push(format!(
+            "{} {} {}/{} ({})",
+            name, status, running, desired, launch
+        ));
+    }
+
+    Some(join_with_overflow(&result, total, MAX_ITEMS, "services"))
+}
+
+fn filter_rds_instances(json_str: &str) -> Option<String> {
+    let v: Value = serde_json::from_str(json_str).ok()?;
+    let dbs = v["DBInstances"].as_array()?;
+
+    let mut result = Vec::new();
+    let total = dbs.len();
+
+    for db in dbs.iter().take(MAX_ITEMS) {
+        let name = db["DBInstanceIdentifier"].as_str().unwrap_or("?");
+        let engine = db["Engine"].as_str().unwrap_or("?");
+        let version = db["EngineVersion"].as_str().unwrap_or("?");
+        let class = db["DBInstanceClass"].as_str().unwrap_or("?");
+        let status = db["DBInstanceStatus"].as_str().unwrap_or("?");
+        result.push(format!(
+            "{} {} {} {} {}",
+            name, engine, version, class, status
+        ));
+    }
+
+    Some(join_with_overflow(&result, total, MAX_ITEMS, "instances"))
+}
+
+fn filter_cfn_list_stacks(json_str: &str) -> Option<String> {
+    let v: Value = serde_json::from_str(json_str).ok()?;
+    let stacks = v["StackSummaries"].as_array()?;
+
+    let mut result = Vec::new();
+    let total = stacks.len();
+
+    for stack in stacks.iter().take(MAX_ITEMS) {
+        let name = stack["StackName"].as_str().unwrap_or("?");
+        let status = stack["StackStatus"].as_str().unwrap_or("?");
+        let date = stack["LastUpdatedTime"]
+            .as_str()
+            .or_else(|| stack["CreationTime"].as_str())
+            .unwrap_or("?");
+        result.push(format!("{} {} {}", name, status, truncate_iso_date(date)));
+    }
+
+    Some(join_with_overflow(&result, total, MAX_ITEMS, "stacks"))
+}
+
+fn filter_cfn_describe_stacks(json_str: &str) -> Option<String> {
+    let v: Value = serde_json::from_str(json_str).ok()?;
+    let stacks = v["Stacks"].as_array()?;
+
+    let mut result = Vec::new();
+    let total = stacks.len();
+
+    for stack in stacks.iter().take(MAX_ITEMS) {
+        let name = stack["StackName"].as_str().unwrap_or("?");
+        let status = stack["StackStatus"].as_str().unwrap_or("?");
+        let date = stack["LastUpdatedTime"]
+            .as_str()
+            .or_else(|| stack["CreationTime"].as_str())
+            .unwrap_or("?");
+        result.push(format!("{} {} {}", name, status, truncate_iso_date(date)));
+
+        // Show outputs if present
+        if let Some(outputs) = stack["Outputs"].as_array() {
+            for out in outputs {
+                let key = out["OutputKey"].as_str().unwrap_or("?");
+                let val = out["OutputValue"].as_str().unwrap_or("?");
+                result.push(format!("  {}={}", key, val));
+            }
+        }
+    }
+
+    Some(join_with_overflow(&result, total, MAX_ITEMS, "stacks"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_snapshot_sts_identity() {
+        let json = r#"{
+    "UserId": "AIDAEXAMPLEUSERID1234",
+    "Account": "123456789012",
+    "Arn": "arn:aws:iam::123456789012:user/dev-user"
+}"#;
+        let result = filter_sts_identity(json).unwrap();
+        assert_eq!(
+            result,
+            "AWS: 123456789012 arn:aws:iam::123456789012:user/dev-user"
+        );
+    }
+
+    #[test]
+    fn test_snapshot_ec2_instances() {
+        let json = r#"{"Reservations":[{"Instances":[{"InstanceId":"i-0a1b2c3d4e5f00001","InstanceType":"t3.micro","PrivateIpAddress":"10.0.1.10","State":{"Code":16,"Name":"running"},"Tags":[{"Key":"Name","Value":"web-server-1"}],"BlockDeviceMappings":[],"SecurityGroups":[]},{"InstanceId":"i-0a1b2c3d4e5f00002","InstanceType":"t3.large","PrivateIpAddress":"10.0.2.20","State":{"Code":80,"Name":"stopped"},"Tags":[{"Key":"Name","Value":"worker-1"}],"BlockDeviceMappings":[],"SecurityGroups":[]}]}]}"#;
+        let result = filter_ec2_instances(json).unwrap();
+        assert!(result.contains("EC2: 2 instances"));
+        assert!(result.contains("i-0a1b2c3d4e5f00001 running t3.micro 10.0.1.10 (web-server-1)"));
+        assert!(result.contains("i-0a1b2c3d4e5f00002 stopped t3.large 10.0.2.20 (worker-1)"));
+    }
+
+    #[test]
+    fn test_filter_sts_identity() {
+        let json = r#"{
+            "UserId": "AIDAEXAMPLE",
+            "Account": "123456789012",
+            "Arn": "arn:aws:iam::123456789012:user/dev"
+        }"#;
+        let result = filter_sts_identity(json).unwrap();
+        assert_eq!(
+            result,
+            "AWS: 123456789012 arn:aws:iam::123456789012:user/dev"
+        );
+    }
+
+    #[test]
+    fn test_filter_sts_identity_missing_fields() {
+        let json = r#"{}"#;
+        let result = filter_sts_identity(json).unwrap();
+        assert_eq!(result, "AWS: ? ?");
+    }
+
+    #[test]
+    fn test_filter_sts_identity_invalid_json() {
+        let result = filter_sts_identity("not json");
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_filter_s3_ls_basic() {
+        let output = "2024-01-01 bucket1\n2024-01-02 bucket2\n2024-01-03 bucket3\n";
+        let result = filter_s3_ls(output);
+        assert!(result.contains("bucket1"));
+        assert!(result.contains("bucket3"));
+    }
+
+    #[test]
+    fn test_filter_s3_ls_overflow() {
+        let mut lines = Vec::new();
+        for i in 1..=50 {
+            lines.push(format!("2024-01-01 bucket{}", i));
+        }
+        let input = lines.join("\n");
+        let result = filter_s3_ls(&input);
+        assert!(result.contains("... +20 more items"));
+    }
+
+    #[test]
+    fn test_filter_ec2_instances() {
+        let json = r#"{
+            "Reservations": [{
+                "Instances": [{
+                    "InstanceId": "i-abc123",
+                    "State": {"Name": "running"},
+                    "InstanceType": "t3.micro",
+                    "PrivateIpAddress": "10.0.1.5",
+                    "Tags": [{"Key": "Name", "Value": "web-server"}]
+                }, {
+                    "InstanceId": "i-def456",
+                    "State": {"Name": "stopped"},
+                    "InstanceType": "t3.large",
+                    "PrivateIpAddress": "10.0.1.6",
+                    "Tags": [{"Key": "Name", "Value": "worker"}]
+                }]
+            }]
+        }"#;
+        let result = filter_ec2_instances(json).unwrap();
+        assert!(result.contains("EC2: 2 instances"));
+        assert!(result.contains("i-abc123 running t3.micro 10.0.1.5 (web-server)"));
+        assert!(result.contains("i-def456 stopped t3.large 10.0.1.6 (worker)"));
+    }
+
+    #[test]
+    fn test_filter_ec2_no_name_tag() {
+        let json = r#"{
+            "Reservations": [{
+                "Instances": [{
+                    "InstanceId": "i-abc123",
+                    "State": {"Name": "running"},
+                    "InstanceType": "t3.micro",
+                    "PrivateIpAddress": "10.0.1.5",
+                    "Tags": []
+                }]
+            }]
+        }"#;
+        let result = filter_ec2_instances(json).unwrap();
+        assert!(result.contains("(-)"));
+    }
+
+    #[test]
+    fn test_filter_ec2_invalid_json() {
+        assert!(filter_ec2_instances("not json").is_none());
+    }
+
+    #[test]
+    fn test_filter_ecs_list_services() {
+        let json = r#"{
+            "serviceArns": [
+                "arn:aws:ecs:us-east-1:123:service/cluster/api-service",
+                "arn:aws:ecs:us-east-1:123:service/cluster/worker-service"
+            ]
+        }"#;
+        let result = filter_ecs_list_services(json).unwrap();
+        assert!(result.contains("api-service"));
+        assert!(result.contains("worker-service"));
+        assert!(!result.contains("arn:aws"));
+    }
+
+    #[test]
+    fn test_filter_ecs_describe_services() {
+        let json = r#"{
+            "services": [{
+                "serviceName": "api",
+                "status": "ACTIVE",
+                "runningCount": 3,
+                "desiredCount": 3,
+                "launchType": "FARGATE"
+            }]
+        }"#;
+        let result = filter_ecs_describe_services(json).unwrap();
+        assert_eq!(result, "api ACTIVE 3/3 (FARGATE)");
+    }
+
+    #[test]
+    fn test_filter_rds_instances() {
+        let json = r#"{
+            "DBInstances": [{
+                "DBInstanceIdentifier": "mydb",
+                "Engine": "postgres",
+                "EngineVersion": "15.4",
+                "DBInstanceClass": "db.t3.micro",
+                "DBInstanceStatus": "available"
+            }]
+        }"#;
+        let result = filter_rds_instances(json).unwrap();
+        assert_eq!(result, "mydb postgres 15.4 db.t3.micro available");
+    }
+
+    #[test]
+    fn test_filter_cfn_list_stacks() {
+        let json = r#"{
+            "StackSummaries": [{
+                "StackName": "my-stack",
+                "StackStatus": "CREATE_COMPLETE",
+                "CreationTime": "2024-01-15T10:30:00Z"
+            }, {
+                "StackName": "other-stack",
+                "StackStatus": "UPDATE_COMPLETE",
+                "LastUpdatedTime": "2024-02-20T14:00:00Z",
+                "CreationTime": "2024-01-01T00:00:00Z"
+            }]
+        }"#;
+        let result = filter_cfn_list_stacks(json).unwrap();
+        assert!(result.contains("my-stack CREATE_COMPLETE 2024-01-15"));
+        assert!(result.contains("other-stack UPDATE_COMPLETE 2024-02-20"));
+    }
+
+    #[test]
+    fn test_filter_cfn_describe_stacks_with_outputs() {
+        let json = r#"{
+            "Stacks": [{
+                "StackName": "my-stack",
+                "StackStatus": "CREATE_COMPLETE",
+                "CreationTime": "2024-01-15T10:30:00Z",
+                "Outputs": [
+                    {"OutputKey": "ApiUrl", "OutputValue": "https://api.example.com"},
+                    {"OutputKey": "BucketName", "OutputValue": "my-bucket"}
+                ]
+            }]
+        }"#;
+        let result = filter_cfn_describe_stacks(json).unwrap();
+        assert!(result.contains("my-stack CREATE_COMPLETE 2024-01-15"));
+        assert!(result.contains("ApiUrl=https://api.example.com"));
+        assert!(result.contains("BucketName=my-bucket"));
+    }
+
+    #[test]
+    fn test_filter_cfn_describe_stacks_no_outputs() {
+        let json = r#"{
+            "Stacks": [{
+                "StackName": "my-stack",
+                "StackStatus": "CREATE_COMPLETE",
+                "CreationTime": "2024-01-15T10:30:00Z"
+            }]
+        }"#;
+        let result = filter_cfn_describe_stacks(json).unwrap();
+        assert!(result.contains("my-stack CREATE_COMPLETE 2024-01-15"));
+        assert!(!result.contains("="));
+    }
+
+    fn count_tokens(text: &str) -> usize {
+        text.split_whitespace().count()
+    }
+
+    #[test]
+    fn test_ec2_token_savings() {
+        let json = r#"{
+    "Reservations": [{
+        "ReservationId": "r-001",
+        "OwnerId": "123456789012",
+        "Groups": [],
+        "Instances": [{
+            "InstanceId": "i-0a1b2c3d4e5f00001",
+            "ImageId": "ami-0abcdef1234567890",
+            "InstanceType": "t3.micro",
+            "KeyName": "my-key-pair",
+            "LaunchTime": "2024-01-15T10:30:00+00:00",
+            "Placement": { "AvailabilityZone": "us-east-1a", "GroupName": "", "Tenancy": "default" },
+            "PrivateDnsName": "ip-10-0-1-10.ec2.internal",
+            "PrivateIpAddress": "10.0.1.10",
+            "PublicDnsName": "ec2-54-0-0-10.compute-1.amazonaws.com",
+            "PublicIpAddress": "54.0.0.10",
+            "State": { "Code": 16, "Name": "running" },
+            "SubnetId": "subnet-0abc123def456001",
+            "VpcId": "vpc-0abc123def456001",
+            "Architecture": "x86_64",
+            "BlockDeviceMappings": [{ "DeviceName": "/dev/xvda", "Ebs": { "AttachTime": "2024-01-15T10:30:05+00:00", "DeleteOnTermination": true, "Status": "attached", "VolumeId": "vol-001" } }],
+            "EbsOptimized": false,
+            "EnaSupport": true,
+            "Hypervisor": "xen",
+            "NetworkInterfaces": [{ "NetworkInterfaceId": "eni-001", "PrivateIpAddress": "10.0.1.10", "Status": "in-use" }],
+            "RootDeviceName": "/dev/xvda",
+            "RootDeviceType": "ebs",
+            "SecurityGroups": [{ "GroupId": "sg-001", "GroupName": "web-server-sg" }],
+            "SourceDestCheck": true,
+            "Tags": [{ "Key": "Name", "Value": "web-server-1" }, { "Key": "Environment", "Value": "production" }, { "Key": "Team", "Value": "backend" }],
+            "VirtualizationType": "hvm",
+            "CpuOptions": { "CoreCount": 1, "ThreadsPerCore": 2 },
+            "MetadataOptions": { "State": "applied", "HttpTokens": "required", "HttpEndpoint": "enabled" }
+        }]
+    }]
+}"#;
+        let result = filter_ec2_instances(json).unwrap();
+        let input_tokens = count_tokens(json);
+        let output_tokens = count_tokens(&result);
+        let savings = 100.0 - (output_tokens as f64 / input_tokens as f64 * 100.0);
+        assert!(
+            savings >= 60.0,
+            "EC2 filter: expected >=60% savings, got {:.1}%",
+            savings
+        );
+    }
+
+    #[test]
+    fn test_sts_token_savings() {
+        let json = r#"{
+    "UserId": "AIDAEXAMPLEUSERID1234",
+    "Account": "123456789012",
+    "Arn": "arn:aws:iam::123456789012:user/dev-user"
+}"#;
+        let result = filter_sts_identity(json).unwrap();
+        let input_tokens = count_tokens(json);
+        let output_tokens = count_tokens(&result);
+        let savings = 100.0 - (output_tokens as f64 / input_tokens as f64 * 100.0);
+        assert!(
+            savings >= 60.0,
+            "STS identity filter: expected >=60% savings, got {:.1}%",
+            savings
+        );
+    }
+
+    #[test]
+    fn test_rds_overflow() {
+        let mut dbs = Vec::new();
+        for i in 1..=25 {
+            dbs.push(format!(
+                r#"{{"DBInstanceIdentifier": "db-{}", "Engine": "postgres", "EngineVersion": "15.4", "DBInstanceClass": "db.t3.micro", "DBInstanceStatus": "available"}}"#,
+                i
+            ));
+        }
+        let json = format!(r#"{{"DBInstances": [{}]}}"#, dbs.join(","));
+        let result = filter_rds_instances(&json).unwrap();
+        assert!(result.contains("... +5 more instances"));
+    }
+}