npcrs 0.1.13

Rust core for the NPC system — agent kernel, jinx executor, LLM client
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
113

use crate::error::{NpcError, Result};
use std::collections::HashMap;
use std::path::Path;

pub fn capture_screenshot(full: bool) -> Result<HashMap<String, String>> {
    let dir = shellexpand::tilde("~/.npcsh/screenshots").to_string();
    std::fs::create_dir_all(&dir).map_err(|e| NpcError::FileLoad {
        path: dir.clone(),
        source: e,
    })?;
    let timestamp = chrono::Local::now().format("%Y%m%d_%H%M%S").to_string();
    let filename = format!("screenshot_{}.png", timestamp);
    let file_path = format!("{}/{}", dir, filename);
    let os = std::env::consts::OS;
    if full {
        match os {
            "macos" => {
                let _ = std::process::Command::new("screencapture")
                    .arg(&file_path)
                    .output();
            }
            "linux" => {
                let tools: &[(&str, &[&str])] = &[
                    ("grim", &[]),
                    ("scrot", &[]),
                    ("import", &["-window", "root"]),
                    ("gnome-screenshot", &["-f"]),
                ];
                let mut took = false;
                for (cmd, extra) in tools {
                    if std::process::Command::new("which")
                        .arg(cmd)
                        .output()
                        .map(|o| o.status.success())
                        .unwrap_or(false)
                    {
                        let mut args: Vec<&str> = extra.to_vec();
                        args.push(&file_path);
                        let _ = std::process::Command::new(cmd).args(&args).output();
                        if Path::new(&file_path).exists() {
                            took = true;
                            break;
                        }
                    }
                }
                if !took {
                    return Err(NpcError::Shell("No screenshot tool found".into()));
                }
            }
            _ => return Err(NpcError::Shell(format!("Unsupported OS: {}", os))),
        }
    } else {
        match os {
            "macos" => {
                let _ = std::process::Command::new("screencapture")
                    .args(["-i", &file_path])
                    .output();
            }
            "linux" => {
                if std::process::Command::new("which")
                    .arg("scrot")
                    .output()
                    .map(|o| o.status.success())
                    .unwrap_or(false)
                {
                    let _ = std::process::Command::new("scrot")
                        .args(["-s", &file_path])
                        .output();
                } else {
                    return Err(NpcError::Shell("No interactive screenshot tool".into()));
                }
            }
            _ => return Err(NpcError::Shell(format!("Unsupported OS: {}", os))),
        }
    }
    if Path::new(&file_path).exists() {
        let mut r = HashMap::new();
        r.insert("filename".into(), filename);
        r.insert("file_path".into(), file_path);
        Ok(r)
    } else {
        Err(NpcError::Shell("Screenshot failed".into()))
    }
}

pub fn compress_image(image_bytes: &[u8], max_width: u32, max_height: u32) -> Result<Vec<u8>> {
    let tmp_in = std::env::temp_dir().join(format!("npc_ci_{}.png", std::process::id()));
    let tmp_out = std::env::temp_dir().join(format!("npc_co_{}.jpg", std::process::id()));
    std::fs::write(&tmp_in, image_bytes).map_err(|e| NpcError::FileLoad {
        path: tmp_in.display().to_string(),
        source: e,
    })?;
    let resize = format!("{}x{}>", max_width, max_height);
    let result = std::process::Command::new("convert")
        .args([
            tmp_in.to_str().unwrap(),
            "-resize",
            &resize,
            "-quality",
            "95",
            tmp_out.to_str().unwrap(),
        ])
        .output();
    let out = match result {
        Ok(o) if o.status.success() && tmp_out.exists() => {
            std::fs::read(&tmp_out).unwrap_or_else(|_| image_bytes.to_vec())
        }
        _ => image_bytes.to_vec(),
    };
    let _ = std::fs::remove_file(&tmp_in);
    let _ = std::fs::remove_file(&tmp_out);
    Ok(out)
}