greentic_setup/
bundle.rs

1//! Bundle directory structure creation and management.
2//!
3//! Handles creating the demo bundle scaffold, writing configuration files,
4//! and managing tenant/team directories.
5
6use std::path::{Path, PathBuf};
7
8use anyhow::{Context, anyhow};
9
10pub const LEGACY_BUNDLE_MARKER: &str = "greentic.demo.yaml";
11pub const BUNDLE_WORKSPACE_MARKER: &str = "bundle.yaml";
12
13/// Create the standard demo bundle directory structure.
14pub fn create_demo_bundle_structure(root: &Path, bundle_name: Option<&str>) -> anyhow::Result<()> {
15    let directories = [
16        "",
17        "providers",
18        "providers/messaging",
19        "providers/events",
20        "providers/secrets",
21        "providers/oauth",
22        "packs",
23        "resolved",
24        "state",
25        "state/resolved",
26        "state/runs",
27        "state/pids",
28        "state/logs",
29        "state/runtime",
30        "state/doctor",
31        "tenants",
32        "tenants/default",
33        "tenants/default/teams",
34        "tenants/demo",
35        "tenants/demo/teams",
36        "tenants/demo/teams/default",
37        "logs",
38    ];
39    for directory in directories {
40        std::fs::create_dir_all(root.join(directory))?;
41    }
42
43    let mut demo_yaml = "version: \"1\"\nproject_root: \"./\"\n".to_string();
44    if let Some(name) = bundle_name.filter(|v| !v.trim().is_empty()) {
45        demo_yaml.push_str(&format!("bundle_name: \"{}\"\n", name.replace('"', "")));
46    }
47    write_if_missing(&root.join(LEGACY_BUNDLE_MARKER), &demo_yaml)?;
48    write_if_missing(
49        &root.join("tenants").join("default").join("tenant.gmap"),
50        "_ = forbidden\n",
51    )?;
52    write_if_missing(
53        &root.join("tenants").join("demo").join("tenant.gmap"),
54        "_ = forbidden\n",
55    )?;
56    write_if_missing(
57        &root
58            .join("tenants")
59            .join("demo")
60            .join("teams")
61            .join("default")
62            .join("team.gmap"),
63        "_ = forbidden\n",
64    )?;
65
66    // Write embedded welcome default.gtpack so the operator has a flow to execute.
67    write_default_pack_if_missing(root);
68
69    Ok(())
70}
71
72/// Embedded quickstart pack bytes (built from `assets/default-welcome.gtpack`).
73///
74/// This pack contains an Adaptive Card menu flow (quickstart demo) using the
75/// adaptive-card component with text + button routing, i18n support, and
76/// Handlebars template rendering for dynamic card content.
77const EMBEDDED_WELCOME_PACK: &[u8] = include_bytes!("../assets/default-welcome.gtpack");
78
79/// Write the embedded welcome pack as `packs/default.gtpack` if not already present.
80fn write_default_pack_if_missing(bundle_root: &Path) {
81    let target = bundle_root.join("packs").join("default.gtpack");
82    if target.exists() {
83        return;
84    }
85    if let Err(err) = std::fs::write(&target, EMBEDDED_WELCOME_PACK) {
86        eprintln!(
87            "  [scaffold] WARNING: failed to write default.gtpack: {}",
88            err,
89        );
90    } else {
91        println!("  [scaffold] created default.gtpack (welcome flow)");
92    }
93}
94
95/// Write a file only if it doesn't already exist.
96pub fn write_if_missing(path: &Path, contents: &str) -> anyhow::Result<()> {
97    if path.exists() {
98        return Ok(());
99    }
100    if let Some(parent) = path.parent() {
101        std::fs::create_dir_all(parent)?;
102    }
103    std::fs::write(path, contents)?;
104    Ok(())
105}
106
107/// Validate that a bundle directory exists and has the expected marker file.
108pub fn validate_bundle_exists(bundle: &Path) -> anyhow::Result<()> {
109    if !bundle.exists() {
110        return Err(anyhow!("bundle path {} does not exist", bundle.display()));
111    }
112    if !is_bundle_root(bundle) {
113        return Err(anyhow!(
114            "bundle {} missing {} or {}",
115            bundle.display(),
116            LEGACY_BUNDLE_MARKER,
117            BUNDLE_WORKSPACE_MARKER,
118        ));
119    }
120    Ok(())
121}
122
123pub fn is_bundle_root(bundle: &Path) -> bool {
124    bundle.join(LEGACY_BUNDLE_MARKER).exists() || bundle.join(BUNDLE_WORKSPACE_MARKER).exists()
125}
126
127/// Compute the gmap file path for a tenant/team in a bundle.
128pub fn gmap_path(bundle: &Path, tenant: &str, team: Option<&str>) -> PathBuf {
129    let mut path = bundle.join("tenants").join(tenant);
130    if let Some(team) = team {
131        path = path.join("teams").join(team).join("team.gmap");
132    } else {
133        path = path.join("tenant.gmap");
134    }
135    path
136}
137
138/// Compute the resolved manifest filename for a tenant/team.
139pub fn resolved_manifest_filename(tenant: &str, team: Option<&str>) -> String {
140    match team {
141        Some(team) => format!("{tenant}.{team}.yaml"),
142        None => format!("{tenant}.yaml"),
143    }
144}
145
146/// Locate a provider's `.gtpack` file in the bundle by provider_id stem.
147pub fn find_provider_pack_path(bundle: &Path, provider_id: &str) -> Option<PathBuf> {
148    for subdir in &["providers/messaging", "providers/events", "packs"] {
149        let candidate = bundle.join(subdir).join(format!("{provider_id}.gtpack"));
150        if candidate.exists() {
151            return Some(candidate);
152        }
153    }
154    None
155}
156
157/// Discover tenants inside the bundle.
158///
159/// Scans `{bundle}/tenants/` for subdirectories and files, returning
160/// tenant names (directory names or file stems without extension).
161///
162/// If `domain` is provided, first checks `{bundle}/{domain}/tenants/`
163/// and falls back to the general `{bundle}/tenants/` directory.
164pub fn discover_tenants(bundle: &Path, domain: Option<&str>) -> anyhow::Result<Vec<String>> {
165    // Try domain-specific tenants directory first
166    if let Some(domain_name) = domain {
167        let domain_dir = bundle.join(domain_name).join("tenants");
168        if let Some(tenants) = read_tenants_from_dir(&domain_dir)? {
169            return Ok(tenants);
170        }
171    }
172
173    // Fall back to general tenants directory
174    let general_dir = bundle.join("tenants");
175    if let Some(tenants) = read_tenants_from_dir(&general_dir)? {
176        return Ok(tenants);
177    }
178
179    Ok(Vec::new())
180}
181
182/// Read tenant names from a directory.
183fn read_tenants_from_dir(dir: &Path) -> anyhow::Result<Option<Vec<String>>> {
184    use std::collections::BTreeSet;
185
186    if !dir.exists() {
187        return Ok(None);
188    }
189
190    let mut tenants = BTreeSet::new();
191    for entry in std::fs::read_dir(dir)? {
192        let entry = entry?;
193        let path = entry.path();
194
195        if path.is_dir() {
196            if let Some(name) = path.file_name().and_then(|v| v.to_str()) {
197                tenants.insert(name.to_string());
198            }
199            continue;
200        }
201
202        if path.is_file()
203            && let Some(stem) = path.file_stem().and_then(|v| v.to_str())
204        {
205            tenants.insert(stem.to_string());
206        }
207    }
208
209    Ok(Some(tenants.into_iter().collect()))
210}
211
212/// Read and parse the provider registry JSON from a bundle.
213pub fn load_provider_registry(bundle: &Path) -> anyhow::Result<serde_json::Value> {
214    let path = bundle.join("providers").join("providers.json");
215    if path.exists() {
216        let raw = std::fs::read_to_string(&path)
217            .with_context(|| format!("read provider registry {}", path.display()))?;
218        serde_json::from_str(&raw)
219            .with_context(|| format!("parse provider registry {}", path.display()))
220    } else {
221        Ok(serde_json::json!({ "providers": [] }))
222    }
223}
224
225/// Write the provider registry JSON to a bundle.
226pub fn write_provider_registry(bundle: &Path, root: &serde_json::Value) -> anyhow::Result<()> {
227    let path = bundle.join("providers").join("providers.json");
228    if let Some(parent) = path.parent() {
229        std::fs::create_dir_all(parent)?;
230    }
231    let payload = serde_json::to_string_pretty(root)
232        .with_context(|| format!("serialize provider registry {}", path.display()))?;
233    std::fs::write(&path, payload).with_context(|| format!("write {}", path.display()))
234}
235
236#[cfg(test)]
237mod tests {
238    use super::*;
239
240    #[test]
241    fn create_bundle_structure() {
242        let temp = tempfile::tempdir().unwrap();
243        let root = temp.path().join("demo-bundle");
244        create_demo_bundle_structure(&root, Some("test")).unwrap();
245        assert!(root.join(LEGACY_BUNDLE_MARKER).exists());
246        assert!(root.join("providers/messaging").exists());
247        assert!(root.join("tenants/demo/teams/default/team.gmap").exists());
248    }
249
250    #[test]
251    fn embedded_welcome_pack_written_when_no_sibling() {
252        let temp = tempfile::tempdir().unwrap();
253        let root = temp.path().join("new-bundle");
254        create_demo_bundle_structure(&root, Some("test")).unwrap();
255        let pack = root.join("packs").join("default.gtpack");
256        assert!(pack.exists(), "embedded welcome pack should be written");
257        assert!(
258            pack.metadata().unwrap().len() > 1000,
259            "pack should not be empty"
260        );
261    }
262
263    #[test]
264    fn embedded_welcome_pack_not_overwritten() {
265        let temp = tempfile::tempdir().unwrap();
266        let root = temp.path().join("existing-bundle");
267        std::fs::create_dir_all(root.join("packs")).unwrap();
268        std::fs::write(root.join("packs").join("default.gtpack"), b"custom").unwrap();
269        create_demo_bundle_structure(&root, Some("test")).unwrap();
270        let contents = std::fs::read(root.join("packs").join("default.gtpack")).unwrap();
271        assert_eq!(
272            contents, b"custom",
273            "existing pack should not be overwritten"
274        );
275    }
276
277    #[test]
278    fn validate_bundle_exists_fails_for_missing() {
279        let result = validate_bundle_exists(Path::new("/nonexistent"));
280        assert!(result.is_err());
281    }
282
283    #[test]
284    fn validate_bundle_exists_accepts_bundle_yaml_workspace() {
285        let temp = tempfile::tempdir().unwrap();
286        let root = temp.path().join("bundle-workspace");
287        std::fs::create_dir_all(&root).unwrap();
288        std::fs::write(root.join(BUNDLE_WORKSPACE_MARKER), "schema_version: 1\n").unwrap();
289
290        validate_bundle_exists(&root).unwrap();
291        assert!(is_bundle_root(&root));
292    }
293
294    #[test]
295    fn gmap_paths() {
296        let p = gmap_path(Path::new("/b"), "demo", None);
297        assert_eq!(p, PathBuf::from("/b/tenants/demo/tenant.gmap"));
298
299        let p = gmap_path(Path::new("/b"), "demo", Some("ops"));
300        assert_eq!(p, PathBuf::from("/b/tenants/demo/teams/ops/team.gmap"));
301    }
302
303    #[test]
304    fn resolved_manifest_filenames() {
305        assert_eq!(resolved_manifest_filename("demo", None), "demo.yaml");
306        assert_eq!(
307            resolved_manifest_filename("demo", Some("ops")),
308            "demo.ops.yaml"
309        );
310    }
311
312    #[test]
313    fn discover_tenants_reads_dirs_and_files() {
314        let bundle = tempfile::tempdir().unwrap();
315        let tenants_dir = bundle.path().join("tenants");
316        std::fs::create_dir_all(tenants_dir.join("alpha")).unwrap();
317        std::fs::write(tenants_dir.join("beta.json"), "{}").unwrap();
318
319        let tenants = discover_tenants(bundle.path(), None).unwrap();
320        assert!(tenants.contains(&"alpha".to_string()));
321        assert!(tenants.contains(&"beta".to_string()));
322    }
323
324    #[test]
325    fn discover_tenants_domain_specific() {
326        let bundle = tempfile::tempdir().unwrap();
327        let domain_dir = bundle.path().join("messaging").join("tenants");
328        std::fs::create_dir_all(domain_dir.join("gamma")).unwrap();
329
330        let tenants = discover_tenants(bundle.path(), Some("messaging")).unwrap();
331        assert_eq!(tenants, vec!["gamma".to_string()]);
332    }
333
334    #[test]
335    fn discover_tenants_falls_back_to_general() {
336        let bundle = tempfile::tempdir().unwrap();
337        let tenants_dir = bundle.path().join("tenants");
338        std::fs::create_dir_all(tenants_dir.join("delta")).unwrap();
339
340        // No domain-specific directory, should fall back
341        let tenants = discover_tenants(bundle.path(), Some("events")).unwrap();
342        assert_eq!(tenants, vec!["delta".to_string()]);
343    }
344}
greentic_setup/bundle.rs

greentic_setup/
bundle.rs
