Skip to main content

paper/cli/
models.rs

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
9/// Per-model install/removal guard.
10///
11/// Serializes concurrent `paper models install` / `paper models remove` calls
12/// for the same model so they cannot race on the shared model directory or its
13/// `.partial` download files. Different models proceed in parallel.
14static MODEL_INSTALL_LOCKS: OnceLock<StdMutex<HashMap<String, Arc<StdMutex<()>>>>> =
15    OnceLock::new();
16
17/// Returns a lock unique to `model_id`, creating it on first use.
18fn 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            // Serialize installs of the same model so concurrent calls cannot
57            // race on the model directory / `.partial` files (M14).
58            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            // Aggregate progress bar for the whole model
65            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                // GitHub Releases first, Hugging Face as fallback (see
80                // `ModelSpec::download_urls`). ModelDownloader verifies the
81                // same SHA256 pin regardless of source.
82                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                // Update aggregate progress
103                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            // Update installed cache via is_installed (which caches on success)
114            let _ = manager.is_installed(&model);
115        }
116        ModelsCommand::Remove { model } => {
117            // Serialize removals of the same model so an install and a remove
118            // cannot race on the model directory / `.partial` files (M14).
119            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}