zinit_client/rhai/

engine.rs

//! Rhai engine for zinit client
//!
//! This module provides the Rhai scripting engine with zinit functions.
//! The engine uses ZinitHandle (sync) to communicate with the RPC thread.

use crate::client::handle::ZinitHandle;
use rhai::{AST, Dynamic, Engine, EvalAltResult, Map, Position, Scope};
use std::path::Path;
use std::sync::Mutex;
use std::time::Duration;

use super::service_builder::{ServiceBuilder, XinitBuilder, rhai_fns, xinit_rhai_fns};

// Import herolib Rhai registration functions
use herolib_clients::rhai::register_redisclient_module;
use herolib_core::rhai::register_text_module;
use herolib_os::rhai::{
    register_git_module, register_net_module, register_os_module, register_process_module,
};

// Global output buffer for print/debug output
lazy_static::lazy_static! {
    static ref OUTPUT_BUFFER: Mutex<Vec<String>> = Mutex::new(Vec::new());
    static ref GLOBAL_HANDLE: Mutex<Option<ZinitHandle>> = Mutex::new(None);
}

/// Set the global handle for use by chained builder methods
fn set_global_handle(handle: ZinitHandle) {
    if let Ok(mut h) = GLOBAL_HANDLE.lock() {
        *h = Some(handle);
    }
}

/// Get a clone of the global handle
pub fn get_global_handle() -> Option<ZinitHandle> {
    GLOBAL_HANDLE.lock().ok().and_then(|h| h.clone())
}

/// Append to the output buffer
fn append_output(s: &str) {
    if let Ok(mut buf) = OUTPUT_BUFFER.lock() {
        buf.push(s.to_string());
    }
    // Also print to stdout for immediate feedback
    println!("{}", s);
}

/// Clear the output buffer
pub fn clear_output() {
    if let Ok(mut buf) = OUTPUT_BUFFER.lock() {
        buf.clear();
    }
}

/// Get accumulated output
pub fn get_output() -> Vec<String> {
    OUTPUT_BUFFER.lock().map(|b| b.clone()).unwrap_or_default()
}

/// Normalize a service name: replace - with _, lowercase
pub fn normalize_service_name(name: &str) -> String {
    name.replace('-', "_").to_lowercase()
}

/// Create a Rhai runtime error
fn make_error<T>(msg: impl Into<String>) -> Result<T, Box<EvalAltResult>> {
    Err(Box::new(EvalAltResult::ErrorRuntime(
        Dynamic::from(msg.into()),
        Position::NONE,
    )))
}

/// Check if a TCP port is open
fn check_tcp_port(addr: &str) -> bool {
    if addr.is_empty() {
        return true;
    }
    use std::net::{TcpStream, ToSocketAddrs};
    match addr.to_socket_addrs() {
        Ok(mut addrs) => {
            if let Some(socket_addr) = addrs.next() {
                TcpStream::connect_timeout(&socket_addr, Duration::from_secs(2)).is_ok()
            } else {
                false
            }
        }
        Err(_) => false,
    }
}

/// Check if an HTTP endpoint is reachable
fn check_http(url: &str) -> bool {
    if url.is_empty() {
        return true;
    }
    use std::io::{Read, Write};
    use std::net::{TcpStream, ToSocketAddrs};

    let url = url.trim();
    let without_proto = url
        .strip_prefix("http://")
        .or_else(|| url.strip_prefix("https://"))
        .unwrap_or(url);

    let (host_port, path) = match without_proto.find('/') {
        Some(i) => (&without_proto[..i], &without_proto[i..]),
        None => (without_proto, "/"),
    };

    let host_port_with_default = if host_port.contains(':') {
        host_port.to_string()
    } else {
        format!("{}:80", host_port)
    };

    let socket_addr = match host_port_with_default.to_socket_addrs() {
        Ok(mut addrs) => match addrs.next() {
            Some(a) => a,
            None => return false,
        },
        Err(_) => return false,
    };

    match TcpStream::connect_timeout(&socket_addr, Duration::from_secs(2)) {
        Ok(mut stream) => {
            stream.set_read_timeout(Some(Duration::from_secs(2))).ok();
            stream.set_write_timeout(Some(Duration::from_secs(2))).ok();

            let request = format!(
                "GET {} HTTP/1.0\r\nHost: {}\r\nConnection: close\r\n\r\n",
                path, host_port
            );

            if stream.write_all(request.as_bytes()).is_err() {
                return false;
            }

            let mut response = [0u8; 32];
            if stream.read(&mut response).is_err() {
                return false;
            }

            let response_str = String::from_utf8_lossy(&response);
            response_str.contains("HTTP/1.0 2") || response_str.contains("HTTP/1.1 2")
        }
        Err(_) => false,
    }
}

