cc-audit 3.6.0

Security auditor for Claude Code skills, hooks, and MCP servers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Configuration and profile management handlers.

use crate::{CheckArgs, Config, Profile, profile_from_check_args};
use std::fs;
use std::path::Path;
use std::process::ExitCode;

/// Handle `init` subcommand.
pub fn handle_init_config(path: &Path) -> ExitCode {
    let output_path = if path.is_dir() {
        path.join(".cc-audit.yaml")
    } else {
        path.to_path_buf()
    };

    // Check if file already exists
    if output_path.exists() {
        eprintln!(
            "Error: Configuration file already exists at {}",
            output_path.display()
        );
        eprintln!("Remove it first or specify a different path.");
        return ExitCode::from(2);
    }

    let template = Config::generate_template();

    match fs::write(&output_path, &template) {
        Ok(()) => {
            println!(
                "Created configuration file template at {}",
                output_path.display()
            );
            println!("\nYou can customize this file to:");
            println!("  - Set default scan options");
            println!("  - Configure ignore patterns");
            println!("  - Add custom rules");
            println!("  - Define malware signatures");
            ExitCode::SUCCESS
        }
        Err(e) => {
            eprintln!("Error: Failed to write configuration file: {}", e);
            ExitCode::from(2)
        }
    }
}

/// Handle --save-profile command.
pub fn handle_save_profile(args: &CheckArgs, profile_name: &str, verbose: bool) -> ExitCode {
    // Create profile from current check args
    let profile = profile_from_check_args(profile_name, args, verbose);

    match profile.save() {
        Ok(path) => {
            println!("Profile '{}' saved to {}", profile_name, path.display());
            println!("\nUse --profile {} to load these settings.", profile_name);
            ExitCode::SUCCESS
        }
        Err(e) => {
            eprintln!("Failed to save profile: {}", e);
            ExitCode::from(2)
        }
    }
}

/// Handle showing a profile.
pub fn handle_show_profile(profile_name: &str) -> ExitCode {
    match Profile::load(profile_name) {
        Ok(profile) => {
            println!("Profile: {}", profile.name);
            println!("Description: {}", profile.description);
            println!("\nSettings:");
            if let Some(format) = &profile.format {
                println!("  format: {}", format);
            }
            if profile.strict {
                println!("  strict: true");
            }
            if profile.verbose {
                println!("  verbose: true");
            }
            if profile.recursive {
                println!("  recursive: true");
            }
            if profile.ci {
                println!("  ci: true");
            }
            if let Some(scan_type) = &profile.scan_type {
                println!("  scan_type: {}", scan_type);
            }
            if !profile.min_confidence.is_empty() {
                println!("  min_confidence: {}", profile.min_confidence);
            }
            if profile.fix_hint {
                println!("  fix_hint: true");
            }
            ExitCode::SUCCESS
        }
        Err(e) => {
            eprintln!("Failed to load profile '{}': {}", profile_name, e);
            ExitCode::from(2)
        }
    }
}