create-ekka-desktop-app 0.3.12 → 0.4.0

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

@@ -1,27 +1,30 @@
 //! Engine Process Management
 //!
-//! Handles spawning, readiness checking, and routing for the external ekka-engine binary.
+//! Handles spawning and readiness checking for the external ekka-engine binary.
 //!
 //! ═══════════════════════════════════════════════════════════════════════════════════════════
-//! DRIFT GUARD - ARCHITECTURE FREEZE
+//! ARCHITECTURE NOTE
 //! ═══════════════════════════════════════════════════════════════════════════════════════════
-//! DO NOT extend this without revisiting the Desktop–Engine architecture decision.
+//! The spawned engine is a RUNNER RUNTIME (ekka-runner-local), NOT a request router.
+//! It provides:
+//! - /health endpoint for readiness check
+//! - Task execution via runner_tasks_v2 polling
 //!
-//! This module is FROZEN as of Phase 3G. Responsibilities are:
+//! It does NOT provide:
+//! - /request endpoint (removed - never existed in runner)
+//! - Command routing (all commands go to local Rust handlers + cloud API)
+//!
+//! Responsibilities:
 //! - Spawn ekka-engine binary on startup
-//! - Check readiness via health endpoint
-//! - Route requests to engine (or fallback to stub)
-//! - One-way disable on failure
+//! - Check readiness via /health endpoint
 //! - Clean shutdown on Desktop exit
-//! - Read-only status visibility (installed, running, available, pid, version, build)
+//! - Read-only status visibility (installed, running, available, pid)
 //! - Log streaming (stdout/stderr forwarding)
-//!
-//! Any changes require explicit architecture review.
 //! ═══════════════════════════════════════════════════════════════════════════════════════════
 
 use crate::bootstrap::resolve_home_path;
 use crate::node_credentials;
-use crate::types::{EngineRequest, EngineResponse};
+use regex::Regex;
 use serde::Serialize;
 use std::fs;
 use std::io::{BufRead, BufReader, Write};
@@ -30,6 +33,44 @@ use std::process::{Child, Command, Stdio};
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
+// =============================================================================
+// Log Cleaning Utilities
+// =============================================================================
+
+/// Strip ANSI escape codes from a string (colors, formatting, etc.)
+fn strip_ansi_codes(s: &str) -> String {
+    // Match ANSI escape sequences: ESC [ ... m (and other variants)
+    lazy_static::lazy_static! {
+        static ref ANSI_RE: Regex = Regex::new(r"\x1b\[[0-9;]*[a-zA-Z]").unwrap();
+    }
+    ANSI_RE.replace_all(s, "").to_string()
+}
+
+/// Log engine output with clean formatting
+///
+/// Bootstrap lines are prefixed with [BOOTSTRAP] and logged as bootstrap op.
+/// Engine lines with ERROR/error are logged as errors.
+/// Everything else is logged as engine info.
+fn log_engine_output(line: &str, stream: &str) {
+    let clean = strip_ansi_codes(line);
+    let trimmed = clean.trim();
+
+    if trimmed.is_empty() {
+        return;
+    }
+
+    if trimmed.starts_with("[BOOTSTRAP]") {
+        // Bootstrap output - log with bootstrap op
+        tracing::info!(op = "bootstrap", stream = stream, "{}", trimmed);
+    } else if trimmed.contains("ERROR") || trimmed.contains("error:") {
+        // Error line
+        tracing::error!(op = "engine", stream = stream, "{}", trimmed);
+    } else {
+        // Regular engine output
+        tracing::info!(op = "engine", stream = stream, "{}", trimmed);
+    }
+}
+
 // =============================================================================
 // Engine Environment Builder
 // =============================================================================
