1use super::{ModelsArgs, ModelsCommand, EXIT_ERROR, EXIT_FOUND};
2use crate::cli::model_downloader::ModelDownloader;
3use crate::core::models::ModelManager;
4use anyhow::{Context, Result};
5use indicatif::{ProgressBar, ProgressStyle};
6use std::collections::HashMap;
7use std::sync::{Arc, Mutex as StdMutex, OnceLock};
8
9static MODEL_INSTALL_LOCKS: OnceLock<StdMutex<HashMap<String, Arc<StdMutex<()>>>>> =
15 OnceLock::new();
16
17fn model_install_lock(model_id: &str) -> Arc<StdMutex<()>> {
19 let mut map = MODEL_INSTALL_LOCKS
20 .get_or_init(|| StdMutex::new(HashMap::new()))
21 .lock()
22 .expect("model install lock map poisoned");
23 map.entry(model_id.to_string())
24 .or_insert_with(|| Arc::new(StdMutex::new(())))
25 .clone()
26}
27
28pub async fn run(args: ModelsArgs) -> Result<i32> {
29 let manager = ModelManager::new();
30 match args.command {
31 ModelsCommand::List => {
32 println!(
33 "{:<24} {:>7} {:<9} {:<16} DESCRIPTION",
34 "MODEL", "SIZE", "INSTALLED", "LANGUAGES"
35 );
36 for m in manager.list() {
37 println!(
38 "{:<24} {:>5}MB {:<9} {:<16} {}{}",
39 m.id,
40 m.size_mb,
41 if m.installed { "yes" } else { "no" },
42 m.languages,
43 m.name,
44 if m.is_default { " [default]" } else { "" }
45 );
46 }
47 }
48 ModelsCommand::Install { model } => {
49 if !cfg!(feature = "embeddings") {
50 eprintln!(
51 "this build has no embedding support: rebuild with --features embeddings \
52 (keyword search works without it)"
53 );
54 return Ok(EXIT_ERROR);
55 }
56 let _install_guard = model_install_lock(&model);
59
60 let spec = manager.spec(&model)?;
61 let model_dir = manager.model_dir(&model);
62 tokio::fs::create_dir_all(&model_dir).await?;
63
64 let total_size = spec.size_bytes();
66 let aggregate_pb = ProgressBar::new(total_size);
67 aggregate_pb.set_style(
68 ProgressStyle::with_template(
69 "{msg} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({bytes_per_sec}, {eta})",
70 )
71 .unwrap_or_else(|_| ProgressStyle::default_bar())
72 .progress_chars("##-"),
73 );
74 aggregate_pb.set_message(format!("Downloading {} ({} MB)", model, spec.size_mb()));
75
76 for file in spec.files {
77 let dest = model_dir.join(file.name);
78
79 let mut last_error = None;
83 for url in spec.download_urls(file.name) {
84 let downloader =
85 ModelDownloader::new(url, dest.clone(), file.sha256.to_string(), file.size);
86 match downloader.download_with_progress().await {
87 Ok(()) => {
88 last_error = None;
89 break;
90 }
91 Err(e) => {
92 eprintln!("download failed, trying next source: {e:#}");
93 last_error = Some(e);
94 }
95 }
96 }
97 if let Some(e) = last_error {
98 return Err(e)
99 .with_context(|| format!("failed to download {}/{}", model, file.name));
100 }
101
102 aggregate_pb.inc(file.size);
104 }
105
106 aggregate_pb.finish_with_message(format!(
107 "Installed {} at {}",
108 model,
109 model_dir.display()
110 ));
111 println!("installed {} at {}", model, model_dir.display());
112
113 let _ = manager.is_installed(&model);
115 }
116 ModelsCommand::Remove { model } => {
117 let _remove_guard = model_install_lock(&model);
120
121 if manager.spec(&model).is_err() {
122 eprintln!("unknown model: {model}");
123 return Ok(EXIT_ERROR);
124 }
125 manager.remove(&model).await?;
126 println!("removed {model}");
127 }
128 }
129 Ok(EXIT_FOUND)
130}