/// Get child PIDs of a process
fn get_child_pids(parent_pid: i32) -> Vec<i32> {
    use std::process::Command;

    let output = Command::new("pgrep")
        .args(["-P", &parent_pid.to_string()])
        .output();

    match output {
        Ok(out) if out.status.success() => std::str::from_utf8(&out.stdout)
            .unwrap_or("")
            .lines()
            .filter_map(|s| s.trim().parse().ok())
            .collect(),
        _ => Vec::new(),
    }
}

/// Recursively collect all descendant PIDs (depth-first, deepest first)
fn collect_descendants_depth_first(pid: i32, result: &mut Vec<i32>) {
    let children = get_child_pids(pid);
    for child in children {
        collect_descendants_depth_first(child, result);
        result.push(child);
    }
}

/// Kill a process and all its children (children first, then parent)
fn kill_process_tree(pid: i32) {
    use std::process::Command;

    // Collect all descendants depth-first (deepest first)
    let mut descendants = Vec::new();
    collect_descendants_depth_first(pid, &mut descendants);

    // Kill children first (deepest first), then parent
    for child_pid in &descendants {
        let _ = Command::new("kill").arg(child_pid.to_string()).output();
    }
    let _ = Command::new("kill").arg(pid.to_string()).output();

    // Wait briefly
    std::thread::sleep(Duration::from_millis(100));

    // Force kill any remaining
    for child_pid in &descendants {
        let check = Command::new("kill")
            .args(["-0", &child_pid.to_string()])
            .output();
        if check.map(|o| o.status.success()).unwrap_or(false) {
            let _ = Command::new("kill")
                .args(["-9", &child_pid.to_string()])
                .output();
        }
    }
    let check = Command::new("kill").args(["-0", &pid.to_string()]).output();
    if check.map(|o| o.status.success()).unwrap_or(false) {
        let _ = Command::new("kill").args(["-9", &pid.to_string()]).output();
    }
}

/// Kill process(es) listening on a TCP port (used by kill_port rhai function)
fn kill_process_on_port(port: u16) -> usize {
    use std::process::Command;

    let output = Command::new("lsof")
        .args(["-ti", &format!(":{}", port)])
        .output();

    match output {
        Ok(out) if out.status.success() => {
            let pids: Vec<i32> = std::str::from_utf8(&out.stdout)
                .unwrap_or("")
                .lines()
                .filter_map(|s| s.trim().parse().ok())
                .collect();

            let mut killed = 0;
            for pid in &pids {
                kill_process_tree(*pid);
                killed += 1;
            }
            killed
        }
        _ => 0,
    }
}

/// Zinit Rhai scripting engine
pub struct ZinitEngine {
    engine: Engine,
}

impl ZinitEngine {
    /// Create a new engine without server connection (utility functions only)
    pub fn new() -> Self {
        let mut engine = Engine::new();
        Self::register_types(&mut engine);
        Self::register_utility_functions(&mut engine);
        Self { engine }
    }

    /// Create a new engine with ZinitHandle for server communication
    pub fn with_handle(handle: ZinitHandle) -> Self {
        // Store handle globally for chained builder methods
        set_global_handle(handle.clone());

        let mut engine = Engine::new();
        Self::register_types(&mut engine);
        Self::register_utility_functions(&mut engine);
        Self::register_zinit_functions(&mut engine, handle);
        Self { engine }
    }

