From fb5f3bd47a87d3a93a88175af174a3a89f7a4bfe Mon Sep 17 00:00:00 2001 From: elvis Date: Tue, 8 Sep 2026 10:14:15 -0300 Subject: Screen vision MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cuarta herramienta: captura la pantalla y responde sobre lo que hay en ella. Aprovecha el mismo proyector multimodal que ya usaba la cámara. Como las dos hacen lo mismo —conseguir un JPEG, preguntarle al modelo, devolver texto— y sólo cambian en de dónde salen los píxeles, se unifican tras VisionTool y un trait FrameSource. La captura vive en scripts/capturar- pantalla.sh, que detecta grim, spectacle, maim, ImageMagick o scrot y reduce con ffmpeg: añadir un compositor es editar el guion, no recompilar. El ajuste que decide todo es la resolución, y no coincide con la de la cámara porque el problema no es el mismo: una escena se entiende, un texto hay que leerlo. Medido con tipografía de interfaz de 13 px y preguntando por datos concretos, a 1280 px acierta 3 de 3 en 7,6 s; a 960, 2 de 3; a 640, 1 de 3. Y a 640 px no falla diciendo que no lee: dijo que el error era «no se pudo abrir el archivo involution» y que la reunión era «a las 10:00», cuando ponía /dev/video0 y 15:30. Para un asistente de voz, decir una hora equivocada con aplomo es peor que tardar cuatro segundos más, así que 1280 px por defecto aunque cueste el triple que la cámara. Al prompt se le añade además que no complete lo que no se distinga, y funciona: en una prueba real contestó que el texto de la barra de direcciones era ilegible en vez de inventárselo. Con cuatro herramientas declaradas el riesgo era confundir pantalla con cámara. No pasa: 18 de 20, con cero confusiones entre ambas. Corregido de paso un fallo del lanzador de procesos que la captura destapó. Esperaba con try_wait en bucle sin vaciar las tuberías, así que un hijo que escribiera más de los 64 KB del búfer se quedaba bloqueado y moría por plazo vencido aunque estuviera trabajando. Los tres usos anteriores cabían de sobra —una fecha, un JSON, un fotograma de 9 KB—; la primera captura, de 174 KB, no. Ahora se vacían en hilos aparte, con una prueba por tubería. Ese lanzador es además nuevo: había tres copias del mismo patrón —plazo máximo, sin shell de por medio, distinguir fallo de cuelgue— en la shell, la búsqueda y la cámara. Ahora está una sola vez en asist_core::proc. Claude-Session: https://claude.ai/code/session_01KSfMfDsRwNAaXcCA6V5RTe --- crates/asist-core/src/proc.rs | 228 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 crates/asist-core/src/proc.rs (limited to 'crates/asist-core/src/proc.rs') diff --git a/crates/asist-core/src/proc.rs b/crates/asist-core/src/proc.rs new file mode 100644 index 0000000..8e38108 --- /dev/null +++ b/crates/asist-core/src/proc.rs @@ -0,0 +1,228 @@ +//! Ejecutar un programa con un plazo máximo. +//! +//! Tres sitios lo necesitaban con los mismos cuidados —no dejar nunca un +//! proceso colgado, no pasar por una shell, distinguir «falló» de «tardó +//! demasiado»— y cada uno lo tenía escrito a su manera. Aquí está una sola vez. +//! +//! Nada de esto pasa por `sh`: los argumentos van al `execve` tal cual. Importa +//! más de lo que parece, porque lo que acaba en ellos viene, en última +//! instancia, de lo que se ha oído por el micrófono. + +use std::ffi::OsStr; +use std::io::Read; +use std::path::Path; +use std::process::{Command, Stdio}; +use std::time::{Duration, Instant}; + +/// Cómo terminó. +#[derive(Debug)] +pub struct Output { + pub stdout: Vec, + pub stderr: String, + pub status: Option, + pub took: Duration, +} + +impl Output { + pub fn success(&self) -> bool { + self.status == Some(0) + } + + /// Última línea del error, que es donde los programas suelen poner el + /// motivo de verdad. + pub fn last_error_line(&self) -> &str { + self.stderr + .trim() + .lines() + .next_back() + .unwrap_or("sin detalles") + } +} + +#[derive(Debug, thiserror::Error)] +pub enum ProcError { + #[error("no se pudo ejecutar {program}: {source}")] + Spawn { + program: String, + #[source] + source: std::io::Error, + }, + #[error("{program} tardó más de {} s", timeout.as_secs())] + Timeout { program: String, timeout: Duration }, + #[error("fallo esperando a {program}: {source}")] + Wait { + program: String, + #[source] + source: std::io::Error, + }, +} + +/// Lanza `program`, espera hasta `timeout` y devuelve lo que haya escrito. +/// +/// Si vence el plazo, mata el proceso antes de rendirse: un ffmpeg contra una +/// cámara ocupada, o un buscador que no contesta, se quedarían ahí para +/// siempre. +pub fn run( + program: impl AsRef, + args: impl IntoIterator>, + timeout: Duration, + working_dir: Option<&Path>, +) -> Result { + let program = program.as_ref(); + let name = program.display().to_string(); + let started = Instant::now(); + + let mut command = Command::new(program); + command + .args(args) + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + if let Some(dir) = working_dir { + command.current_dir(dir); + } + + let mut child = command.spawn().map_err(|source| ProcError::Spawn { + program: name.clone(), + source, + })?; + + // Las tuberías se vacían en hilos aparte, y no después de esperar. + // + // Esto no es una optimización: un hijo que escribe más de lo que cabe en el + // búfer de la tubería (64 KB en Linux) se queda bloqueado escribiendo, no + // termina nunca, y el bucle de espera acaba matándolo por plazo vencido + // aunque estuviera haciendo su trabajo. Costó descubrirlo porque los tres + // primeros usos —una fecha, un JSON de búsqueda, un fotograma de 9 KB— + // cabían de sobra; la primera captura de pantalla, de 180 KB, no. + let mut stdout = child.stdout.take(); + let mut stderr = child.stderr.take(); + let stdout_reader = std::thread::spawn(move || { + let mut buf = Vec::new(); + if let Some(pipe) = stdout.as_mut() { + let _ = pipe.read_to_end(&mut buf); + } + buf + }); + let stderr_reader = std::thread::spawn(move || { + let mut buf = Vec::new(); + if let Some(pipe) = stderr.as_mut() { + let _ = pipe.read_to_end(&mut buf); + } + buf + }); + + let deadline = started + timeout; + let status = loop { + match child.try_wait() { + Ok(Some(status)) => break status, + Ok(None) if Instant::now() >= deadline => { + // Matar cierra las tuberías, así que los lectores terminan y + // se pueden recoger sin quedarse colgados. + let _ = child.kill(); + let _ = child.wait(); + let _ = stdout_reader.join(); + let _ = stderr_reader.join(); + return Err(ProcError::Timeout { + program: name, + timeout, + }); + } + Ok(None) => std::thread::sleep(Duration::from_millis(20)), + Err(source) => { + return Err(ProcError::Wait { + program: name, + source, + }) + } + } + }; + + let stdout = stdout_reader.join().unwrap_or_default(); + let stderr = stderr_reader.join().unwrap_or_default(); + + Ok(Output { + stdout, + stderr: String::from_utf8_lossy(&stderr).into_owned(), + status: status.code(), + took: started.elapsed(), + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn se_recoge_la_salida_estandar() { + let out = run("echo", ["hola"], Duration::from_secs(5), None).unwrap(); + assert!(out.success()); + assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), "hola"); + } + + #[test] + fn un_proceso_colgado_se_mata_al_vencer_el_plazo() { + let started = Instant::now(); + let err = run("sleep", ["30"], Duration::from_millis(300), None).unwrap_err(); + assert!(matches!(err, ProcError::Timeout { .. }), "{err}"); + assert!( + started.elapsed() < Duration::from_secs(3), + "debió cortar enseguida, tardó {:?}", + started.elapsed() + ); + } + + #[test] + fn una_salida_grande_no_bloquea_al_hijo() { + // La regresión que dejó colgada la captura de pantalla: sin vaciar la + // tubería mientras se espera, un hijo que escribe más de 64 KB se + // bloquea y acaba muriendo por plazo vencido. + let out = run( + "dd", + ["if=/dev/zero", "bs=1024", "count=512", "status=none"], + Duration::from_secs(10), + None, + ) + .expect("no debió vencer el plazo"); + assert!(out.success()); + assert_eq!(out.stdout.len(), 512 * 1024); + } + + #[test] + fn el_error_grande_tampoco_bloquea() { + // Mismo problema por la otra tubería: mucho ruido en stderr y poca + // salida es justo lo que hace ffmpeg cuando algo va mal. + let out = run( + "sh", + ["-c", "yes error | head -c 200000 >&2; echo ok"], + Duration::from_secs(10), + None, + ) + .expect("no debió vencer el plazo"); + assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), "ok"); + assert!(out.stderr.len() > 100_000); + } + + #[test] + fn un_programa_inexistente_da_un_error_con_su_nombre() { + let err = run("/no/existe/nada", ["x"], Duration::from_secs(1), None).unwrap_err(); + assert!(err.to_string().contains("/no/existe/nada"), "{err}"); + } + + #[test] + fn un_fallo_conserva_el_codigo_y_el_mensaje() { + let out = run("ls", ["/no/existe"], Duration::from_secs(5), None).unwrap(); + assert!(!out.success()); + assert!(!out.last_error_line().is_empty()); + } + + #[test] + fn los_metacaracteres_no_los_interpreta_ninguna_shell() { + let out = run("echo", ["a; echo b"], Duration::from_secs(5), None).unwrap(); + assert_eq!( + String::from_utf8_lossy(&out.stdout).trim(), + "a; echo b", + "el punto y coma debe llegar como texto, no como separador de órdenes" + ); + } +} -- cgit v1.2.3