eli 0.5.1

Ease Lives Instantly — hook-first AI agent framework with multi-channel support
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#[cfg(feature = "gateway")]
use std::path::{Path, PathBuf};

#[cfg(feature = "gateway")]
use serde_json::Value;

#[cfg(feature = "gateway")]
pub(crate) fn find_sidecar_dir() -> Option<PathBuf> {
    [
        std::env::var("ELI_SIDECAR_DIR").ok().map(PathBuf::from),
        installed_sidecar_dir(),
        std::env::current_dir().ok().map(|dir| dir.join("sidecar")),
    ]
    .into_iter()
    .flatten()
    .find(|path| sidecar_exists(path))
}

#[cfg(feature = "gateway")]
pub(crate) fn ensure_node_available() -> bool {
    let status = std::process::Command::new("node")
        .arg("--version")
        .stdout(std::process::Stdio::null())
        .stderr(std::process::Stdio::null())
        .status();
    status.is_ok()
}

#[cfg(feature = "gateway")]
pub(crate) fn ensure_sidecar_deps(sidecar_dir: &Path, refresh: bool) -> bool {
    if !refresh && sidecar_dir.join("node_modules").exists() {
        return true;
    }
    if refresh && deps_are_current(sidecar_dir).unwrap_or(false) {
        return true;
    }
    run_npm_install(sidecar_dir)
}

#[cfg(feature = "gateway")]
fn installed_sidecar_dir() -> Option<PathBuf> {
    std::env::current_exe()
        .ok()
        .and_then(|path| path.parent().map(|dir| dir.join("sidecar")))
}

#[cfg(feature = "gateway")]
fn sidecar_exists(path: &Path) -> bool {
    path.join("start.cjs").exists()
}

#[cfg(feature = "gateway")]
fn run_npm_install(sidecar_dir: &Path) -> bool {
    std::process::Command::new("npm")
        .arg("install")
        .current_dir(sidecar_dir)
        .status()
        .is_ok_and(|status| status.success())
}

#[cfg(feature = "gateway")]
fn deps_are_current(sidecar_dir: &Path) -> Option<bool> {
    let openclaw = expected_dep_version(sidecar_dir, "openclaw")?;
    let weixin = expected_dep_version(sidecar_dir, "@tencent-weixin/openclaw-weixin")?;
    Some(
        installed_dep_version(sidecar_dir, "openclaw")? == openclaw
            && installed_dep_version(sidecar_dir, "@tencent-weixin/openclaw-weixin")? == weixin,
    )
}

#[cfg(feature = "gateway")]
fn expected_dep_version(sidecar_dir: &Path, package: &str) -> Option<String> {
    let package_json = read_package_json(&sidecar_dir.join("package.json"))?;
    package_json["dependencies"][package]
        .as_str()
        .map(str::to_owned)
}

#[cfg(feature = "gateway")]
fn installed_dep_version(sidecar_dir: &Path, package: &str) -> Option<String> {
    let path = package_json_path(&sidecar_dir.join("node_modules"), package);
    read_package_json(&path)?["version"]
        .as_str()
        .map(str::to_owned)
}

#[cfg(feature = "gateway")]
fn read_package_json(path: &Path) -> Option<Value> {
    let raw = std::fs::read_to_string(path).ok()?;
    serde_json::from_str(&raw).ok()
}

#[cfg(feature = "gateway")]
fn package_json_path(base_dir: &Path, package: &str) -> PathBuf {
    package
        .split('/')
        .fold(base_dir.to_path_buf(), |path, part| path.join(part))
        .join("package.json")
}