@@ -51,43 +92,6 @@ fn build_engine_env() -> Result<Vec<(&'static str, String)>, &'static str> {
         env.push(("EKKA_ENGINE_URL", url.to_string()));
     }
 
-    // EKKA_INTERNAL_SERVICE_KEY - optional for desktop (only needed for engine-bootstrap binary)
-    // Desktop runner uses node session auth, not internal key
-    let internal_key = std::env::var("EKKA_INTERNAL_SERVICE_KEY")
-        .or_else(|_| std::env::var("INTERNAL_SERVICE_KEY"))
-        .ok();
-
-    if let Some(ref key) = internal_key {
-        env.push(("EKKA_INTERNAL_SERVICE_KEY", key.clone()));
-        tracing::info!(
-            op = "desktop.internal_key.optional",
-            present = true,
-            "Internal service key configured (for engine-bootstrap)"
-        );
-    } else {
-        tracing::info!(
-            op = "desktop.internal_key.optional",
-            present = false,
-            "Internal service key not set (desktop runner uses node session auth)"
-        );
-    }
-
-    // EKKA_TENANT_ID - optional for desktop (only needed for engine-bootstrap binary)
-    // Desktop runner gets tenant_id from node session
-    if let Ok(tenant_id) = std::env::var("EKKA_TENANT_ID") {
-        if uuid::Uuid::parse_str(&tenant_id).is_ok() {
-            env.push(("EKKA_TENANT_ID", tenant_id));
-        }
-    }
-
-    // EKKA_WORKSPACE_ID - optional for desktop (only needed for engine-bootstrap binary)
-    // Desktop runner gets workspace_id from node session
-    if let Ok(workspace_id) = std::env::var("EKKA_WORKSPACE_ID") {
-        if uuid::Uuid::parse_str(&workspace_id).is_ok() {
-            env.push(("EKKA_WORKSPACE_ID", workspace_id));
-        }
-    }
-
     // Node credentials: Try keychain first, fall back to env vars
     // This enables headless engine startup without manual env exports
     if let Ok((node_id, node_secret)) = node_credentials::load_credentials() {
@@ -198,10 +202,6 @@ impl EngineProcess {
         }
     }
 
-    /// Permanently disable engine for this session (one-way switch)
-    pub fn disable(&self) {
-        self.set_available(false);
-    }
 }
 
 impl Default for EngineProcess {
@@ -210,7 +210,15 @@ impl Default for EngineProcess {
     }
 }
 
+/// Compute bootstrap binary path using ekka_home_folder
+/// Bootstrap is installed from resources and always runs first
+fn compute_bootstrap_path() -> Result<PathBuf, String> {
+    let home = resolve_home_path()?;
+    Ok(home.join("engine").join("ekka-engine-bootstrap"))
+}
+
 /// Compute engine binary path using ekka_home_folder
