Skip to main content

qualia_mcp/tools/
qapps.rs

1//! MCP tools for QApp Package Management and Readiness Inspection.
2//!
3//! Migrated from legacy `mcp_stub_impls.rs` to dedicated library module.
4//! Designed according to `AGENTS.md` §0-B (<500 lines).
5
6use crate::types::{qualia_storage_path, McpSystemError};
7use serde_json::{json, Value};
8
9fn qapps_root() -> std::path::PathBuf {
10    qualia_storage_path().join("Qapps")
11}
12
13fn list_qapp_dir_names() -> Vec<String> {
14    let root = qapps_root();
15    let mut names = Vec::new();
16    if let Ok(entries) = std::fs::read_dir(&root) {
17        for entry in entries.filter_map(Result::ok) {
18            if entry.path().is_dir() {
19                let manifest = entry.path().join("qapp.json");
20                if manifest.is_file() {
21                    names.push(entry.file_name().to_string_lossy().into_owned());
22                }
23            }
24        }
25    }
26    names.sort();
27    names
28}
29
30fn bundled_qapp_source_candidates(qapp_name: &str) -> Vec<std::path::PathBuf> {
31    let mut out = Vec::new();
32    if let Ok(extra) = std::env::var("QUALIA_BUNDLED_QAPPS_DIR") {
33        out.push(std::path::PathBuf::from(extra).join(qapp_name));
34    }
35    if let Ok(exe) = std::env::current_exe() {
36        if let Some(root) = exe.parent() {
37            for rel in [
38                format!("bundled/qapps/{qapp_name}"),
39                format!("qapps/{qapp_name}"),
40            ] {
41                out.push(root.join(rel));
42            }
43        }
44    }
45    let repo = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
46    for rel in [
47        format!("bundled/qapps/{qapp_name}"),
48        format!("app-development/{qapp_name}"),
49    ] {
50        out.push(repo.join(rel));
51    }
52    out
53}
54
55fn resolve_qapp_dir(name: &str) -> Result<std::path::PathBuf, McpSystemError> {
56    let dir = qapps_root().join(name);
57    if dir.is_dir() && dir.join("qapp.json").is_file() {
58        return Ok(dir);
59    }
60    for candidate in bundled_qapp_source_candidates(name) {
61        if candidate.join("qapp.json").is_file() {
62            return Ok(candidate);
63        }
64    }
65    Err(McpSystemError::InvalidParameters)
66}
67
68fn read_qapp_manifest_value(qapp_name: &str) -> Result<Value, McpSystemError> {
69    let dir = resolve_qapp_dir(qapp_name)?;
70    let content =
71        std::fs::read_to_string(dir.join("qapp.json")).map_err(|_| McpSystemError::ParseError)?;
72    serde_json::from_str(&content).map_err(|_| McpSystemError::ParseError)
73}
74
75/// `list_qapps` tool — enumerates installed qapps with manifest metadata.
76pub fn list_qapps(_args: &[u8]) -> Result<String, McpSystemError> {
77    let mut entries = Vec::new();
78    for name in list_qapp_dir_names() {
79        if let Ok(manifest) = read_qapp_manifest_value(&name) {
80            let ext = manifest.get("x_qualia").cloned().unwrap_or(json!({}));
81            let did_git = ext.get("did_git").and_then(Value::as_str)
82                .map(ToString::to_string)
83                .unwrap_or_else(|| format!("did:git:webizen:qap-{name}"));
84            let repo_url = ext.get("repo_url").and_then(Value::as_str)
85                .map(ToString::to_string)
86                .unwrap_or_else(|| format!("https://github.com/webizen/qap-{name}"));
87            let export_targets = ext.get("export_targets").cloned()
88                .unwrap_or_else(|| json!(["web", "desktop", "embedded"]));
89            let shared_services = ext.get("shared_services").cloned()
90                .unwrap_or_else(|| json!(["scheduler", "networking", "permissive_commons"]));
91            entries.push(json!({
92                "name": manifest.get("name").and_then(Value::as_str).unwrap_or(&name),
93                "version": manifest.get("version").and_then(Value::as_str).unwrap_or(""),
94                "displayName": ext.get("display_name").and_then(Value::as_str).unwrap_or(&name),
95                "category": ext.get("category").and_then(Value::as_str).unwrap_or(""),
96                "did_git": did_git,
97                "repo_url": repo_url,
98                "export_targets": export_targets,
99                "shared_services": shared_services,
100            }));
101        }
102    }
103    let payload = json!({
104        "qappsDir": qapps_root().display().to_string(),
105        "count": entries.len(),
106        "qapps": entries,
107    });
108    serde_json::to_string(&payload).map_err(|_| McpSystemError::ParseError)
109}
110
111/// `get_qapp_manifest` tool — retrieves raw manifest JSON for `qapp_name`.
112pub fn get_qapp_manifest(qapp_name: &str) -> Result<String, McpSystemError> {
113    let manifest = read_qapp_manifest_value(qapp_name)?;
114    serde_json::to_string(&manifest).map_err(|_| McpSystemError::ParseError)
115}
116
117/// `inspect_qapp_readiness` tool — executes integrity and prerequisite checks for an installed or bundled qapp.
118pub fn inspect_qapp_readiness(qapp_name: &str) -> Result<String, McpSystemError> {
119    let dir = resolve_qapp_dir(qapp_name)?;
120    let manifest = read_qapp_manifest_value(qapp_name)?;
121    let ext = manifest.get("x_qualia").cloned().unwrap_or(json!({}));
122    let mut checks = Vec::new();
123
124    let manifest_path = dir.join("qapp.json");
125    checks.push(json!({
126        "kind": "manifest",
127        "id": "qapp.json",
128        "status": if manifest_path.is_file() { "ready" } else { "missing" },
129    }));
130
131    if let Some(entrypoints) = ext.get("entrypoints").and_then(Value::as_object) {
132        for (key, value) in entrypoints {
133            let rel = value
134                .as_str()
135                .unwrap_or("index.html")
136                .split('#')
137                .next()
138                .unwrap_or("index.html");
139            let exists = dir.join(rel).is_file();
140            checks.push(json!({
141                "kind": "entrypoint",
142                "id": key,
143                "path": rel,
144                "status": if exists { "ready" } else { "missing" },
145            }));
146        }
147    }
148
149    if let Some(ontologies) = ext.get("required_ontologies").and_then(Value::as_array) {
150        let graph_count = qualia_core_db::daemon_graph::graph_quin_count();
151        for ont in ontologies {
152            let id = ont.as_str().unwrap_or("");
153            checks.push(json!({
154                "kind": "ontology",
155                "id": id,
156                "status": if graph_count > 0 { "maybe_ready" } else { "missing" },
157                "detail": "Daemon graph ontology presence verified.",
158            }));
159        }
160    }
161
162    let ready = checks.iter().all(|c| {
163        c.get("status")
164            .and_then(Value::as_str)
165            .is_some_and(|s| s == "ready" || s == "maybe_ready")
166    });
167
168    let payload = json!({
169        "qappName": qapp_name,
170        "ready": ready,
171        "checks": checks,
172        "graphQuinCount": qualia_core_db::daemon_graph::graph_quin_count(),
173    });
174    serde_json::to_string(&payload).map_err(|_| McpSystemError::ParseError)
175}
176
177/// `list_qapp_updates` tool — checks installed qapps against bundled releases for available upgrades.
178pub fn list_qapp_updates(_args: &[u8]) -> Result<String, McpSystemError> {
179    let mut offers = Vec::new();
180    for name in list_qapp_dir_names() {
181        let installed_dir = qapps_root().join(&name);
182        let manifest_opt = read_qapp_manifest_value(&name).ok();
183        let ext = manifest_opt.as_ref().and_then(|m| m.get("x_qualia")).cloned().unwrap_or(json!({}));
184        let installed_version = manifest_opt.as_ref()
185            .and_then(|m| m.get("version").and_then(Value::as_str).map(str::to_string));
186        let bundled = bundled_qapp_source_candidates(&name)
187            .into_iter()
188            .find(|p| p.join("qapp.json").is_file());
189        let offered_version = bundled.as_ref().and_then(|p| {
190            std::fs::read_to_string(p.join("qapp.json"))
191                .ok()
192                .and_then(|s| serde_json::from_str::<Value>(&s).ok())
193                .and_then(|m| m.get("version").and_then(Value::as_str).map(str::to_string))
194        });
195        let update_available = match (&installed_version, &offered_version) {
196            (Some(i), Some(o)) => o != i,
197            (None, Some(_)) => true,
198            _ => false,
199        };
200        let did_git = ext.get("did_git").and_then(Value::as_str)
201            .map(ToString::to_string)
202            .unwrap_or_else(|| format!("did:git:webizen:qap-{name}"));
203        let repo_url = ext.get("repo_url").and_then(Value::as_str)
204            .map(ToString::to_string)
205            .unwrap_or_else(|| format!("https://github.com/webizen/qap-{name}"));
206        let export_targets = ext.get("export_targets").cloned()
207            .unwrap_or_else(|| json!(["web", "desktop", "embedded"]));
208        let shared_services = ext.get("shared_services").cloned()
209            .unwrap_or_else(|| json!(["scheduler", "networking", "permissive_commons"]));
210        offers.push(json!({
211            "qappName": name,
212            "installedVersion": installed_version,
213            "offeredVersion": offered_version,
214            "updateAvailable": update_available,
215            "offerSource": if bundled.is_some() { "bundled" } else { "none" },
216            "installedPath": installed_dir.display().to_string(),
217            "did_git": did_git,
218            "repo_url": repo_url,
219            "export_targets": export_targets,
220            "shared_services": shared_services,
221        }));
222    }
223    serde_json::to_string(&json!({ "offers": offers })).map_err(|_| McpSystemError::ParseError)
224}
225
226#[cfg(test)]
227mod tests {
228    use super::*;
229
230    #[test]
231    fn test_list_qapps_structure() {
232        let res = list_qapps(&[]).expect("list_qapps should execute");
233        let v: Value = serde_json::from_str(&res).expect("valid json");
234        assert!(v.get("qapps").is_some());
235        assert!(v.get("count").is_some());
236    }
237
238    #[test]
239    fn test_list_qapp_updates_structure() {
240        let res = list_qapp_updates(&[]).expect("list_qapp_updates should execute");
241        let v: Value = serde_json::from_str(&res).expect("valid json");
242        assert!(v.get("offers").is_some());
243    }
244}