lenso-cli 0.1.27

Lenso command-line interface for scaffolding and operating Lenso backend projects.
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

use std::path::{Path, PathBuf};
use std::process::Command;

use anyhow::{Context, Result, bail};

#[derive(Debug, Clone)]
pub struct ConsoleDevOptions {
    pub cwd: Option<PathBuf>,
    pub host: Option<String>,
    pub open: bool,
    pub package: Option<PathBuf>,
    pub port: u16,
    pub runtime_console_root: Option<PathBuf>,
}

pub fn run_console_dev(options: ConsoleDevOptions) -> Result<()> {
    let runtime_console_root =
        resolve_runtime_console_root(options.runtime_console_root.as_deref())?;
    let script = runtime_console_root.join("scripts/console-package-dev.mjs");
    if !script.exists() {
        bail!("Runtime Console dev runner not found: {}", script.display());
    }

    let mut command = Command::new("node");
    command.arg(script);
    if let Some(cwd) = options.cwd {
        command.arg("--cwd").arg(cwd);
    }
    if let Some(host) = options.host {
        command.arg("--host").arg(host);
    }
    if let Some(package) = options.package {
        command.arg("--package").arg(package);
    }
    command.arg("--port").arg(options.port.to_string());
    if options.open {
        command.env("LENSO_CONSOLE_DEV_OPEN", "1");
    }

    let status = command.status().with_context(|| {
        format!(
            "run Runtime Console dev runner in {}",
            runtime_console_root.display()
        )
    })?;
    if !status.success() {
        bail!("Runtime Console dev runner exited with {status}");
    }
    Ok(())
}

fn resolve_runtime_console_root(explicit: Option<&Path>) -> Result<PathBuf> {
    if let Some(root) = explicit {
        return Ok(root.to_path_buf());
    }
    if let Ok(root) = std::env::var("LENSO_RUNTIME_CONSOLE_ROOT") {
        return Ok(PathBuf::from(root));
    }

    let cwd = std::env::current_dir().context("read current directory")?;
    if let Some(root) = find_runtime_console_root_from(&cwd) {
        return Ok(root);
    }

    let sibling = cwd
        .join("../lenso-runtime-console")
        .canonicalize()
        .context(
            "resolve sibling lenso-runtime-console; set LENSO_RUNTIME_CONSOLE_ROOT if it is elsewhere",
        )?;
    Ok(sibling)
}

fn find_runtime_console_root_from(start: &Path) -> Option<PathBuf> {
    start
        .ancestors()
        .find(|candidate| is_runtime_console_root(candidate))
        .map(Path::to_path_buf)
}

fn is_runtime_console_root(candidate: &Path) -> bool {
    candidate
        .join("scripts")
        .join("console-package-dev.mjs")
        .is_file()
}