cosh-tools 0.1.4

Tools crate for cosh - coding agent for the terminal
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
105
106
107
108
109
110
111
112

//! Tests for the `read_asset` action: sandbox enforcement, valid reads, embedded rejection.

use super::super::{
    EmbeddedSkill, SkillAction, SkillError, SkillOutput, SkillSchema, SkillSource, execute,
};
use super::common::{TempDir, list_schema, single_skill};

#[test]
fn read_asset_path_traversal_rejected() {
    let dir = TempDir::new();
    single_skill(dir.path(), "safe", "description: Safe skill\n", "body");

    let result = execute(&SkillSchema {
        action: SkillAction::ReadAsset,
        asset_path: Some("../../../etc/passwd".into()),
        skill_name: Some("safe".into()),
        ..list_schema(dir.path())
    });

    assert!(
        matches!(result, Err(SkillError::PathTraversal(_))),
        "expected PathTraversal error, got: {result:?}"
    );
}

#[test]
fn read_asset_absolute_path_rejected() {
    let dir = TempDir::new();
    single_skill(dir.path(), "safe", "description: Safe skill\n", "body");
    let absolute_asset = dir.path().join("outside-the-skill.md");

    let result = execute(&SkillSchema {
        action: SkillAction::ReadAsset,
        asset_path: Some(absolute_asset.to_string_lossy().into_owned()),
        skill_name: Some("safe".into()),
        ..list_schema(dir.path())
    });

    assert!(
        matches!(result, Err(SkillError::PathTraversal(_))),
        "expected absolute path rejection, got: {result:?}"
    );
}

#[test]
fn read_asset_valid_file_succeeds() {
    let dir = TempDir::new();
    let path = dir.path();
    single_skill(path, "docs", "description: Docs\n", "main body");

    std::fs::write(path.join("docs").join("README.md"), "Hello from README").unwrap();

    let out = execute(&SkillSchema {
        action: SkillAction::ReadAsset,
        asset_path: Some("README.md".into()),
        skill_name: Some("docs".into()),
        ..list_schema(path)
    })
    .expect("read_asset should succeed");

    match out {
        SkillOutput::ReadAsset { content } => {
            assert_eq!(content, "Hello from README");
        }
        _ => panic!("expected ReadAsset output"),
    }
}

#[test]
fn read_asset_nonexistent_file_returns_not_found() {
    let dir = TempDir::new();
    single_skill(dir.path(), "docs", "description: Docs\n", "body");

    let result = execute(&SkillSchema {
        action: SkillAction::ReadAsset,
        asset_path: Some("missing.txt".into()),
        skill_name: Some("docs".into()),
        ..list_schema(dir.path())
    });

    assert!(matches!(result, Err(SkillError::NotFound(_))));
}

#[test]
fn read_asset_embedded_skill_fails() {
    let result = execute(&SkillSchema {
        action: SkillAction::ReadAsset,
        sources: vec![SkillSource::Embedded {
            skill: EmbeddedSkill {
                name: "embedded".into(),
                description: "Embedded".into(),
                content: "---\nname: embedded\n---\nbody".into(),
                globs: Vec::new(),
                always_apply: false,
            },
        }],
        skill_name: Some("embedded".into()),
        asset_path: Some("file.txt".into()),
        ..SkillSchema {
            action: SkillAction::ReadAsset,
            sources: Vec::new(),
            skill_name: None,
            asset_path: None,
            match_paths: Vec::new(),
            recursive: false,
            ignore: Vec::new(),
            include: Vec::new(),
        }
    });

    assert!(matches!(result, Err(SkillError::InvalidAction(_))));
}