kreuzberg-cli 4.8.0

Command-line interface for Kreuzberg document intelligence
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Integration tests for server commands (serve and mcp).

#[cfg(not(coverage))]
use std::process::{Command, Stdio};
#[cfg(not(coverage))]
use std::thread;
#[cfg(not(coverage))]
use std::time::Duration;

#[cfg(not(coverage))]
#[test]
#[ignore]
fn test_serve_command_starts() {
    let status = Command::new("cargo")
        .args(["build", "--bin", "kreuzberg", "--features", "all"])
        .status()
        .expect("Failed to build binary");

    assert!(status.success(), "Failed to build kreuzberg binary");

    let mut child = Command::new("./target/debug/kreuzberg")
        .args(["serve", "-H", "127.0.0.1", "-p", "18000"])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start server");

    thread::sleep(Duration::from_secs(3));

    let mut health_response = ureq::get("http://127.0.0.1:18000/health")
        .call()
        .expect("Failed to call health endpoint");

    assert_eq!(health_response.status(), 200);

    let health_json: serde_json::Value = health_response
        .body_mut()
        .read_json()
        .expect("Failed to parse health response");

    assert_eq!(health_json["status"], "healthy");
    assert!(health_json["version"].is_string());

    let mut info_response = ureq::get("http://127.0.0.1:18000/info")
        .call()
        .expect("Failed to call info endpoint");

    assert_eq!(info_response.status(), 200);

    let info_json: serde_json::Value = info_response
        .body_mut()
        .read_json()
        .expect("Failed to parse info response");

    assert!(info_json["rust_backend"].as_bool().unwrap_or(false));

    child.kill().expect("Failed to kill server");
    child.wait().expect("Failed to wait for server");
}

#[cfg(not(coverage))]
#[test]
#[ignore]
fn test_serve_command_with_config() {
    use std::fs;

    let config_content = r#"
use_cache = true
enable_quality_processing = true

[ocr]
backend = "tesseract"
language = "eng"
"#;

    fs::write("test_config.toml", config_content).expect("Failed to write test config");

    let mut child = Command::new("./target/debug/kreuzberg")
        .args(["serve", "-H", "127.0.0.1", "-p", "18001", "-c", "test_config.toml"])
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start server");

    thread::sleep(Duration::from_secs(3));

    let health_response = ureq::get("http://127.0.0.1:18001/health").call();

    assert!(health_response.is_ok(), "Server should be running with custom config");

    child.kill().expect("Failed to kill server");
    child.wait().expect("Failed to wait for server");

    fs::remove_file("test_config.toml").ok();
}

#[cfg(not(coverage))]
#[test]
fn test_serve_command_help() {
    let build_status = Command::new("cargo")
        .args(["build", "--bin", "kreuzberg", "--features", "all"])
        .status()
        .expect("Failed to build binary");

    assert!(build_status.success(), "Failed to build kreuzberg binary");

    let binary_path = env!("CARGO_TARGET_TMPDIR")
        .split("target")
        .next()
        .map(|s| format!("{}target/debug/kreuzberg", s))
        .unwrap_or_else(|| "../target/debug/kreuzberg".to_string());

    let output = Command::new(&binary_path)
        .args(["serve", "--help"])
        .output()
        .expect("Failed to execute command");

    assert!(output.status.success());

    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("Start the API server"));
    assert!(stdout.contains("--host"));
    assert!(stdout.contains("--port"));
    assert!(stdout.contains("--config"));
}

#[cfg(not(coverage))]
#[test]
fn test_mcp_command_help() {
    let build_status = Command::new("cargo")
        .args(["build", "--bin", "kreuzberg", "--features", "all"])
        .status()
        .expect("Failed to build binary");

    assert!(build_status.success(), "Failed to build kreuzberg binary");

    let binary_path = env!("CARGO_TARGET_TMPDIR")
        .split("target")
        .next()
        .map(|s| format!("{}target/debug/kreuzberg", s))
        .unwrap_or_else(|| "../target/debug/kreuzberg".to_string());

    let output = Command::new(&binary_path)
        .args(["mcp", "--help"])
        .output()
        .expect("Failed to execute command");

    assert!(output.status.success());

    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("Start the MCP (Model Context Protocol) server"));
    assert!(stdout.contains("--config"));
}