Skip to main content

infinity_agent_cli/
install.rs

1//! `infinity-agent-cli rap install/update` — install RAP crates and register in rap.json.
2
3use crate::inline_viewport::InlineViewport;
4use crate::term_io::{CrosstermEvents, CrosstermTerm, EventSource, TermOut as _};
5use crate::terminal;
6use infinity_agent_core::tools::config::ToolsConfig;
7use ratatui::layout::{Constraint, Layout};
8use ratatui::{
9    crossterm::event::{Event, KeyCode, KeyModifiers},
10    style::{Color, Style},
11    text::{Line, Span},
12};
13use std::io::{BufRead, BufReader};
14use std::process::{Command, Stdio};
15use tokio::sync::mpsc;
16use tokio::time::Instant;
17
18type BoxError = Box<dyn std::error::Error + Send + Sync>;
19
20pub struct InstallArgs {
21    pub crate_name: String,
22    pub git: Option<String>,
23    pub path: Option<String>,
24}
25
26/// Arguments for `infinity provider install <id> --crate ...`.
27pub struct ProviderInstallArgs {
28    /// Provider id to register in providers.json (e.g. "bedrock").
29    pub id: String,
30    pub crate_name: String,
31    pub git: Option<String>,
32    pub path: Option<String>,
33}
34
35pub use infinity_daemon::config::{load_config, providers_config_path, user_config_path};
36use infinity_daemon::models::{ProviderConfig, ProvidersConfig, load_providers_config};
37
38fn draw_spinner(
39    viewport: &mut InlineViewport<CrosstermTerm>,
40    start: &Instant,
41    status: &str,
42) -> Result<(), BoxError> {
43    viewport.draw(2, |frame| {
44        let areas =
45            Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).split(frame.area());
46        terminal::render_thinking_bar(
47            frame,
48            areas[1],
49            start,
50            status,
51            terminal::SpinnerState::Thinking,
52        );
53    })?;
54    Ok(())
55}
56
57/// Stream `cargo install` output through the TUI viewport, with Ctrl+C support.
58async fn run_cargo_install(
59    viewport: &mut InlineViewport<CrosstermTerm>,
60    crate_name: &str,
61    git: Option<&str>,
62    path: Option<&str>,
63    features: &[&str],
64) -> Result<(), BoxError> {
65    let mut cmd = Command::new("cargo");
66    cmd.arg("install");
67    cmd.env("CARGO_NET_GIT_FETCH_WITH_CLI", "true");
68    if let Some(git) = git {
69        cmd.args(["--git", git]);
70    } else if let Some(path) = path {
71        cmd.args(["--path", path]);
72    }
73    cmd.arg(crate_name);
74    cmd.arg("--force");
75    if !features.is_empty() {
76        cmd.args(["--features", &features.join(",")]);
77    }
78    cmd.stdout(Stdio::piped());
79    cmd.stderr(Stdio::piped());
80    cmd.stdin(Stdio::null());
81
82    let mut child = cmd
83        .spawn()
84        .map_err(|e| format!("failed to spawn cargo: {e}"))?;
85    let stderr = child.stderr.take().ok_or("failed to capture stderr")?;
86    let (line_tx, mut line_rx) = mpsc::unbounded_channel::<String>();
87
88    std::thread::spawn(move || {
89        for line in BufReader::new(stderr).lines().map_while(Result::ok) {
90            let _ = line_tx.send(line);
91        }
92    });
93
94    let spinner_start = Instant::now();
95    let status = format!("installing {crate_name}...");
96    draw_spinner(viewport, &spinner_start, &status)?;
97
98    let mut events = CrosstermEvents;
99
100    loop {
101        tokio::select! {
102            biased;
103            line = line_rx.recv() => {
104                match line {
105                    Some(text) => {
106                        viewport.print_line_above(
107                            Line::from(Span::styled(
108                                crate::sanitize::strip_ansi(&text),
109                                Style::default().fg(Color::DarkGray),
110                            )),
111                        )?;
112                        draw_spinner(viewport, &spinner_start, &status)?;
113                    }
114                    None => break,
115                }
116            }
117            _ = events.wait_for_event() => {
118                while let Some(event) = events.try_read_event()? {
119                    if let Event::Key(key) = event
120                        && matches!(key.code, KeyCode::Char('c'))
121                            && key.modifiers.contains(KeyModifiers::CONTROL)
122                        {
123                            let _ = child.kill();
124                            return Err("installation cancelled".into());
125                        }
126                }
127
128                draw_spinner(viewport, &spinner_start, &status)?;
129            }
130        }
131    }
132
133    let status = child.wait()?;
134    if !status.success() {
135        return Err(format!("cargo install failed (exit code: {:?})", status.code()).into());
136    }
137    Ok(())
138}
139
140pub async fn run_install(args: InstallArgs) -> Result<(), BoxError> {
141    let mut term = CrosstermTerm::new();
142    term.enable_raw_mode()?;
143    let mut viewport = InlineViewport::new(term, 2)?;
144
145    viewport.print_line_above(Line::from(Span::styled(
146        format!("Installing {}...", args.crate_name),
147        Style::default().fg(Color::Yellow),
148    )))?;
149
150    if let Err(e) = run_cargo_install(
151        &mut viewport,
152        &args.crate_name,
153        args.git.as_deref(),
154        args.path.as_deref(),
155        &[],
156    )
157    .await
158    {
159        viewport.print_line_above(Line::from(Span::styled(
160            format!("✗ {e}"),
161            Style::default().fg(Color::Red),
162        )))?;
163        viewport.draw(2, |_| {})?;
164        terminal::cleanup(viewport.term_mut())?;
165        return Err(e);
166    }
167
168    // Update user rap.json
169    let config_path = user_config_path()?;
170    if let Some(parent) = config_path.parent() {
171        std::fs::create_dir_all(parent)?;
172    }
173
174    let mut config = if config_path.exists() {
175        load_config(&config_path)?
176    } else {
177        ToolsConfig::empty() // init if empty
178    };
179
180    // Remove existing entry with same id, then re-add with source info
181    let had_existing = config
182        .tool_sets
183        .iter()
184        .any(|ts| ts.id() == Some(&args.crate_name));
185    if had_existing {
186        config
187            .tool_sets
188            .retain(|ts| ts.id() != Some(&args.crate_name));
189        viewport.print_line_above(Line::from(Span::styled(
190            format!("Replacing existing entry for {}", args.crate_name),
191            Style::default().fg(Color::Yellow),
192        )))?;
193    }
194    config.add_installed_command(
195        args.crate_name.clone(),
196        args.crate_name.clone(),
197        args.git.clone(),
198        args.path.clone().map(|p| {
199            std::fs::canonicalize(p)
200                .expect("failed to canonicalize install path")
201                .to_string_lossy()
202                .to_string()
203        }),
204    );
205    std::fs::write(&config_path, serde_json::to_string_pretty(&config)?)?;
206
207    viewport.print_line_above(Line::from(Span::styled(
208        format!(
209            "✓ Installed and registered {} in {}",
210            args.crate_name,
211            config_path.display()
212        ),
213        Style::default().fg(Color::Green),
214    )))?;
215    viewport.draw(2, |_| {})?;
216    terminal::cleanup(viewport.term_mut())?;
217    Ok(())
218}
219
220/// Install a model provider crate and register it under the given id in
221/// `~/.infinity/providers.json`. The crate's binary (assumed to share the
222/// crate's name) becomes the provider's command.
223pub async fn run_provider_install(args: ProviderInstallArgs) -> Result<(), BoxError> {
224    let mut term = CrosstermTerm::new();
225    term.enable_raw_mode()?;
226    let mut viewport = InlineViewport::new(term, 2)?;
227
228    viewport.print_line_above(Line::from(Span::styled(
229        format!(
230            "Installing {} as provider '{}'...",
231            args.crate_name, args.id
232        ),
233        Style::default().fg(Color::Yellow),
234    )))?;
235
236    if let Err(e) = run_cargo_install(
237        &mut viewport,
238        &args.crate_name,
239        args.git.as_deref(),
240        args.path.as_deref(),
241        &[],
242    )
243    .await
244    {
245        viewport.print_line_above(Line::from(Span::styled(
246            format!("✗ {e}"),
247            Style::default().fg(Color::Red),
248        )))?;
249        viewport.draw(2, |_| {})?;
250        terminal::cleanup(viewport.term_mut())?;
251        return Err(e);
252    }
253
254    // Update user providers.json (created on first install).
255    let config_path = providers_config_path()?;
256    if let Some(parent) = config_path.parent() {
257        std::fs::create_dir_all(parent)?;
258    }
259    let mut config = if config_path.exists() {
260        load_providers_config(&config_path)?
261    } else {
262        ProvidersConfig::default()
263    };
264
265    if config.get(&args.id).is_some() {
266        viewport.print_line_above(Line::from(Span::styled(
267            format!("Replacing existing entry for provider '{}'", args.id),
268            Style::default().fg(Color::Yellow),
269        )))?;
270    }
271    let canonical_path = match args.path {
272        Some(p) => Some(
273            std::fs::canonicalize(&p)
274                .map_err(|e| format!("failed to canonicalize install path {p}: {e}"))?
275                .to_string_lossy()
276                .to_string(),
277        ),
278        None => None,
279    };
280    config.upsert(
281        args.id.clone(),
282        ProviderConfig {
283            command: vec![args.crate_name.clone()],
284            crate_name: Some(args.crate_name.clone()),
285            git: args.git.clone(),
286            path: canonical_path,
287        },
288    );
289    std::fs::write(&config_path, serde_json::to_string_pretty(&config)?)?;
290
291    viewport.print_line_above(Line::from(Span::styled(
292        format!(
293            "✓ Installed and registered provider '{}' in {}",
294            args.id,
295            config_path.display()
296        ),
297        Style::default().fg(Color::Green),
298    )))?;
299    viewport.draw(2, |_| {})?;
300    terminal::cleanup(viewport.term_mut())?;
301    Ok(())
302}
303
304/// Update RAP tools, printing progress into an existing viewport. Returns names of failures.
305async fn update_rap_tools(
306    viewport: &mut InlineViewport<CrosstermTerm>,
307) -> Result<Vec<String>, BoxError> {
308    let config_path = user_config_path()?;
309    let config = if config_path.exists() {
310        load_config(&config_path)?
311    } else {
312        viewport.print_line_above(Line::from(Span::styled(
313            "No user-level RAP configuration found",
314            Style::default().fg(Color::DarkGray),
315        )))?;
316        return Ok(vec![]);
317    };
318    let installable = config.installable_commands();
319
320    if installable.is_empty() {
321        viewport.print_line_above(Line::from(Span::styled(
322            format!(
323                "No RAP tools with recorded sources in {}",
324                config_path.display()
325            ),
326            Style::default().fg(Color::DarkGray),
327        )))?;
328        return Ok(vec![]);
329    }
330
331    viewport.print_line_above(Line::from(Span::styled(
332        format!("Updating {} RAP tool(s)...", installable.len()),
333        Style::default().fg(Color::Yellow),
334    )))?;
335
336    let mut failed = Vec::new();
337    for (_command, crate_name, git, path) in &installable {
338        viewport.print_line_above(Line::from(Span::styled(
339            format!("→ Updating {crate_name}..."),
340            Style::default().fg(Color::Cyan),
341        )))?;
342        viewport.draw(2, |_| {})?;
343
344        match run_cargo_install(viewport, crate_name, git.as_deref(), path.as_deref(), &[]).await {
345            Ok(()) => {
346                viewport.print_line_above(Line::from(Span::styled(
347                    format!("  ✓ {crate_name}"),
348                    Style::default().fg(Color::Green),
349                )))?;
350            }
351            Err(e) => {
352                viewport.print_line_above(Line::from(Span::styled(
353                    format!("  ✗ {crate_name}: {e}"),
354                    Style::default().fg(Color::Red),
355                )))?;
356                failed.push(crate_name.clone());
357            }
358        }
359        viewport.draw(2, |_| {})?;
360    }
361    Ok(failed)
362}
363
364/// Update model providers that have a recorded source, printing progress
365/// into an existing viewport. Returns ids of failures.
366async fn update_providers(
367    viewport: &mut InlineViewport<CrosstermTerm>,
368) -> Result<Vec<String>, BoxError> {
369    let config_path = providers_config_path()?;
370    if !config_path.exists() {
371        viewport.print_line_above(Line::from(Span::styled(
372            "No model providers configuration found",
373            Style::default().fg(Color::DarkGray),
374        )))?;
375        return Ok(vec![]);
376    }
377    let config = load_providers_config(&config_path)?;
378    let installable: Vec<(String, String, Option<String>, Option<String>)> = config
379        .providers
380        .iter()
381        .filter_map(|(id, provider)| {
382            provider.crate_name.as_ref().map(|crate_name| {
383                (
384                    id.clone(),
385                    crate_name.clone(),
386                    provider.git.clone(),
387                    provider.path.clone(),
388                )
389            })
390        })
391        .collect();
392
393    if installable.is_empty() {
394        viewport.print_line_above(Line::from(Span::styled(
395            format!(
396                "No model providers with recorded sources in {}",
397                config_path.display()
398            ),
399            Style::default().fg(Color::DarkGray),
400        )))?;
401        return Ok(vec![]);
402    }
403
404    viewport.print_line_above(Line::from(Span::styled(
405        format!("Updating {} model provider(s)...", installable.len()),
406        Style::default().fg(Color::Yellow),
407    )))?;
408
409    let mut failed = Vec::new();
410    for (id, crate_name, git, path) in &installable {
411        viewport.print_line_above(Line::from(Span::styled(
412            format!("→ Updating provider '{id}' ({crate_name})..."),
413            Style::default().fg(Color::Cyan),
414        )))?;
415        viewport.draw(2, |_| {})?;
416
417        match run_cargo_install(viewport, crate_name, git.as_deref(), path.as_deref(), &[]).await {
418            Ok(()) => {
419                viewport.print_line_above(Line::from(Span::styled(
420                    format!("  ✓ {id}"),
421                    Style::default().fg(Color::Green),
422                )))?;
423            }
424            Err(e) => {
425                viewport.print_line_above(Line::from(Span::styled(
426                    format!("  ✗ {id}: {e}"),
427                    Style::default().fg(Color::Red),
428                )))?;
429                failed.push(id.clone());
430            }
431        }
432        viewport.draw(2, |_| {})?;
433    }
434    Ok(failed)
435}
436
437/// After an update, ensure the daemon runs the freshly installed binaries:
438/// boot one if none is running, or warn that the running instance is still
439/// executing pre-update code and needs `infinity daemon restart`. Returns
440/// `Ok(false)` if the daemon needed to be started but failed to boot (the
441/// error is printed to the viewport), so callers can reflect it in their
442/// exit code after cleaning up the terminal.
443async fn ensure_fresh_daemon(
444    viewport: &mut InlineViewport<CrosstermTerm>,
445) -> Result<bool, BoxError> {
446    if let Some(pid) = crate::daemon_client::running_daemon_pid() {
447        viewport.print_line_above(Line::from(Span::styled(
448            format!(
449                "⚠ The daemon (pid {pid}) is still running the previous version — run `infinity daemon restart` to pick up the update"
450            ),
451            Style::default().fg(Color::Yellow),
452        )))?;
453        return Ok(true);
454    }
455
456    viewport.print_line_above(Line::from(Span::styled(
457        "Daemon is not running — starting it...",
458        Style::default().fg(Color::Yellow),
459    )))?;
460    viewport.draw(2, |_| {})?;
461    match crate::daemon_client::launch_daemon().await {
462        Ok(()) => {
463            viewport.print_line_above(Line::from(Span::styled(
464                "✓ Daemon started",
465                Style::default().fg(Color::Green),
466            )))?;
467            Ok(true)
468        }
469        Err(e) => {
470            viewport.print_line_above(Line::from(Span::styled(
471                format!("✗ Failed to start daemon: {e}"),
472                Style::default().fg(Color::Red),
473            )))?;
474            Ok(false)
475        }
476    }
477}
478
479/// `infinity provider update` — re-install all providers with recorded sources.
480pub async fn run_provider_update() -> Result<(), BoxError> {
481    let mut term = CrosstermTerm::new();
482    term.enable_raw_mode()?;
483    let mut viewport = InlineViewport::new(term, 2)?;
484
485    let failed = update_providers(&mut viewport).await?;
486    let daemon_ok = ensure_fresh_daemon(&mut viewport).await?;
487
488    let summary = if failed.is_empty() {
489        Span::styled("✓ All providers updated", Style::default().fg(Color::Green))
490    } else {
491        Span::styled(
492            format!("✗ {} provider(s) failed to update", failed.len()),
493            Style::default().fg(Color::Red),
494        )
495    };
496    viewport.print_line_above(Line::from(summary))?;
497    viewport.draw(2, |_| {})?;
498    terminal::cleanup(viewport.term_mut())?;
499
500    if !failed.is_empty() {
501        Err("some providers failed to update".into())
502    } else if !daemon_ok {
503        Err("failed to start daemon after update".into())
504    } else {
505        Ok(())
506    }
507}
508
509/// Returns the list of cargo features this binary was compiled with.
510fn installed_features() -> Vec<&'static str> {
511    let mut features = Vec::new();
512    if cfg!(feature = "bundled-web") {
513        features.push("bundled-web");
514    }
515    features
516}
517
518/// Update the CLI binary itself, printing progress into an existing viewport.
519async fn update_cli(
520    viewport: &mut InlineViewport<CrosstermTerm>,
521    features: &[&str],
522) -> Result<(), BoxError> {
523    let (git, path) = detect_install_source()?;
524
525    viewport.print_line_above(Line::from(Span::styled(
526        "Updating infinity-agent-cli...",
527        Style::default().fg(Color::Yellow),
528    )))?;
529
530    if let Err(e) = run_cargo_install(
531        viewport,
532        "infinity-agent-cli",
533        git.as_deref(),
534        path.as_deref(),
535        features,
536    )
537    .await
538    {
539        viewport.print_line_above(Line::from(Span::styled(
540            format!("✗ {e}"),
541            Style::default().fg(Color::Red),
542        )))?;
543        return Err(e);
544    }
545
546    viewport.print_line_above(Line::from(Span::styled(
547        "✓ infinity-agent-cli updated",
548        Style::default().fg(Color::Green),
549    )))?;
550    Ok(())
551}
552
553pub async fn run_update() -> Result<(), BoxError> {
554    let mut term = CrosstermTerm::new();
555    term.enable_raw_mode()?;
556    let mut viewport = InlineViewport::new(term, 2)?;
557
558    let failed = update_rap_tools(&mut viewport).await?;
559    let daemon_ok = ensure_fresh_daemon(&mut viewport).await?;
560
561    let summary = if failed.is_empty() {
562        Span::styled("✓ All tools updated", Style::default().fg(Color::Green))
563    } else {
564        Span::styled(
565            format!("✗ {} tool(s) failed to update", failed.len()),
566            Style::default().fg(Color::Red),
567        )
568    };
569    viewport.print_line_above(Line::from(summary))?;
570    viewport.draw(2, |_| {})?;
571    terminal::cleanup(viewport.term_mut())?;
572
573    if !failed.is_empty() {
574        Err("some tools failed to update".into())
575    } else if !daemon_ok {
576        Err("failed to start daemon after update".into())
577    } else {
578        Ok(())
579    }
580}
581
582/// Detect how `infinity-agent-cli` was originally installed by reading
583/// `~/.cargo/.crates2.json`. Returns `(git, path)` — both None means registry.
584fn detect_install_source() -> Result<(Option<String>, Option<String>), BoxError> {
585    let home = dirs::home_dir().ok_or("could not determine home directory")?;
586    let crates_file = home.join(".cargo").join(".crates2.json");
587    let data = std::fs::read_to_string(&crates_file)
588        .map_err(|e| format!("failed to read {}: {e}", crates_file.display()))?;
589    let json: serde_json::Value =
590        serde_json::from_str(&data).map_err(|e| format!("failed to parse .crates2.json: {e}"))?;
591    let installs = json
592        .get("installs")
593        .and_then(|v| v.as_object())
594        .ok_or("unexpected .crates2.json format")?;
595
596    let key = installs
597        .keys()
598        .find(|k| k.starts_with("infinity-agent-cli "))
599        .ok_or(
600            "infinity-agent-cli not found in .crates2.json — was it installed via cargo install?",
601        )?;
602
603    // Key format: "infinity-agent-cli 0.1.0 (source+url#hash)"
604    let source = key
605        .rsplit_once('(')
606        .and_then(|(_, rest)| rest.strip_suffix(')'))
607        .ok_or("could not parse source from .crates2.json key")?;
608
609    if let Some(url) = source.strip_prefix("git+") {
610        // Strip #commit-hash if present
611        let url = url.split_once('#').map_or(url, |(u, _)| u);
612        Ok((Some(url.to_owned()), None))
613    } else if let Some(path) = source.strip_prefix("path+file://") {
614        Ok((None, Some(path.to_owned())))
615    } else {
616        // registry install
617        Ok((None, None))
618    }
619}
620
621pub async fn run_self_update(features_override: Option<&str>) -> Result<(), BoxError> {
622    let mut term = CrosstermTerm::new();
623    term.enable_raw_mode()?;
624    let mut viewport = InlineViewport::new(term, 2)?;
625
626    let features: Vec<&str> = match features_override {
627        Some("") => vec![],
628        Some(s) => s
629            .split(',')
630            .map(str::trim)
631            .filter(|s| !s.is_empty())
632            .collect(),
633        None => installed_features(),
634    };
635
636    if let Err(e) = update_cli(&mut viewport, &features).await {
637        viewport.draw(2, |_| {})?;
638        terminal::cleanup(viewport.term_mut())?;
639        return Err(e);
640    }
641
642    let rap_failed = update_rap_tools(&mut viewport).await?;
643    let provider_failed = update_providers(&mut viewport).await?;
644    let daemon_ok = ensure_fresh_daemon(&mut viewport).await?;
645
646    let failed_count = rap_failed.len() + provider_failed.len();
647    let summary = if failed_count == 0 {
648        Span::styled("✓ Everything updated", Style::default().fg(Color::Green))
649    } else {
650        Span::styled(
651            format!("✗ {failed_count} component(s) failed to update"),
652            Style::default().fg(Color::Red),
653        )
654    };
655    viewport.print_line_above(Line::from(summary))?;
656    viewport.draw(2, |_| {})?;
657    terminal::cleanup(viewport.term_mut())?;
658
659    if failed_count != 0 {
660        Err("some components failed to update".into())
661    } else if !daemon_ok {
662        Err("failed to start daemon after update".into())
663    } else {
664        Ok(())
665    }
666}