create-ekka-desktop-app 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-ekka-desktop-app",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Create an EKKA desktop app with built-in demo backend. No setup required.",
   "type": "module",
   "bin": {

package/template/src-tauri/Cargo.toml

@@ -10,6 +10,7 @@ edition = "2021"
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
+dotenvy = "0.15"
 
 [dependencies]
 tauri = { version = "2", features = [] }

package/template/src-tauri/build.rs

@@ -1,3 +1,49 @@
 fn main() {
+    // Rerun if env files change (check both src-tauri and project root)
+    println!("cargo:rerun-if-changed=.env");
+    println!("cargo:rerun-if-changed=.env.local");
+    println!("cargo:rerun-if-changed=../.env");
+    println!("cargo:rerun-if-changed=../.env.local");
+
+    // Load env files: try src-tauri first, then project root
+    // .env.local takes precedence over .env
+    let _ = dotenvy::from_filename(".env.local");
+    let _ = dotenvy::from_filename(".env");
+    let _ = dotenvy::from_filename("../.env.local");
+    let _ = dotenvy::from_filename("../.env");
+
+    // EKKA_ENGINE_URL is required at build time
+    let engine_url = std::env::var("EKKA_ENGINE_URL").unwrap_or_else(|_| {
+        panic!(
+            "\n\n\
+            ╔══════════════════════════════════════════════════════════════════╗\n\
+            ║  BUILD ERROR: EKKA_ENGINE_URL is not set                         ║\n\
+            ╠══════════════════════════════════════════════════════════════════╣\n\
+            ║  Add EKKA_ENGINE_URL to .env.local or .env before building:      ║\n\
+            ║                                                                  ║\n\
+            ║    echo 'EKKA_ENGINE_URL=https://api.ekka.ai' >> .env.local      ║\n\
+            ║                                                                  ║\n\
+            ╚══════════════════════════════════════════════════════════════════╝\n\n"
+        )
+    });
+
+    if engine_url.trim().is_empty() {
+        panic!(
+            "\n\n\
+            ╔══════════════════════════════════════════════════════════════════╗\n\
+            ║  BUILD ERROR: EKKA_ENGINE_URL is empty                           ║\n\
+            ╠══════════════════════════════════════════════════════════════════╣\n\
+            ║  Set a valid URL in .env.local or .env:                          ║\n\
+            ║                                                                  ║\n\
+            ║    EKKA_ENGINE_URL=https://api.ekka.ai                           ║\n\
+            ║                                                                  ║\n\
+            ╚══════════════════════════════════════════════════════════════════╝\n\n"
+        )
+    }
+
+    // Bake EKKA_ENGINE_URL into the binary at compile time
+    println!("cargo:rustc-env=EKKA_ENGINE_URL={}", engine_url);
+
+    // Continue with tauri build
     tauri_build::build()
 }

package/template/src-tauri/src/commands.rs

@@ -455,9 +455,10 @@ fn handle_node_credentials_clear() -> EngineResponse {
 fn handle_runner_task_stats(state: &EngineState) -> EngineResponse {
     use crate::state::NodeAuthState;
 
-    // Get engine URL (needed for both auth and stats request)
-    let engine_url = std::env::var("EKKA_ENGINE_URL")
-        .unwrap_or_else(|_| "https://api.ekka.ai".to_string());
+    // Get engine URL (baked at build time)
+    let engine_url = option_env!("EKKA_ENGINE_URL")
+        .unwrap_or("https://api.ekka.ai")
+        .to_string();
 
     // Get node auth token for Authorization header
     let node_token = match state.get_node_auth_token() {
@@ -819,8 +820,9 @@ fn handle_bootstrap_node_session(payload: &Value, state: &EngineState) -> Engine
     if start_runner {
         // Build runner config from node auth token
         let runner_config = node_auth::NodeSessionRunnerConfig {
-            engine_url: std::env::var("EKKA_ENGINE_URL")
-                .or_else(|_| std::env::var("ENGINE_URL"))
+            engine_url: option_env!("EKKA_ENGINE_URL")
+                .map(|s| s.to_string())
+                .or_else(|| std::env::var("ENGINE_URL").ok())
                 .unwrap_or_default(),
             node_url: std::env::var("NODE_URL").unwrap_or_else(|_| "http://127.0.0.1:7777".to_string()),
             session_token: node_token.token.clone(),
@@ -913,8 +915,9 @@ fn build_security_headers(jwt: Option<&str>, module: &str, action: &str) -> Vec<
 
 /// Create a workflow run (POST /engine/workflow-runs)
 fn handle_workflow_runs_create(payload: &Value) -> EngineResponse {
-    let engine_url = std::env::var("EKKA_ENGINE_URL")
-        .unwrap_or_else(|_| "http://localhost:3200".to_string());
+    let engine_url = option_env!("EKKA_ENGINE_URL")
+        .unwrap_or("http://localhost:3200")
+        .to_string();
 
     // Extract request body
     let request = match payload.get("request") {
@@ -974,8 +977,9 @@ fn handle_workflow_runs_create(payload: &Value) -> EngineResponse {
 
 /// Get a workflow run (GET /engine/workflow-runs/{id})
 fn handle_workflow_runs_get(payload: &Value) -> EngineResponse {
-    let engine_url = std::env::var("EKKA_ENGINE_URL")
-        .unwrap_or_else(|_| "http://localhost:3200".to_string());
+    let engine_url = option_env!("EKKA_ENGINE_URL")
+        .unwrap_or("http://localhost:3200")
+        .to_string();
 
     // Extract workflow run ID
     let id = match payload.get("id").and_then(|v| v.as_str()) {

package/template/src-tauri/src/engine_process.rs

@@ -46,9 +46,9 @@ fn build_engine_env() -> Result<Vec<(&'static str, String)>, &'static str> {
     // EKKA_RUNNER_MODE=engine (always set)
     env.push(("EKKA_RUNNER_MODE", "engine".to_string()));
 
-    // EKKA_ENGINE_URL - pass through from process env or use default
-    if let Ok(url) = std::env::var("EKKA_ENGINE_URL") {
-        env.push(("EKKA_ENGINE_URL", url));
+    // EKKA_ENGINE_URL - baked at build time
+    if let Some(url) = option_env!("EKKA_ENGINE_URL") {
+        env.push(("EKKA_ENGINE_URL", url.to_string()));
     }
 
     // EKKA_INTERNAL_SERVICE_KEY - required for engine mode

package/template/src-tauri/src/main.rs

@@ -74,6 +74,14 @@ fn main() {
                 "Required security env vars"
             );
 
+            // Log build-time baked engine URL presence (not the URL itself)
+            let engine_url_baked = option_env!("EKKA_ENGINE_URL").is_some();
+            tracing::info!(
+                op = "desktop.engine_url.baked",
+                present = engine_url_baked,
+                "EKKA_ENGINE_URL baked at build time"
+            );
+
             // Check for stored node credentials (vault-backed)
             let has_creds = node_credentials::has_credentials();
 
@@ -112,13 +120,14 @@ fn main() {
                 }
 
                 // Authenticate node with server before spawning engine
-                let engine_url = match std::env::var("EKKA_ENGINE_URL") {
-                    Ok(url) => url,
-                    Err(_) => {
+                // EKKA_ENGINE_URL is baked at build time via build.rs
+                let engine_url = match option_env!("EKKA_ENGINE_URL") {
+                    Some(url) => url.to_string(),
+                    None => {
                         tracing::warn!(
                             op = "desktop.engine.start.blocked",
                             reason = "missing_engine_url",
-                            "Engine start blocked - EKKA_ENGINE_URL not set"
+                            "Engine start blocked - EKKA_ENGINE_URL not baked at build time"
                         );
                         return;
                     }

package/template/src-tauri/src/node_auth.rs

@@ -770,9 +770,11 @@ pub struct NodeSessionRunnerConfig {
 
 impl NodeSessionRunnerConfig {
     pub fn from_session(session: &NodeSession, node_id: Uuid) -> Result<Self, String> {
-        let engine_url = std::env::var("ENGINE_URL")
-            .or_else(|_| std::env::var("EKKA_ENGINE_URL"))
-            .map_err(|_| "ENGINE_URL or EKKA_ENGINE_URL required")?;
+        // EKKA_ENGINE_URL baked at build time, ENGINE_URL as runtime fallback
+        let engine_url = option_env!("EKKA_ENGINE_URL")
+            .map(|s| s.to_string())
+            .or_else(|| std::env::var("ENGINE_URL").ok())
+            .ok_or("EKKA_ENGINE_URL not baked at build time and ENGINE_URL not set")?;
 
         let node_url = std::env::var("NODE_URL").unwrap_or_else(|_| "http://127.0.0.1:7777".to_string());
 

package/template/src-tauri/src/ops/home.rs

@@ -80,13 +80,13 @@ pub fn handle_grant(state: &EngineState) -> EngineResponse {
         None => return EngineResponse::err("MARKER_INVALID", "Marker missing instance_id"),
     };
 
-    // 4. Get engine URL
-    let engine_url = match std::env::var("EKKA_ENGINE_URL") {
-        Ok(u) => u,
-        Err(_) => {
+    // 4. Get engine URL (baked at build time)
+    let engine_url = match option_env!("EKKA_ENGINE_URL") {
+        Some(u) => u,
+        None => {
             return EngineResponse::err(
                 "ENGINE_NOT_CONFIGURED",
-                "EKKA_ENGINE_URL not set. HOME grant requires online engine.",
+                "EKKA_ENGINE_URL not baked at build time. Rebuild with EKKA_ENGINE_URL set.",
             )
         }
     };

package/template/src-tauri/src/state.rs

@@ -179,7 +179,7 @@ impl Default for RunnerStatus {
             enabled: false,
             state: RunnerLoopState::Stopped,
             runner_id: None,
-            engine_url: std::env::var("EKKA_ENGINE_URL").ok(),
+            engine_url: option_env!("EKKA_ENGINE_URL").map(|s| s.to_string()),
             last_poll_at: None,
             last_claim_at: None,
             last_complete_at: None,
@@ -259,9 +259,10 @@ impl RunnerState {
             s.enabled = true;
             s.state = RunnerLoopState::Running;
             s.runner_id = Some(runner_id.to_string());
-            s.engine_url = std::env::var("EKKA_ENGINE_URL")
-                .or_else(|_| std::env::var("ENGINE_URL"))
-                .ok();
+            // EKKA_ENGINE_URL baked at build time, ENGINE_URL as runtime fallback
+            s.engine_url = option_env!("EKKA_ENGINE_URL")
+                .map(|s| s.to_string())
+                .or_else(|| std::env::var("ENGINE_URL").ok());
             s.last_error = None;
         });
     }
@@ -511,11 +512,11 @@ impl GrantIssuer for EngineHttpGrantIssuer {
             EkkaError::new(ops::codes::NOT_AUTHENTICATED, "Must login before requesting grant")
         })?;
 
-        // Get engine URL
-        let engine_url = std::env::var("EKKA_ENGINE_URL").map_err(|_| {
+        // Get engine URL (baked at build time)
+        let engine_url = option_env!("EKKA_ENGINE_URL").ok_or_else(|| {
             EkkaError::new(
                 ops::codes::ENGINE_ERROR,
-                "EKKA_ENGINE_URL not set. Grant requires online engine.",
+                "EKKA_ENGINE_URL not baked at build time. Rebuild with EKKA_ENGINE_URL set.",
             )
         })?;
 
@@ -613,10 +614,10 @@ impl GrantIssuer for EngineHttpGrantIssuer {
             EkkaError::new(ops::codes::NOT_AUTHENTICATED, "Must login to revoke grant")
         })?;
 
-        // Get engine URL (optional - revoke is best effort)
-        let engine_url = match std::env::var("EKKA_ENGINE_URL") {
-            Ok(url) => url,
-            Err(_) => return Ok(()), // No engine, just return success
+        // Get engine URL (baked at build time, optional - revoke is best effort)
+        let engine_url = match option_env!("EKKA_ENGINE_URL") {
+            Some(url) => url,
+            None => return Ok(()), // No engine baked, just return success
         };
 
         // Make revoke request (best effort)