Initial commit

core/parmanode/src/converter.rs

@@ -0,0 +1,101 @@
+// Parmanode to App Manifest converter
+// Converts Parmanode module structure to Archipelago app manifest format
+
+use archipelago_container::AppManifest;
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+use tokio::fs;
+use tracing::info;
+
+pub struct ParmanodeConverter;
+
+impl ParmanodeConverter {
+    pub fn new() -> Self {
+        Self
+    }
+    
+    /// Convert a Parmanode module directory to an App Manifest
+    pub async fn convert_to_manifest(&self, module_path: &PathBuf) -> Result<AppManifest> {
+        info!("Converting Parmanode module to manifest: {:?}", module_path);
+        
+        // Read Parmanode module metadata if available
+        let module_name = module_path
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("unknown")
+            .to_string();
+        
+        // Try to detect what the module installs
+        let install_script = module_path.join("install.sh");
+        let script_content = if install_script.exists() {
+            fs::read_to_string(&install_script).await.ok()
+        } else {
+            None
+        };
+        
+        // Infer app details from script content
+        let (app_id, image) = self.infer_from_script(&script_content)?;
+        
+        // Create a basic manifest
+        let manifest_yaml = format!(
+            r#"
+app:
+  id: {}
+  name: {}
+  version: 1.0.0
+  description: Converted from Parmanode module
+  
+  container:
+    image: {}
+    pull_policy: if-not-present
+    
+  resources:
+    cpu_limit: 1
+    memory_limit: 512Mi
+    disk_limit: 10Gi
+    
+  security:
+    capabilities: []
+    readonly_root: true
+    network_policy: isolated
+"#,
+            app_id, module_name, image
+        );
+        
+        AppManifest::from_str(&manifest_yaml)
+            .context("Failed to create manifest from Parmanode module")
+    }
+    
+    fn infer_from_script(&self, script_content: &Option<String>) -> Result<(String, String)> {
+        let content = script_content.as_deref().unwrap_or("");
+        
+        // Try to detect Bitcoin Core
+        if content.contains("bitcoind") || content.contains("bitcoin-core") {
+            return Ok(("bitcoin-core".to_string(), "bitcoin/bitcoin:latest".to_string()));
+        }
+        
+        // Try to detect LND
+        if content.contains("lnd") && !content.contains("lightning") {
+            return Ok(("lnd".to_string(), "lightninglabs/lnd:latest".to_string()));
+        }
+        
+        // Try to detect Core Lightning
+        if content.contains("clightning") || content.contains("core-lightning") {
+            return Ok(("core-lightning".to_string(), "elementsproject/lightningd:latest".to_string()));
+        }
+        
+        // Try to detect Electrs
+        if content.contains("electrs") {
+            return Ok(("electrs".to_string(), "romanz/electrs:latest".to_string()));
+        }
+        
+        // Default fallback
+        Ok(("parmanode-module".to_string(), "alpine:latest".to_string()))
+    }
+}
+
+impl Default for ParmanodeConverter {
+    fn default() -> Self {
+        Self::new()
+    }
+}