Enhance ISO build process and documentation for Archipelago

- Updated BUILD-GUIDE.md to clarify instructions for building the Archipelago Auto-Installer ISO, emphasizing the recommended method of building directly on the target server.
- Added auto-installation of missing dependencies (xorriso, podman) when running the build script with sudo.
- Enhanced the build-auto-installer-iso.sh script to capture container images from the live server, ensuring the ISO includes the same set of applications as the dev server.
- Revised deployment documentation to stress the importance of building the Rust backend on the Linux dev server and included new instructions for capturing system-level changes for ISO builds.
- Improved UI components and added new bundled applications (BTCPay Server, Mempool Explorer, Nostr Relay, Strfry Relay, Tailscale) to enhance user experience.

core/archipelago/src/api/handler.rs

@@ -10,6 +10,8 @@ use tokio::sync::broadcast;
 use tokio_tungstenite::tungstenite::Message;
 use tracing::{debug, info};
 
+const CORS_ANY: &str = "*";
+
 pub struct ApiHandler {
     _config: Config,
     rpc_handler: Arc<RpcHandler>,
@@ -53,6 +55,12 @@ impl ApiHandler {
                 .status(StatusCode::OK)
                 .body(hyper::Body::from("OK"))
                 .unwrap()),
+            (Method::GET, path) if path.starts_with("/api/container/logs") => {
+                Self::handle_container_logs_http(self.rpc_handler.clone(), path).await
+            }
+            (Method::GET, path) if path.starts_with("/proxy/lnd/") => {
+                Self::handle_lnd_proxy(path).await
+            }
             _ => Ok(Response::builder()
                 .status(StatusCode::NOT_FOUND)
                 .body(hyper::Body::from("Not Found"))
@@ -60,6 +68,86 @@ impl ApiHandler {
         }
     }
 
+    async fn handle_container_logs_http(
+        rpc: Arc<RpcHandler>,
+        path: &str,
+    ) -> Result<Response<hyper::Body>> {
+        let query = path
+            .strip_prefix("/api/container/logs")
+            .and_then(|s| s.strip_prefix('?'))
+            .unwrap_or("");
+        let params: std::collections::HashMap<String, String> =
+            query
+                .split('&')
+                .filter_map(|p| {
+                    let mut it = p.splitn(2, '=');
+                    let k = it.next()?.to_string();
+                    let v = it.next()?.to_string();
+                    Some((k, v))
+                })
+                .collect();
+        let app_id = params.get("app_id").map(|s| s.as_str()).unwrap_or("lnd");
+        let lines = params
+            .get("lines")
+            .and_then(|s| s.parse::<u32>().ok())
+            .unwrap_or(200);
+
+        match rpc.get_container_logs_value(app_id, lines).await {
+            Ok(value) => {
+                let body = serde_json::json!({ "result": value });
+                let body_bytes = serde_json::to_vec(&body).unwrap_or_default();
+                Ok(Response::builder()
+                    .status(StatusCode::OK)
+                    .header("Content-Type", "application/json")
+                    .header("Access-Control-Allow-Origin", CORS_ANY)
+                    .body(hyper::Body::from(body_bytes))
+                    .unwrap())
+            }
+            Err(e) => {
+                let body = serde_json::json!({ "error": e.to_string() });
+                let body_bytes = serde_json::to_vec(&body).unwrap_or_default();
+                Ok(Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .header("Content-Type", "application/json")
+                    .header("Access-Control-Allow-Origin", CORS_ANY)
+                    .body(hyper::Body::from(body_bytes))
+                    .unwrap())
+            }
+        }
+    }
+
+    async fn handle_lnd_proxy(path: &str) -> Result<Response<hyper::Body>> {
+        let suffix = path.strip_prefix("/proxy/lnd").unwrap_or("/");
+        let url = format!("http://127.0.0.1:8080{}", suffix);
+        match reqwest::get(&url).await {
+            Ok(resp) => {
+                let status = resp.status().as_u16();
+                let headers = resp.headers().clone();
+                let body = resp.bytes().await.unwrap_or_default();
+                let mut builder = Response::builder().status(status);
+                if let Some(ct) = headers.get("content-type") {
+                    if let Ok(s) = ct.to_str() {
+                        builder = builder.header("Content-Type", s);
+                    }
+                }
+                builder
+                    .header("Access-Control-Allow-Origin", CORS_ANY)
+                    .body(hyper::Body::from(body))
+                    .map_err(|e| anyhow::anyhow!("response build: {}", e))
+            }
+            Err(e) => {
+                let body = serde_json::json!({ "error": e.to_string() });
+                let body_bytes = serde_json::to_vec(&body).unwrap_or_default();
+                Ok(Response::builder()
+                    .status(StatusCode::BAD_GATEWAY)
+                    .header("Content-Type", "application/json")
+                    .header("Access-Control-Allow-Origin", CORS_ANY)
+                    .body(hyper::Body::from(body_bytes))
+                    .unwrap())
+            }
+        }
+    }
+
     async fn handle_websocket(
         req: Request<hyper::Body>,
         state_manager: Arc<StateManager>,

core/archipelago/src/api/rpc.rs

@@ -399,6 +399,25 @@ impl RpcHandler {
         Ok(serde_json::to_value(logs)?)
     }
 
+    /// Used by HTTP GET /api/container/logs (same logic as container-logs RPC).
+    pub async fn get_container_logs_value(
+        &self,
+        app_id: &str,
+        lines: u32,
+    ) -> Result<serde_json::Value> {
+        let orchestrator = self
+            .orchestrator
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("Container orchestrator not available (dev mode required)"))?;
+
+        let logs = orchestrator
+            .get_container_logs(app_id, lines)
+            .await
+            .context("Failed to get container logs")?;
+
+        Ok(serde_json::to_value(logs)?)
+    }
+
     async fn handle_container_health(
         &self,
         params: Option<serde_json::Value>,