+/// Engine is downloaded by bootstrap and exec'd into
 fn compute_engine_path() -> Result<PathBuf, String> {
     let home = resolve_home_path()?;
     Ok(home.join("engine").join("ekka-engine"))
@@ -218,15 +226,15 @@ fn compute_engine_path() -> Result<PathBuf, String> {
 
 /// Ensure bootstrap engine is installed from embedded resources
 ///
-/// Extracts the bundled ekka-engine-bootstrap binary to ekka_home_folder/engine/ekka-engine
-/// if it doesn't already exist.
+/// Extracts the bundled ekka-engine-bootstrap binary to ekka_home_folder/engine/ekka-engine-bootstrap
+/// if it doesn't already exist. The bootstrap will then download the real engine to ekka-engine.
 ///
 /// Returns Ok(true) if installed, Ok(false) if already present.
 pub fn ensure_bootstrap_installed_from_resources(resource_path: Option<PathBuf>) -> Result<bool, String> {
-    let engine_path = compute_engine_path()?;
+    let bootstrap_path = compute_bootstrap_path()?;
 
     // Already installed - return silently
-    if engine_path.exists() {
+    if bootstrap_path.exists() {
         return Ok(false);
     }
 
@@ -260,12 +268,12 @@ pub fn ensure_bootstrap_installed_from_resources(resource_path: Option<PathBuf>)
     })?;
 
     // Create engine directory
-    let engine_dir = engine_path.parent().ok_or("Invalid engine path")?;
+    let engine_dir = bootstrap_path.parent().ok_or("Invalid bootstrap path")?;
     fs::create_dir_all(engine_dir)
         .map_err(|e| format!("Failed to create engine directory: {}", e))?;
 
     // Write atomically: tmp file -> chmod +x -> rename
-    let tmp_path = engine_path.with_extension("tmp");
+    let tmp_path = bootstrap_path.with_extension("tmp");
 
     let mut file = fs::File::create(&tmp_path)
         .map_err(|e| format!("Failed to create temp file: {}", e))?;
@@ -288,13 +296,13 @@ pub fn ensure_bootstrap_installed_from_resources(resource_path: Option<PathBuf>)
     }
 
     // Atomic rename
-    fs::rename(&tmp_path, &engine_path)
+    fs::rename(&tmp_path, &bootstrap_path)
         .map_err(|e| format!("Failed to rename to final path: {}", e))?;
 
     tracing::info!(
         op = "engine.bootstrap.install",
-        path = %engine_path.display(),
-        "Bootstrap engine installed from resources"
+        path = %bootstrap_path.display(),
+        "Bootstrap installed from resources"
     );
 
     Ok(true)
@@ -302,9 +310,29 @@ pub fn ensure_bootstrap_installed_from_resources(resource_path: Option<PathBuf>)
 
 /// Spawn and wait for engine readiness
 ///
+/// Two-binary architecture:
+/// 1. Desktop spawns ekka-engine-bootstrap
+/// 2. Bootstrap checks release service and downloads ekka-engine if needed
+/// 3. Bootstrap execs into ekka-engine (same PID)
+/// 4. Desktop waits for engine health check
+///
 /// Returns true if engine is ready, false otherwise.
 /// Stores result in EngineProcess.available.
 pub fn spawn_and_wait(engine: &EngineProcess) -> bool {
+    // Get both paths
+    let bootstrap_path = match compute_bootstrap_path() {
+        Ok(p) => p,
+        Err(e) => {
+            tracing::warn!(
+                op = "engine.path.error",
+                error = %e,
+                "Failed to compute bootstrap path"
+            );
+            engine.set_available(false);
+            return false;
+        }
+    };
+
     let engine_path = match compute_engine_path() {
         Ok(p) => p,
         Err(e) => {
@@ -318,24 +346,25 @@ pub fn spawn_and_wait(engine: &EngineProcess) -> bool {
         }
     };
 
-    // Check if binary exists
-    let installed = engine_path.exists();
+    // Check if bootstrap binary exists (must be installed from resources)
+    let installed = bootstrap_path.exists();
     engine.set_installed(installed);
 
     if !installed {
         tracing::info!(
             op = "engine.spawn.missing",
-            path = %engine_path.display(),
-            "Engine binary not found, using stub backend"
+            path = %bootstrap_path.display(),
+            "Bootstrap binary not found, using local handlers"
         );
         engine.set_available(false);
         return false;
     }
 
     tracing::info!(
-        op = "engine.spawn.start",
-        path = %engine_path.display(),
-        "Spawning engine process"
+        op = "desktop.bootstrap.start",
+        path = %bootstrap_path.display(),
+        exists = bootstrap_path.exists(),
+        "Starting bootstrap"
     );
 
     // Build engine environment from process env
@@ -352,14 +381,14 @@ pub fn spawn_and_wait(engine: &EngineProcess) -> bool {
         }
     };
 
-    tracing::info!(
+    tracing::debug!(
         op = "engine.spawn.env",
         keys = ?engine_env.iter().map(|(k, _)| *k).collect::<Vec<_>>(),
         "Setting engine environment"
     );
 
-    // Spawn the engine process with piped stdout/stderr
-    let mut child = match Command::new(&engine_path)
+    // Spawn the BOOTSTRAP process (not engine directly) with piped stdout/stderr
+    let mut child = match Command::new(&bootstrap_path)
         .envs(engine_env)
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
@@ -370,20 +399,21 @@ pub fn spawn_and_wait(engine: &EngineProcess) -> bool {
             tracing::warn!(
                 op = "engine.spawn.failed",
                 error = %e,
-                "Failed to spawn engine process"
+                path = %bootstrap_path.display(),
+                "Failed to spawn bootstrap process"
             );
             engine.set_available(false);
             return false;
         }
     };
 
-    // Spawn log reader threads (best-effort, ignore errors)
+    // Spawn log reader threads with clean formatting
     if let Some(stdout) = child.stdout.take() {
         std::thread::spawn(move || {
             let reader = BufReader::new(stdout);
             for line in reader.lines() {
                 match line {
-                    Ok(l) => tracing::info!(op = "engine.stdout", "{}", l),
+                    Ok(l) => log_engine_output(&l, "stdout"),
                     Err(_) => break,
                 }
             }
@@ -396,7 +426,7 @@ pub fn spawn_and_wait(engine: &EngineProcess) -> bool {
             let reader = BufReader::new(stderr);
             for line in reader.lines() {
                 match line {
-                    Ok(l) => tracing::info!(op = "engine.stderr", "{}", l),
+                    Ok(l) => log_engine_output(&l, "stderr"),
                     Err(_) => break,
                 }
             }
@@ -412,9 +442,9 @@ pub fn spawn_and_wait(engine: &EngineProcess) -> bool {
         *guard = Some(child);
     }
 
-    tracing::info!(op = "engine.spawn.success", pid = pid, "Engine process spawned");
+    tracing::info!(op = "engine.spawn.success", pid = pid, "Bootstrap process spawned");
 
-    // Allow bootstrap time to exec into real engine or fail
+    // Allow bootstrap time to download engine (if needed) and exec into it
     // Bootstrap either: execs real engine (same PID), or exits with error code
     std::thread::sleep(Duration::from_secs(2));
 
@@ -443,18 +473,28 @@ pub fn spawn_and_wait(engine: &EngineProcess) -> bool {
     };
 
     if bootstrap_failed {
+        tracing::error!(
+            op = "engine.bootstrap.fatal",
+            pid = pid,
+            "FATAL: Bootstrap failed to start engine. Check logs above for error details."
+        );
         engine.set_available(false);
         return false;
     }
 
-    tracing::debug!(op = "engine.bootstrap.exec", pid = pid, "Bootstrap exec'd into real engine, starting readiness check");
+    tracing::debug!(
+        op = "engine.bootstrap.exec",
+        pid = pid,
+        engine_path = %engine_path.display(),
+        "Bootstrap exec'd into real engine, starting readiness check"
+    );
 
     // Wait for readiness (real engine should now be running)
     let ready = wait_for_ready(15);
     engine.set_available(ready);
 
     if ready {
-        tracing::info!(op = "engine.ready", "Engine is ready");
+        tracing::info!(op = "desktop.engine.ready", "Engine is ready");
     } else {
         tracing::warn!(op = "engine.ready.timeout", "Engine readiness timeout");
     }
@@ -507,49 +547,7 @@ pub fn shutdown(engine: &EngineProcess) {
     engine.set_available(false);
 }
 
-/// Route a request to the real engine
-///
-/// Returns Some(response) if engine handled the request, None on failure.
-/// On failure, caller should fall back to stub.
-pub fn route_to_engine(req: &EngineRequest) -> Option<EngineResponse> {
-    let port: u16 = std::env::var("EKKA_ENGINE_PORT")
-        .ok()
-        .and_then(|s| s.parse().ok())
-        .unwrap_or(9473);
-
-    let url = format!("http://127.0.0.1:{}/request", port);
-
-    let client = match reqwest::blocking::Client::builder()
-        .timeout(Duration::from_secs(30))
-        .build()
-    {
-        Ok(c) => c,
-        Err(e) => {
-            tracing::warn!(op = "engine.route.client_error", error = %e, "Failed to create HTTP client");
-            return None;
-        }
-    };
-
-    match client.post(&url).json(req).send() {
-        Ok(resp) if resp.status().is_success() => {
-            match resp.json::<EngineResponse>() {
-                Ok(engine_resp) => {
-                    tracing::debug!(op = "engine.route.success", op_name = %req.op, "Routed to engine");
-                    Some(engine_resp)
-                }
-                Err(e) => {
-                    tracing::warn!(op = "engine.route.parse_error", error = %e, "Failed to parse engine response");
-                    None
-                }
-            }
-        }
-        Ok(resp) => {
-            tracing::warn!(op = "engine.route.error", status = %resp.status(), "Engine returned error");
-            None
-        }
-        Err(e) => {
-            tracing::warn!(op = "engine.route.failed", error = %e, "Failed to route to engine");
-            None
-        }
-    }
-}
+// NOTE: route_to_engine() was removed.
+// The spawned engine is a runner runtime (ekka-runner-local), not a request router.
+// All commands go directly to local Rust handlers + cloud API.
+// See commit history for removed code if needed.