    fn register_types(engine: &mut Engine) {
        engine
            .register_type_with_name::<ServiceBuilder>("ServiceBuilder")
            .register_fn("zinit_service_new", rhai_fns::new_service)
            .register_fn("exec", rhai_fns::service_exec)
            .register_fn("status", rhai_fns::service_status)
            .register_fn("period", rhai_fns::service_period)
            .register_fn("retry", rhai_fns::service_retry)
            .register_fn("test_cmd", rhai_fns::service_test_cmd)
            .register_fn("oneshot", rhai_fns::service_oneshot)
            .register_fn("shutdown_timeout", rhai_fns::service_shutdown_timeout)
            .register_fn("after", rhai_fns::service_after)
            .register_fn("signal_stop", rhai_fns::service_signal_stop)
            .register_fn("log", rhai_fns::service_log)
            .register_fn("env", rhai_fns::service_env)
            .register_fn("dir", rhai_fns::service_dir)
            .register_fn("to_map", rhai_fns::service_to_map)
            .register_fn("to_string", rhai_fns::service_to_string)
            .register_fn("to_toml", rhai_fns::service_to_toml)
            .register_fn("to_markdown", rhai_fns::service_to_markdown)
            .register_fn("name", rhai_fns::service_name)
            .register_fn("test_tcp", rhai_fns::service_test_tcp)
            .register_fn("test_http", rhai_fns::service_test_http)
            .register_fn("tcp_kill", rhai_fns::service_tcp_kill)
            .register_fn("reset", rhai_fns::service_reset)
            .register_fn("wait", rhai_fns::service_wait)
            .register_fn("register", rhai_fns::service_register);

        // Register XinitBuilder type and methods
        engine
            .register_type_with_name::<XinitBuilder>("XinitBuilder")
            .register_fn("xinit_proxy_new", xinit_rhai_fns::new_xinit)
            .register_fn("name", xinit_rhai_fns::xinit_name)
            .register_fn("listen", xinit_rhai_fns::xinit_listen)
            .register_fn("add_listen", xinit_rhai_fns::xinit_add_listen)
            .register_fn("backend", xinit_rhai_fns::xinit_backend)
            .register_fn("service", xinit_rhai_fns::xinit_service)
            .register_fn("reset", xinit_rhai_fns::xinit_reset)
            .register_fn("idle_timeout", xinit_rhai_fns::xinit_idle_timeout)
            .register_fn("connect_timeout", xinit_rhai_fns::xinit_connect_timeout)
            .register_fn("to_string", xinit_rhai_fns::xinit_to_string)
            .register_fn("to_toml", xinit_rhai_fns::xinit_to_toml)
            .register_fn("to_markdown", xinit_rhai_fns::xinit_to_markdown)
            .register_fn("register", xinit_rhai_fns::xinit_register);
    }

    fn register_utility_functions(engine: &mut Engine) {
        // Capture print/debug output
        engine.on_print(|s| {
            append_output(s);
        });
        engine.on_debug(|s, source, pos| {
            let location = if let Some(src) = source {
                format!("[{}:{}] ", src, pos)
            } else if !pos.is_none() {
                format!("[{}] ", pos)
            } else {
                String::new()
            };
            append_output(&format!("[DEBUG] {}{}", location, s));
        });

        engine.register_fn("sleep_ms", |ms: i64| {
            std::thread::sleep(Duration::from_millis(ms as u64));
        });

        engine.register_fn("sleep", |secs: i64| {
            std::thread::sleep(Duration::from_secs(secs as u64));
        });

        engine.register_fn("get_env", |key: &str| -> Dynamic {
            match std::env::var(key) {
                Ok(val) => Dynamic::from(val),
                Err(_) => Dynamic::UNIT,
            }
        });

        engine.register_fn("set_env", |key: &str, value: &str| {
            // SAFETY: We are single-threaded in the Rhai engine context
            unsafe { std::env::set_var(key, value) };
        });

        engine.register_fn("check_tcp", check_tcp_port);
        engine.register_fn("check_http", check_http);

        engine.register_fn("kill_port", |port: i64| -> i64 {
            kill_process_on_port(port as u16) as i64
        });

        // Register herolib modules (OS, process, git, network)
        let _ = register_os_module(engine);
        let _ = register_process_module(engine);
        let _ = register_git_module(engine);
        let _ = register_net_module(engine);

        // Register herolib-core text module
        let _ = register_text_module(engine);

        // Register herolib-clients redis module
        let _ = register_redisclient_module(engine);
    }

