euv_cli/build/
fn.rs

1use crate::*;
2
3/// Checks whether `wasm_pack_args` already contains a build mode flag.
4///
5/// Returns `true` if any of `--dev`, `--release`, or `--profiling`
6/// is present in the arguments list.
7///
8/// # Arguments
9///
10/// - `&[String]` - The wasm-pack arguments to search.
11///
12/// # Returns
13///
14/// - `bool` - Whether a build mode flag is already present.
15pub fn has_build_mode_flag(wasm_pack_args: &[String]) -> bool {
16    wasm_pack_args
17        .iter()
18        .any(|arg: &String| arg == DEV_FLAG || arg == RELEASE_FLAG || arg == PROFILING_FLAG)
19}
20
21/// Filters out euv-specific arguments from the wasm-pack arguments.
22///
23/// First locates the genuine passthrough arguments by taking everything
24/// after the last `--` separator (or the full list if no `--` is present).
25/// Then removes all known euv-specific flags and their values so that
26/// only wasm-pack-compatible arguments remain.
27///
28/// # Arguments
29///
30/// - `&[String]` - The raw wasm-pack arguments to filter.
31///
32/// # Returns
33///
34/// - `Vec<String>` - The filtered arguments safe for wasm-pack.
35pub fn filter_euv_args(wasm_pack_args: &[String]) -> Vec<String> {
36    let raw_args: &[String] = if let Some(position) = wasm_pack_args
37        .iter()
38        .rposition(|arg: &String| arg == DOUBLE_DASH)
39    {
40        &wasm_pack_args[position + 1..]
41    } else {
42        wasm_pack_args
43    };
44    let mut filtered: Vec<String> = Vec::new();
45    let mut skip_next: bool = false;
46    for arg in raw_args {
47        if skip_next {
48            skip_next = false;
49            continue;
50        }
51        if EUV_ARGS.contains(&arg.as_str()) {
52            if arg.contains('=') {
53                continue;
54            }
55            skip_next = true;
56            continue;
57        }
58        filtered.push(arg.clone());
59    }
60    filtered
61}
62
63/// Reconciles euv-specific arguments that may have been collected into
64/// `wasm_pack_args` (e.g. when placed after `--`) back into the
65/// corresponding `ModeArgs` fields.
66///
67/// Because clap's `trailing_var_arg` collects all unrecognized arguments
68/// into `wasm_pack_args`, any euv flag placed after `--` is not parsed
69/// by clap into its dedicated field. This function scans `wasm_pack_args`
70/// for known euv flags and overwrites the `ModeArgs` fields so that the
71/// rest of the codebase can rely on the typed accessors regardless of
72/// argument order.
73///
74/// # Arguments
75///
76/// - `&mut ModeArgs` - The CLI arguments to reconcile in-place.
77pub fn reconcile_args(args: &mut ModeArgs) {
78    let wasm_pack_args: Vec<String> = args.get_wasm_pack_args().clone();
79    let mut crate_path: Option<PathBuf> = None;
80    let mut port: Option<u16> = None;
81    let mut www_dir: Option<String> = None;
82    let mut index_html: Option<Option<PathBuf>> = None;
83    let mut no_gitignore: Option<bool> = None;
84    let mut dev: Option<bool> = None;
85    let mut release: Option<bool> = None;
86    let mut profiling: Option<bool> = None;
87    let mut iter: std::slice::Iter<String> = wasm_pack_args.iter();
88    while let Some(arg) = iter.next() {
89        match arg.as_str() {
90            CRATE_PATH_ARG | CRATE_PATH_ARG_SHORT => {
91                if let Some(value) = iter.next() {
92                    crate_path = Some(PathBuf::from(value));
93                }
94            }
95            PORT_ARG | PORT_ARG_SHORT => {
96                if let Some(value) = iter.next()
97                    && let Ok(parsed_port) = value.parse::<u16>()
98                {
99                    port = Some(parsed_port);
100                }
101            }
102            WWW_DIR_ARG => {
103                if let Some(value) = iter.next() {
104                    www_dir = Some(value.clone());
105                }
106            }
107            INDEX_HTML_ARG => {
108                if let Some(value) = iter.next() {
109                    index_html = Some(Some(PathBuf::from(value)));
110                }
111            }
112            NO_GITIGNORE_ARG => {
113                no_gitignore = Some(true);
114            }
115            DEV_FLAG => {
116                dev = Some(true);
117            }
118            RELEASE_FLAG => {
119                release = Some(true);
120            }
121            PROFILING_FLAG => {
122                profiling = Some(true);
123            }
124            other => {
125                if let Some(value) = other.strip_prefix(&format!("{CRATE_PATH_ARG}=")) {
126                    crate_path = Some(PathBuf::from(value));
127                } else if let Some(value) = other.strip_prefix(&format!("{PORT_ARG}=")) {
128                    if let Ok(parsed_port) = value.parse::<u16>() {
129                        port = Some(parsed_port);
130                    }
131                } else if let Some(value) = other.strip_prefix(&format!("{WWW_DIR_ARG}=")) {
132                    www_dir = Some(value.to_string());
133                } else if let Some(value) = other.strip_prefix(&format!("{INDEX_HTML_ARG}=")) {
134                    index_html = Some(Some(PathBuf::from(value)));
135                }
136            }
137        }
138    }
139    if let Some(value) = crate_path {
140        args.set_crate_path(value);
141    }
142    if let Some(value) = port {
143        args.set_port(value);
144    }
145    if let Some(value) = www_dir {
146        args.set_www_dir(value);
147    }
148    if let Some(value) = index_html {
149        args.set_index_html(value);
150    }
151    if let Some(value) = no_gitignore {
152        args.set_no_gitignore(value);
153    }
154    if let Some(value) = dev {
155        args.set_dev(value);
156    }
157    if let Some(value) = release {
158        args.set_release(value);
159    }
160    if let Some(value) = profiling {
161        args.set_profiling(value);
162    }
163}
164
165/// Resolves the build mode from CLI arguments.
166///
167/// First checks the explicit `--dev`, `--release`, and `--profiling` flags on `ModeArgs`.
168/// If none of those are set, inspects `wasm_pack_args` for any build mode flag
169/// that may have been forwarded by the user.
170/// Defaults to `BuildMode::Dev` if no build mode flag is found anywhere.
171///
172/// # Arguments
173///
174/// - `&ModeArgs` - The CLI arguments containing the build mode flags and wasm_pack_args.
175///
176/// # Returns
177///
178/// - `BuildMode` - The resolved build mode.
179pub fn resolve_build_mode(args: &ModeArgs) -> BuildMode {
180    if args.get_profiling() {
181        BuildMode::Profiling
182    } else if args.get_release() {
183        BuildMode::Release
184    } else if args.get_dev() {
185        BuildMode::Dev
186    } else if args
187        .get_wasm_pack_args()
188        .iter()
189        .any(|arg: &String| arg == PROFILING_FLAG)
190    {
191        BuildMode::Profiling
192    } else if args
193        .get_wasm_pack_args()
194        .iter()
195        .any(|arg: &String| arg == RELEASE_FLAG)
196    {
197        BuildMode::Release
198    } else {
199        BuildMode::Dev
200    }
201}
202
203/// Converts a `BuildMode` to the corresponding wasm-pack flag string.
204///
205/// # Arguments
206///
207/// - `BuildMode` - The build mode to convert.
208///
209/// # Returns
210///
211/// - `&'static str` - The wasm-pack command-line flag.
212pub fn build_mode_to_flag(build_mode: BuildMode) -> &'static str {
213    match build_mode {
214        BuildMode::Dev => DEV_FLAG,
215        BuildMode::Release => RELEASE_FLAG,
216        BuildMode::Profiling => PROFILING_FLAG,
217    }
218}
219
220/// Builds a `Gitignore` matcher from the `.gitignore` file at the given root path.
221///
222/// # Arguments
223///
224/// - `&PathBuf` - The root directory where `.gitignore` is located.
225///
226/// # Returns
227///
228/// - `Gitignore` - The compiled gitignore matcher.
229async fn build_gitignore(root: &PathBuf) -> Gitignore {
230    let gitignore_path: PathBuf = root.join(GITIGNORE_FILE_NAME);
231    let mut builder: GitignoreBuilder = GitignoreBuilder::new(root);
232    let gitignore_exists: bool = metadata(&gitignore_path).await.is_ok();
233    if gitignore_exists && let Some(error) = builder.add(&gitignore_path) {
234        log::warn!("Failed to load .gitignore: {error}");
235    }
236    match builder.build() {
237        Ok(gitignore) => {
238            if gitignore_exists {
239                log::info!("Loaded .gitignore to filter file change events");
240            }
241            gitignore
242        }
243        Err(error) => {
244            log::warn!("Failed to build gitignore matcher: {error}");
245            GitignoreBuilder::new(root)
246                .build()
247                .unwrap_or_else(|_error: ignore::Error| Gitignore::empty())
248        }
249    }
250}
251
252/// Extracts the value of `--out-name` from the wasm-pack arguments.
253///
254/// Returns `None` if `--out-name` is not specified.
255///
256/// # Arguments
257///
258/// - `&[String]` - The wasm-pack arguments to search.
259///
260/// # Returns
261///
262/// - `Option<String>` - The value of `--out-name` if found.
263fn extract_out_name(wasm_pack_args: &[String]) -> Option<String> {
264    let mut iter = wasm_pack_args.iter();
265    while let Some(arg) = iter.next() {
266        if arg == OUT_NAME_ARG {
267            return iter.next().cloned();
268        }
269        if let Some(value) = arg.strip_prefix(&format!("{OUT_NAME_ARG}=")) {
270            return Some(value.to_string());
271        }
272    }
273    None
274}
275
276/// Extracts the value of `--out-dir` from the wasm-pack arguments.
277///
278/// Returns `None` if `--out-dir` is not specified.
279///
280/// # Arguments
281///
282/// - `&[String]` - The wasm-pack arguments to search.
283///
284/// # Returns
285///
286/// - `Option<String>` - The value of `--out-dir` if found.
287fn extract_out_dir(wasm_pack_args: &[String]) -> Option<String> {
288    let mut iter = wasm_pack_args.iter();
289    while let Some(arg) = iter.next() {
290        if arg == OUT_DIR_ARG {
291            return iter.next().cloned();
292        }
293        if let Some(value) = arg.strip_prefix(&format!("{OUT_DIR_ARG}=")) {
294            return Some(value.to_string());
295        }
296    }
297    None
298}
299
300/// Resolves the output JS filename for HTML generation.
301///
302/// Uses `--out-name` from wasm-pack args if specified,
303/// otherwise reads the crate name from `Cargo.toml` `[package] name` field
304/// and replaces hyphens with underscores (matching wasm-pack behavior).
305/// Appends `.js` extension to form the complete JS filename.
306///
307/// # Arguments
308///
309/// - `&ModeArgs` - The CLI arguments containing crate_path and wasm_pack_args.
310///
311/// # Returns
312///
313/// - `String` - The resolved JS filename with `.js` extension (e.g. `euv_example.js`).
314pub fn resolve_out_name(args: &ModeArgs) -> String {
315    let name: String = if let Some(out_name) = extract_out_name(args.get_wasm_pack_args()) {
316        out_name
317    } else {
318        let cargo_toml_path: PathBuf = args.get_crate_path().join(CARGO_TOML_FILE_NAME);
319        read_crate_name_from_toml(&cargo_toml_path).unwrap_or_else(|| {
320            args.get_crate_path()
321                .file_name()
322                .unwrap_or_default()
323                .to_string_lossy()
324                .to_string()
325        })
326    };
327    format!("{name}{JS_EXTENSION}")
328}
329
330/// Reads the `name` field from a Cargo.toml file.
331///
332/// Parses the file line-by-line looking for `name = "..."` within the `[package]` section.
333///
334/// # Arguments
335///
336/// - `&Path` - The path to the Cargo.toml file.
337///
338/// # Returns
339///
340/// - `Option<String>` - The crate name if found.
341fn read_crate_name_from_toml(path: &Path) -> Option<String> {
342    let content: String = std::fs::read_to_string(path).ok()?;
343    let mut in_package: bool = false;
344    for line in content.lines() {
345        let trimmed: &str = line.trim();
346        if trimmed.starts_with('[') {
347            in_package = trimmed == "[package]";
348            continue;
349        }
350        if in_package
351            && trimmed.starts_with("name")
352            && let Some(value) = trimmed.strip_prefix("name")
353        {
354            let value: &str = value.trim().strip_prefix('=')?.trim();
355            let value: &str = value.strip_prefix('"')?.strip_suffix('"')?;
356            return Some(value.to_string());
357        }
358    }
359    None
360}
361
362/// Resolves the JS import path for HTML generation.
363///
364/// Computes the relative path from the www directory to the output directory,
365/// then appends the JS filename (from `resolve_out_name`, which includes `.js`)
366/// to form the full import path (e.g. `./pkg/euv.js` or `./euv.js`).
367///
368/// # Arguments
369///
370/// - `&ModeArgs` - The CLI arguments containing crate_path, www_dir, wasm_pack_args.
371///
372/// # Returns
373///
374/// - `String` - The resolved JS import path relative to the www directory.
375pub fn resolve_import_path(args: &ModeArgs) -> String {
376    let out_name: String = resolve_out_name(args);
377    let www_absolute: PathBuf = args.get_crate_path().join(args.get_www_dir());
378    let out_dir_absolute: PathBuf = resolve_out_dir(args);
379    let relative: PathBuf = match out_dir_absolute.strip_prefix(&www_absolute) {
380        Ok(rel) => rel.to_path_buf(),
381        Err(_) => out_dir_absolute,
382    };
383    let mut components: Vec<String> = relative
384        .components()
385        .filter_map(|component: Component| match component {
386            Component::Normal(os_str) => os_str.to_str().map(|text: &str| text.to_string()),
387            _ => None,
388        })
389        .collect();
390    components.push(out_name);
391    format!("{RELATIVE_PATH_PREFIX}{}", components.join(PATH_SEPARATOR))
392}
393
394/// Resolves the output directory for wasm-pack artifacts.
395///
396/// Uses `--out-dir` from wasm-pack args if specified,
397/// otherwise defaults to `{www_dir}/pkg` so that build artifacts
398/// are placed directly inside the www directory served
399/// by the development server.
400///
401/// # Arguments
402///
403/// - `&ModeArgs` - The CLI arguments containing crate_path, www_dir, and wasm_pack_args.
404///
405/// # Returns
406///
407/// - `PathBuf` - The resolved output directory (absolute if crate_path is joined).
408pub fn resolve_out_dir(args: &ModeArgs) -> PathBuf {
409    let out_dir_path: PathBuf = PathBuf::from(
410        extract_out_dir(args.get_wasm_pack_args())
411            .unwrap_or_else(|| format!("{}/{PKG_DIR_NAME}", args.get_www_dir())),
412    );
413    if out_dir_path.is_absolute() {
414        out_dir_path
415    } else {
416        args.get_crate_path().join(&out_dir_path)
417    }
418}
419
420/// Executes a build-only pipeline: formats euv macros, cleans output directory,
421/// builds WASM, and generates HTML.
422///
423/// Unlike `run_build_pipeline`, this cleans the output directory before building
424/// and skips reload notifications — only the essential WASM build artifacts are kept.
425///
426/// # Arguments
427///
428/// - `&ModeArgs` - The CLI arguments.
429///
430/// # Returns
431///
432/// - `Result<(), EuvError>` - Indicates success or failure of the build.
433pub async fn run_build_only_pipeline(args: &ModeArgs) -> Result<(), EuvError> {
434    let src_path: PathBuf = args.get_crate_path().join(SRC_DIR_NAME);
435    if let Err(error) = format_dir(&src_path, FmtMode::Write).await {
436        log::warn!("euv fmt error: {error}");
437    }
438    let out_dir: PathBuf = resolve_out_dir(args);
439    clean_out_dir(&out_dir).await;
440    build_wasm(args).await?;
441    log::info!("WASM build completed successfully");
442    let www_dir: PathBuf = resolve_www_dir_from_args(args).await;
443    let import_path: String = resolve_import_path(args);
444    let is_release: bool = resolve_build_mode(args) == BuildMode::Release;
445    let custom_html: &Option<PathBuf> = args.try_get_index_html();
446    generate_html(&www_dir, &import_path, is_release, custom_html).await?;
447    Ok(())
448}
449
450/// Cleans the output directory before a fresh build.
451///
452/// Removes all files and subdirectories within the output directory
453/// so that stale artifacts from previous builds do not remain.
454/// The directory itself is preserved (recreated if missing).
455///
456/// # Arguments
457///
458/// - `&Path` - The output directory to clean.
459pub async fn clean_out_dir(out_dir: &Path) {
460    let mut entries: ReadDir = match read_dir(out_dir).await {
461        Ok(dir) => dir,
462        Err(_) => return,
463    };
464    while let Ok(Some(entry)) = entries.next_entry().await {
465        let path: PathBuf = entry.path();
466        if path.is_dir() {
467            if let Err(error) = remove_dir_all(&path).await {
468                log::warn!("Failed to remove directory '{}': {error}", path.display());
469            }
470        } else if let Err(error) = remove_file(&path).await {
471            log::warn!("Failed to remove file '{}': {error}", path.display());
472        }
473    }
474}
475
476/// Executes a full build pipeline: euv fmt, build wasm, generate HTML.
477/// After the serial pipeline completes, hyperlane-cli fmt is spawned in the
478/// background so it does not block the caller.
479/// Notifies the reload channel on build success or failure.
480///
481/// # Arguments
482///
483/// - `&ModeArgs` - The CLI arguments.
484/// - `Option<&broadcast::Sender<ReloadEvent>>` - Optional reload channel for notifying clients.
485///
486/// # Returns
487///
488/// - `Result<String, EuvError>` - The generated HTML with reload script injected on success.
489pub async fn run_build_pipeline(
490    args: &ModeArgs,
491    reload_tx: Option<&broadcast::Sender<ReloadEvent>>,
492) -> Result<String, EuvError> {
493    let src_path: PathBuf = args.get_crate_path().join(SRC_DIR_NAME);
494    if let Err(error) = format_dir(&src_path, FmtMode::Write).await {
495        log::warn!("euv fmt error: {error}");
496    }
497    match build_wasm(args).await {
498        Ok(()) => {
499            log::info!("WASM build completed successfully");
500            if let Some(sender) = reload_tx {
501                let _ = sender.send(ReloadEvent::Reload);
502            }
503        }
504        Err(error) => {
505            log::error!("WASM build failed: {error}");
506            if let Some(sender) = reload_tx {
507                let _ = sender.send(ReloadEvent::Error(error.to_string()));
508            }
509        }
510    }
511    let www_dir: PathBuf = resolve_www_dir_from_args(args).await;
512    let import_path: String = resolve_import_path(args);
513    let is_release: bool = resolve_build_mode(args) == BuildMode::Release;
514    let custom_html: &Option<PathBuf> = args.try_get_index_html();
515    let html: String = generate_html(&www_dir, &import_path, is_release, custom_html).await?;
516    spawn(async move {
517        if let Err(error) = run_hyperlane_fmt().await {
518            log::warn!("hyperlane-cli fmt error: {error}");
519        }
520    });
521    Ok(html)
522}
523
524/// Resolves the www directory from CLI arguments.
525///
526/// # Arguments
527///
528/// - `&ModeArgs` - The CLI arguments.
529///
530/// # Returns
531///
532/// - `PathBuf` - The resolved www directory.
533async fn resolve_www_dir_from_args(args: &ModeArgs) -> PathBuf {
534    let www_absolute: PathBuf = args.get_crate_path().join(args.get_www_dir());
535    resolve_www_dir(&www_absolute).await
536}
537
538/// Watches source files and triggers WASM builds.
539///
540/// # Arguments
541///
542/// - `Arc<AppState>` - The shared application state.
543///
544/// # Returns
545///
546/// - `Result<(), EuvError>` - Indicates success or failure of the file watcher.
547pub async fn watch_and_build(state: Arc<AppState>) -> Result<(), EuvError> {
548    let crate_path: PathBuf = state.get_args().get_crate_path().clone();
549    let src_path: PathBuf = crate_path.join(SRC_DIR_NAME);
550    let gitignore: Gitignore = build_gitignore(&crate_path).await;
551    let (tx, mut rx): (Sender<Event>, Receiver<Event>) = channel(32);
552    let mut watcher: RecommendedWatcher = RecommendedWatcher::new(
553        move |result: Result<Event, notify::Error>| {
554            if let Ok(event) = result {
555                let _ = tx.blocking_send(event);
556            }
557        },
558        Config::default(),
559    )?;
560    watcher.watch(&src_path, RecursiveMode::Recursive)?;
561    log::info!("Watching {} for changes...", src_path.display());
562    let mut debounce: Interval = interval(Duration::from_millis(500));
563    debounce.tick().await;
564    while let Some(event) = rx.recv().await {
565        let filtered_paths: Vec<String> = event
566            .paths
567            .iter()
568            .filter(|path: &&PathBuf| !gitignore.matched(*path, path.is_dir()).is_ignore())
569            .map(|path: &PathBuf| path.display().to_string())
570            .collect();
571        if filtered_paths.is_empty() {
572            continue;
573        }
574        log::warn!("File change detected: {}", filtered_paths.join(", "));
575        debounce.reset();
576        sleep(Duration::from_millis(300)).await;
577        let mut building: RwLockWriteGuard<bool> = state.get_is_building().write().await;
578        if *building {
579            continue;
580        }
581        *building = true;
582        drop(building);
583        let state_for_build: Arc<AppState> = Arc::clone(&state);
584        spawn(async move {
585            let args: ModeArgs = state_for_build.get_args().clone();
586            let reload_tx: broadcast::Sender<ReloadEvent> = state_for_build.get_reload_tx().clone();
587            match run_build_pipeline(&args, Some(&reload_tx)).await {
588                Ok(html) => {
589                    let mut content: RwLockWriteGuard<String> =
590                        state_for_build.get_html_content().write().await;
591                    *content = html;
592                }
593                Err(error) => {
594                    log::error!("Build pipeline error: {error}");
595                }
596            }
597            let mut building: RwLockWriteGuard<bool> =
598                state_for_build.get_is_building().write().await;
599            *building = false;
600        });
601    }
602    Ok(())
603}
604
605/// Runs wasm-pack build for the target crate.
606///
607/// All arguments in `args.wasm_pack_args` are transparently forwarded
608/// to `wasm-pack build`. If `--out-dir` is not specified by the user,
609/// `--out-dir {www_dir}/pkg` is automatically injected so that build artifacts
610/// are placed inside the www directory served by the development server.
611///
612/// # Arguments
613///
614/// - `&ModeArgs` - The CLI arguments containing crate_path, www_dir, and wasm_pack_args.
615///
616/// # Returns
617///
618/// - `Result<(), EuvError>` - Indicates success or failure of the wasm-pack build.
619pub async fn build_wasm(args: &ModeArgs) -> Result<(), EuvError> {
620    let build_mode: BuildMode = resolve_build_mode(args);
621    let build_mode_flag: &str = build_mode_to_flag(build_mode);
622    let filtered_args: Vec<String> = filter_euv_args(args.get_wasm_pack_args());
623    let has_existing_build_mode: bool = has_build_mode_flag(&filtered_args);
624    let default_out_dir: String = format!("{}/{PKG_DIR_NAME}", args.get_www_dir());
625    let mut command: Command = Command::new(WASM_PACK_COMMAND);
626    command.arg(WASM_PACK_BUILD_SUBCOMMAND);
627    if !has_existing_build_mode {
628        command.arg(build_mode_flag);
629    }
630    command
631        .args(&filtered_args)
632        .env(RUST_MIN_STACK_ENV, RUST_MIN_STACK_VALUE);
633    let has_out_dir: bool = extract_out_dir(&filtered_args).is_some();
634    if !has_out_dir {
635        command.arg(OUT_DIR_ARG).arg(&default_out_dir);
636    }
637    let has_target: bool = filtered_args
638        .iter()
639        .any(|arg: &String| arg == TARGET_ARG || arg.starts_with(&format!("{TARGET_ARG}=")));
640    if !has_target {
641        command.arg(TARGET_ARG).arg(TARGET_WEB);
642    }
643    command.current_dir(args.get_crate_path());
644    command.stdout(Stdio::piped()).stderr(Stdio::piped());
645    let display_args: Vec<String> = (if has_existing_build_mode {
646        filtered_args.to_vec()
647    } else {
648        std::iter::once(build_mode_flag.to_string())
649            .chain(filtered_args.iter().cloned())
650            .collect::<Vec<String>>()
651    })
652    .into_iter()
653    .chain(if has_out_dir {
654        Vec::new()
655    } else {
656        vec![OUT_DIR_ARG.to_string(), default_out_dir.clone()]
657    })
658    .chain(if has_target {
659        Vec::new()
660    } else {
661        vec![TARGET_ARG.to_string(), TARGET_WEB.to_string()]
662    })
663    .collect();
664    let out_dir_absolute: PathBuf = resolve_out_dir(args);
665    create_dir_all(&out_dir_absolute)
666        .await
667        .map_err(|error: std::io::Error| EuvError::IoPath {
668            message: String::from("Failed to create output directory"),
669            path: out_dir_absolute.clone(),
670            error,
671        })?;
672    log::info!(
673        "Running: {WASM_PACK_COMMAND} {WASM_PACK_BUILD_SUBCOMMAND} {} ...",
674        display_args.join(" ")
675    );
676    let output: Output = command
677        .output()
678        .await
679        .map_err(|error: std::io::Error| EuvError::Io {
680            message: String::from("Failed to execute wasm-pack"),
681            error,
682        })?;
683    let stdout: String = String::from_utf8_lossy(&output.stdout).to_string();
684    let stderr: String = String::from_utf8_lossy(&output.stderr).to_string();
685    if args.get_no_gitignore() {
686        let gitignore_path: PathBuf = out_dir_absolute.join(GITIGNORE_FILE_NAME);
687        if gitignore_path.exists()
688            && let Err(error) = remove_file(&gitignore_path).await
689        {
690            log::warn!("Failed to remove '{}': {error}", gitignore_path.display());
691        }
692    }
693    for line in stdout.lines().filter(|line: &&str| !line.is_empty()) {
694        log::info!("{line}");
695    }
696    if output.status.success() {
697        for line in stderr.lines().filter(|line: &&str| !line.is_empty()) {
698            log::info!("{line}");
699        }
700    } else {
701        for line in stderr.lines().filter(|line: &&str| !line.is_empty()) {
702            log::error!("{line}");
703        }
704        return Err(EuvError::Message(String::from("wasm-pack build failed")));
705    }
706    Ok(())
707}
708
709/// Prints the startup banner and command information.
710///
711/// # Arguments
712///
713/// - `Action` - The action to perform (run or build).
714pub fn print_banner(action: Action) {
715    let version: &str = env!("CARGO_PKG_VERSION");
716    if version.is_empty() {
717        log::warn!("Failed to parse version from root Cargo.toml");
718    } else {
719        log::info!("euv v{version}");
720    }
721    let action_name: &str = match action {
722        Action::Run => ACTION_RUN,
723        Action::Build => ACTION_BUILD,
724    };
725    log::info!("Mode: {action_name}");
726    log::info!(
727        "Use .gitignore to filter file change events; pass --no-gitignore to remove .gitignore from output"
728    );
729}
730
731/// Enumerates all network interface IP addresses and prints each server URL
732/// along with its corresponding QR code to the console.
733///
734/// Includes both loopback (127.0.0.1) and all private/public IPv4 addresses
735/// bound to the host's network interfaces. Each address produces one URL line
736/// followed by a Unicode QR code rendered with half-block characters,
737/// where every line carries the standard log prefix (timestamp + level).
738///
739/// # Arguments
740///
741/// - `u16` - The port number the server is listening on.
742/// - `&str` - The www route prefix (e.g. "www").
743/// - `&str` - The index HTML file name (e.g. "index.html").
744pub fn print_server_urls(port: u16, www_route_prefix: &str, index_html_file_name: &str) {
745    let mut addresses: Vec<std::net::IpAddr> = Vec::new();
746    match if_addrs::get_if_addrs() {
747        Ok(interfaces) => {
748            for interface in interfaces {
749                let ip: std::net::IpAddr = interface.addr.ip();
750                if !addresses.contains(&ip) {
751                    addresses.push(ip);
752                }
753            }
754        }
755        Err(error) => {
756            log::warn!("Failed to enumerate network interfaces: {error}");
757        }
758    }
759    if addresses.is_empty() {
760        addresses.push(std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST));
761    }
762    for ip in addresses {
763        let host: String = match ip {
764            std::net::IpAddr::V6(_) => format!("[{ip}]"),
765            std::net::IpAddr::V4(_) => format!("{ip}"),
766        };
767        let url: String =
768            format!("{HTTP_SCHEME}://{host}:{port}/{www_route_prefix}/{index_html_file_name}");
769        log::info!("Server: {url}");
770        match QrCode::new(url.as_str()) {
771            Ok(code) => {
772                let string: String = code.render::<Dense1x2>().quiet_zone(false).build();
773                for line in string.lines() {
774                    log::info!("{line}");
775                }
776            }
777            Err(error) => {
778                log::warn!("Failed to generate QR code: {error}");
779            }
780        }
781    }
782}
783
784/// Executes `hyperlane-cli fmt` via the library API to format Rust source files.
785///
786/// # Returns
787///
788/// - `Result<(), EuvError>` - Indicates success or failure of the formatting operation.
789pub async fn run_hyperlane_fmt() -> Result<(), EuvError> {
790    let args: hyperlane_cli::Args = hyperlane_cli::Args {
791        command: hyperlane_cli::CommandType::Fmt,
792        check: false,
793        manifest_path: None,
794        bump_type: None,
795        max_retries: 0,
796        project_name: None,
797        template_type: None,
798        model_sub_type: None,
799        component_name: None,
800    };
801    hyperlane_cli::execute_fmt(&args)
802        .await
803        .map_err(|error: std::io::Error| EuvError::Io {
804            message: String::from("hyperlane-cli fmt error"),
805            error,
806        })
807}
euv_cli/build/fn.rs

euv_cli/build/
fn.rs
