1use 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
26pub struct ProviderInstallArgs {
28 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
57async 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 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() };
179
180 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
220pub 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 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
304async 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
364async 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
437async 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
479pub 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
509fn 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
518async 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
582fn 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 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 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 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}