    fn register_zinit_functions(engine: &mut Engine, handle: ZinitHandle) {
        // zinit_ping() -> map
        let h = handle.clone();
        engine.register_fn(
            "zinit_ping",
            move || -> Result<Dynamic, Box<EvalAltResult>> {
                match h.ping() {
                    Ok(resp) => {
                        let mut map = Map::new();
                        map.insert("message".into(), resp.message.into());
                        map.insert("version".into(), resp.version.into());
                        Ok(Dynamic::from_map(map))
                    }
                    Err(e) => make_error(format!("zinit_ping failed: {}", e)),
                }
            },
        );

        // zinit_list() -> array
        let h = handle.clone();
        engine.register_fn(
            "zinit_list",
            move || -> Result<Dynamic, Box<EvalAltResult>> {
                match h.list() {
                    Ok(services) => Ok(Dynamic::from_array(
                        services.into_iter().map(Dynamic::from).collect(),
                    )),
                    Err(e) => make_error(format!("zinit_list failed: {}", e)),
                }
            },
        );

        // zinit_list_md() -> prints markdown table of all services
        let h = handle.clone();
        engine.register_fn(
            "zinit_list_md",
            move || -> Result<(), Box<EvalAltResult>> {
                match h.list() {
                    Ok(services) => {
                        if services.is_empty() {
                            append_output("No services registered.");
                        } else {
                            let mut output = String::new();
                            output.push_str("| Service | State | PID |\n");
                            output.push_str("|---------|-------|-----|\n");
                            for name in services {
                                match h.status(&name) {
                                    Ok(status) => {
                                        output.push_str(&format!(
                                            "| {} | {} | {} |\n",
                                            status.name, status.state, status.pid
                                        ));
                                    }
                                    Err(_) => {
                                        output.push_str(&format!("| {} | unknown | - |\n", name));
                                    }
                                }
                            }
                            append_output(&output);
                        }
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_list_md failed: {}", e)),
                }
            },
        );

        // zinit_status(name) -> map
        let h = handle.clone();
        engine.register_fn(
            "zinit_status",
            move |name: &str| -> Result<Dynamic, Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.status(&name) {
                    Ok(status) => {
                        let mut map = Map::new();
                        map.insert("name".into(), status.name.into());
                        map.insert("pid".into(), (status.pid as i64).into());
                        map.insert("state".into(), status.state.into());
                        map.insert("target".into(), status.target.into());
                        Ok(Dynamic::from_map(map))
                    }
                    Err(e) => make_error(format!("zinit_status '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_status_md(name) -> prints markdown table of service status
        let h = handle.clone();
        engine.register_fn(
            "zinit_status_md",
            move |name: &str| -> Result<(), Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.status(&name) {
                    Ok(status) => {
                        let mut output = String::new();
                        output.push_str("| Property | Value |\n");
                        output.push_str("|----------|-------|\n");
                        output.push_str(&format!("| Name | {} |\n", status.name));
                        output.push_str(&format!("| PID | {} |\n", status.pid));
                        output.push_str(&format!("| State | {} |\n", status.state));
                        output.push_str(&format!("| Target | {} |\n", status.target));
                        append_output(&output);
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_status_md '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_start(name)
        let h = handle.clone();
        engine.register_fn(
            "zinit_start",
            move |name: &str| -> Result<(), Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.start(&name) {
                    Ok(_) => {
                        append_output(&format!("Started: {}", name));
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_start '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_stop(name)
        let h = handle.clone();
        engine.register_fn(
            "zinit_stop",
            move |name: &str| -> Result<(), Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.stop(&name) {
                    Ok(_) => {
                        append_output(&format!("Stopped: {}", name));
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_stop '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_restart(name)
        let h = handle.clone();
        engine.register_fn(
            "zinit_restart",
            move |name: &str| -> Result<(), Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.restart(&name) {
                    Ok(_) => {
                        append_output(&format!("Restarted: {}", name));
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_restart '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_delete(name)
        let h = handle.clone();
        engine.register_fn(
            "zinit_delete",
            move |name: &str| -> Result<(), Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.delete(&name) {
                    Ok(_) => {
                        append_output(&format!("Deleted: {}", name));
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_delete '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_kill(name, signal)
        let h = handle.clone();
        engine.register_fn(
            "zinit_kill",
            move |name: &str, signal: &str| -> Result<(), Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.kill(&name, signal) {
                    Ok(_) => {
                        append_output(&format!("Sent {} to: {}", signal, name));
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_kill '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_stats(name) -> map
        let h = handle.clone();
        engine.register_fn(
            "zinit_stats",
            move |name: &str| -> Result<Dynamic, Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.stats(&name) {
                    Ok(stats) => {
                        let mut map = Map::new();
                        map.insert("pid".into(), (stats.pid as i64).into());
                        map.insert("memory_usage".into(), (stats.memory_usage as i64).into());
                        map.insert("cpu_usage".into(), (stats.cpu_usage as f64).into());
                        Ok(Dynamic::from_map(map))
                    }
                    Err(e) => make_error(format!("zinit_stats '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_stats_md(name) -> prints markdown table of service stats
        let h = handle.clone();
        engine.register_fn(
            "zinit_stats_md",
            move |name: &str| -> Result<(), Box<EvalAltResult>> {
                let name = normalize_service_name(name);
                match h.stats(&name) {
                    Ok(stats) => {
                        let mut output = String::new();
                        output.push_str("| Metric | Value |\n");
                        output.push_str("|--------|-------|\n");
                        output.push_str(&format!("| PID | {} |\n", stats.pid));
                        output.push_str(&format!("| Memory | {} bytes |\n", stats.memory_usage));
                        output.push_str(&format!("| CPU | {:.2}% |\n", stats.cpu_usage));
                        append_output(&output);
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_stats_md '{}' failed: {}", name, e)),
                }
            },
        );

        // zinit_is_running(name) -> bool
        let h = handle.clone();
        engine.register_fn("zinit_is_running", move |name: &str| -> bool {
            let name = normalize_service_name(name);
            h.is_running(&name).unwrap_or(false)
        });

        // zinit_wait_for(name, timeout_secs) -> bool
        let h = handle.clone();
        engine.register_fn("zinit_wait_for", move |name: &str, secs: i64| -> bool {
            let name = normalize_service_name(name);
            let deadline = std::time::Instant::now() + Duration::from_secs(secs.max(1) as u64);
            loop {
                if std::time::Instant::now() >= deadline {
                    return false;
                }
                if let Ok(status) = h.status(&name) {
                    if status.state == "Running" || status.state == "Success" {
                        return true;
                    }
                    if status.state.contains("Error") || status.state.contains("Failed") {
                        return false;
                    }
                }
                std::thread::sleep(Duration::from_millis(100));
            }
        });

        // zinit_logs() -> array
        let h = handle.clone();
        engine.register_fn(
            "zinit_logs",
            move || -> Result<Dynamic, Box<EvalAltResult>> {
                match h.logs() {
                    Ok(logs) => Ok(Dynamic::from_array(
                        logs.into_iter().map(Dynamic::from).collect(),
                    )),
                    Err(e) => make_error(format!("zinit_logs failed: {}", e)),
                }
            },
        );

        // zinit_logs_filter(service) -> array
        let h = handle.clone();
        engine.register_fn(
            "zinit_logs_filter",
            move |service: &str| -> Result<Dynamic, Box<EvalAltResult>> {
                let service = normalize_service_name(service);
                match h.logs_filter(&service) {
                    Ok(logs) => Ok(Dynamic::from_array(
                        logs.into_iter().map(Dynamic::from).collect(),
                    )),
                    Err(e) => make_error(format!("zinit_logs_filter failed: {}", e)),
                }
            },
        );

        // zinit_logs_tail(n) -> array of last n log lines
        let h = handle.clone();
        engine.register_fn(
            "zinit_logs_tail",
            move |n: i64| -> Result<Dynamic, Box<EvalAltResult>> {
                match h.logs() {
                    Ok(logs) => {
                        let n = n.max(0) as usize;
                        let start = if logs.len() > n { logs.len() - n } else { 0 };
                        Ok(Dynamic::from_array(
                            logs[start..].iter().cloned().map(Dynamic::from).collect(),
                        ))
                    }
                    Err(e) => make_error(format!("zinit_logs_tail failed: {}", e)),
                }
            },
        );

        // zinit_logs_print() - print all logs
        let h = handle.clone();
        engine.register_fn(
            "zinit_logs_print",
            move || -> Result<(), Box<EvalAltResult>> {
                match h.logs() {
                    Ok(logs) => {
                        for line in logs {
                            append_output(&line);
                        }
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_logs_print failed: {}", e)),
                }
            },
        );

        // zinit_logs_print_filter(service) - print logs for a specific service
        let h = handle.clone();
        engine.register_fn(
            "zinit_logs_print_filter",
            move |service: &str| -> Result<(), Box<EvalAltResult>> {
                let service = normalize_service_name(service);
                match h.logs_filter(&service) {
                    Ok(logs) => {
                        for line in logs {
                            append_output(&line);
                        }
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_logs_print_filter failed: {}", e)),
                }
            },
        );

        // zinit_logs_follow(secs) - follow all logs for n seconds
        let h = handle.clone();
        engine.register_fn(
            "zinit_logs_follow",
            move |secs: i64| -> Result<(), Box<EvalAltResult>> {
                let deadline = std::time::Instant::now() + Duration::from_secs(secs.max(1) as u64);
                let mut last_count = 0usize;
                while std::time::Instant::now() < deadline {
                    if let Ok(logs) = h.logs() {
                        if logs.len() > last_count {
                            for line in &logs[last_count..] {
                                append_output(line);
                            }
                            last_count = logs.len();
                        }
                    }
                    std::thread::sleep(Duration::from_millis(100));
                }
                Ok(())
            },
        );

        // zinit_logs_follow_filter(service, secs) - follow service logs for n seconds
        let h = handle.clone();
        engine.register_fn(
            "zinit_logs_follow_filter",
            move |service: &str, secs: i64| -> Result<(), Box<EvalAltResult>> {
                let service = normalize_service_name(service);
                let deadline = std::time::Instant::now() + Duration::from_secs(secs.max(1) as u64);
                let mut last_count = 0usize;
                while std::time::Instant::now() < deadline {
                    if let Ok(logs) = h.logs_filter(&service) {
                        if logs.len() > last_count {
                            for line in &logs[last_count..] {
                                append_output(line);
                            }
                            last_count = logs.len();
                        }
                    }
                    std::thread::sleep(Duration::from_millis(100));
                }
                Ok(())
            },
        );

        // zinit_start_all()
        let h = handle.clone();
        engine.register_fn(
            "zinit_start_all",
            move || -> Result<(), Box<EvalAltResult>> {
                match h.start_all() {
                    Ok(_) => {
                        append_output("Started all services");
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_start_all failed: {}", e)),
                }
            },
        );

        // zinit_stop_all()
        let h = handle.clone();
        engine.register_fn(
            "zinit_stop_all",
            move || -> Result<(), Box<EvalAltResult>> {
                match h.stop_all() {
                    Ok(_) => {
                        append_output("Stopped all services");
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_stop_all failed: {}", e)),
                }
            },
        );

        // zinit_service_delete_all() - stop and delete all services
        let h = handle.clone();
        engine.register_fn(
            "zinit_service_delete_all",
            move || -> Result<(), Box<EvalAltResult>> {
                match h.delete_all() {
                    Ok(_) => {
                        append_output("Deleted all services");
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_service_delete_all failed: {}", e)),
                }
            },
        );

        // zinit_shutdown() - shutdown the server
        let h = handle.clone();
        engine.register_fn(
            "zinit_shutdown",
            move || -> Result<(), Box<EvalAltResult>> {
                match h.shutdown() {
                    Ok(_) => {
                        append_output("Server shutting down");
                        Ok(())
                    }
                    Err(e) => make_error(format!("zinit_shutdown failed: {}", e)),
                }
            },
        );

        // zinit_reboot() - reboot the system
        let h = handle.clone();
        engine.register_fn("zinit_reboot", move || -> Result<(), Box<EvalAltResult>> {
            match h.reboot() {
                Ok(_) => {
                    append_output("System rebooting");
                    Ok(())
                }
                Err(e) => make_error(format!("zinit_reboot failed: {}", e)),
            }
        });

        // ============ Xinit Functions ============

        // xinit_list() -> array
        let h = handle.clone();
        engine.register_fn(
            "xinit_list",
            move || -> Result<Dynamic, Box<EvalAltResult>> {
                match h.xinit_list() {
                    Ok(proxies) => Ok(Dynamic::from_array(
                        proxies.into_iter().map(Dynamic::from).collect(),
                    )),
                    Err(e) => make_error(format!("xinit_list failed: {}", e)),
                }
            },
        );

        // xinit_list_md() -> prints markdown table of all proxies
        let h = handle.clone();
        engine.register_fn(
            "xinit_list_md",
            move || -> Result<(), Box<EvalAltResult>> {
                match h.xinit_status_all() {
                    Ok(statuses) => {
                        if statuses.is_empty() {
                            append_output("No xinit proxies registered.");
                        } else {
                            let mut output = String::new();
                            output.push_str(
                                "| Name | Listen | Backend | Service | Running | Connections |\n",
                            );
                            output.push_str(
                                "|------|--------|---------|---------|---------|-------------|\n",
                            );
                            for status in statuses {
                                output.push_str(&format!(
                                    "| {} | {} | {} | {} | {} | {} |\n",
                                    status.name,
                                    status.listen,
                                    status.backend,
                                    status.service,
                                    if status.running { "Yes" } else { "No" },
                                    status.active_connections
                                ));
                            }
                            append_output(&output);
                        }
                        Ok(())
                    }
                    Err(e) => make_error(format!("xinit_list_md failed: {}", e)),
                }
            },
        );

        // xinit_register(name, listen, backend, service)
        // Legacy xinit_register function (deprecated - use xinit_proxy_new().register() instead)
        let h = handle.clone();
        engine.register_fn(
            "xinit_register",
            move |name: &str,
                  listen: &str,
                  backend: &str,
                  service: &str|
                  -> Result<(), Box<EvalAltResult>> {
                let listen_addrs = vec![listen.to_string()];
                match h.xinit_register(name, &listen_addrs, backend, service, 0, 30) {
                    Ok(_) => {
                        append_output(&format!(
                            "Registered xinit proxy '{}': {} -> {}",
                            name, listen, backend
                        ));
                        Ok(())
                    }
                    Err(e) => make_error(format!("xinit_register '{}' failed: {}", name, e)),
                }
            },
        );

        // xinit_unregister(name)
        let h = handle.clone();
        engine.register_fn(
            "xinit_unregister",
            move |name: &str| -> Result<(), Box<EvalAltResult>> {
                match h.xinit_unregister(name) {
                    Ok(_) => {
                        append_output(&format!("Unregistered xinit proxy '{}'", name));
                        Ok(())
                    }
                    Err(e) => make_error(format!("xinit_unregister '{}' failed: {}", name, e)),
                }
            },
        );

        // xinit_status(name) -> map
        let h = handle.clone();
        engine.register_fn(
            "xinit_status",
            move |name: &str| -> Result<Dynamic, Box<EvalAltResult>> {
                match h.xinit_status(name) {
                    Ok(status) => {
                        let mut map = Map::new();
                        map.insert("name".into(), status.name.into());
                        map.insert("listen".into(), status.listen.into());
                        map.insert("backend".into(), status.backend.into());
                        map.insert("service".into(), status.service.into());
                        map.insert("running".into(), status.running.into());
                        map.insert(
                            "total_connections".into(),
                            (status.total_connections as i64).into(),
                        );
                        map.insert(
                            "active_connections".into(),
                            (status.active_connections as i64).into(),
                        );
                        map.insert(
                            "bytes_to_backend".into(),
                            (status.bytes_to_backend as i64).into(),
                        );
                        map.insert(
                            "bytes_from_backend".into(),
                            (status.bytes_from_backend as i64).into(),
                        );
                        Ok(Dynamic::from_map(map))
                    }
                    Err(e) => make_error(format!("xinit_status '{}' failed: {}", name, e)),
                }
            },
        );

        // xinit_status_all() -> array of maps
        let h = handle.clone();
        engine.register_fn(
            "xinit_status_all",
            move || -> Result<Dynamic, Box<EvalAltResult>> {
                match h.xinit_status_all() {
                    Ok(statuses) => {
                        let arr: Vec<Dynamic> = statuses
                            .into_iter()
                            .map(|status| {
                                let mut map = Map::new();
                                map.insert("name".into(), status.name.into());
                                map.insert("listen".into(), status.listen.into());
                                map.insert("backend".into(), status.backend.into());
                                map.insert("service".into(), status.service.into());
                                map.insert("running".into(), status.running.into());
                                map.insert(
                                    "total_connections".into(),
                                    (status.total_connections as i64).into(),
                                );
                                map.insert(
                                    "active_connections".into(),
                                    (status.active_connections as i64).into(),
                                );
                                Dynamic::from_map(map)
                            })
                            .collect();
                        Ok(Dynamic::from_array(arr))
                    }
                    Err(e) => make_error(format!("xinit_status_all failed: {}", e)),
                }
            },
        );
    }

    /// Compile a script
    pub fn compile(&self, script: &str) -> Result<AST, Box<EvalAltResult>> {
        self.engine.compile(script).map_err(|e| {
            Box::new(EvalAltResult::ErrorRuntime(
                Dynamic::from(e.to_string()),
                Position::NONE,
            ))
        })
    }

    /// Run a compiled AST
    pub fn run_ast(&self, ast: &AST) -> Result<Dynamic, Box<EvalAltResult>> {
        let mut scope = Scope::new();
        self.engine.eval_ast_with_scope(&mut scope, ast)
    }

    /// Run a script directly
    pub fn run(&self, script: &str) -> Result<Dynamic, Box<EvalAltResult>> {
        let mut scope = Scope::new();
        self.engine.eval_with_scope(&mut scope, script)
    }

    /// Run a script file (strips shebang line if present for shebang support)
    pub fn run_file(&self, path: &Path) -> Result<Dynamic, Box<EvalAltResult>> {
        let script = std::fs::read_to_string(path).map_err(|e| {
            Box::new(EvalAltResult::ErrorRuntime(
                Dynamic::from(format!("Failed to read file: {}", e)),
                Position::NONE,
            ))
        })?;

        // Strip shebang line if present (for #!/usr/bin/env zinit support)
        let script = if script.starts_with("#!") {
            script.lines().skip(1).collect::<Vec<_>>().join("\n")
        } else {
            script
        };

        self.run(&script)
    }

    /// Get the underlying engine for advanced usage
    pub fn engine(&self) -> &Engine {
        &self.engine
    }

    /// Get mutable engine for advanced usage
    pub fn engine_mut(&mut self) -> &mut Engine {
        &mut self.engine
    }
}

impl Default for ZinitEngine {
    fn default() -> Self {
        Self::new()
    }
}

/// Create a new engine with default handle
pub fn create_engine() -> Result<ZinitEngine, anyhow::Error> {
    let handle = ZinitHandle::new()?;
    Ok(ZinitEngine::with_handle(handle))
}

/// Run a script with default handle
pub fn run_script(script: &str) -> Result<Dynamic, Box<EvalAltResult>> {
    let engine = create_engine().map_err(|e| {
        Box::new(EvalAltResult::ErrorRuntime(
            Dynamic::from(e.to_string()),
            Position::NONE,
        ))
    })?;
    engine.run(script)
}

/// Run a script file with default handle
pub fn run_script_file(path: &Path) -> Result<Dynamic, Box<EvalAltResult>> {
    let engine = create_engine().map_err(|e| {
        Box::new(EvalAltResult::ErrorRuntime(
            Dynamic::from(e.to_string()),
            Position::NONE,
        ))
    })?;
    engine.run_file(path)
}