qualia_mcp/tools/
qapps.rs1use 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
75pub 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
111pub 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
117pub 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
177pub 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}