use crate::commands::config::SpriteConfig;
use crate::error::SpriteError;
use crate::utils::tmux;
use anyhow::{Context, Result};
pub fn execute(agent: Option<String>, unzoom: bool, list: bool) -> Result<()> {
if SpriteConfig::load().is_ok() {
}
if list {
list_panes()?;
return Ok(());
}
if unzoom {
unzoom_session()?;
return Ok(());
}
let agent_id = if let Some(agent) = agent {
agent
} else {
list_panes_with_prompt()?;
return Ok(());
};
let sessions = tmux::list_sessions().context("Failed to list tmux sessions")?;
let active_session = sessions
.iter()
.find(|s| s.name.starts_with("sprite-") && s.attached)
.or_else(|| sessions.iter().find(|s| s.name.starts_with("sprite-")))
.ok_or_else(|| SpriteError::session_not_found("No active sprite session found"))?;
let panes = tmux::get_session_panes(&active_session.name)
.with_context(|| format!("Failed to get panes for session '{}'", active_session.name))?;
let target_pane = find_target_pane(&panes, &agent_id)?;
zoom_to_pane(&active_session.name, target_pane)?;
Ok(())
}
fn list_panes() -> Result<()> {
let sessions = tmux::list_sessions().context("Failed to list tmux sessions")?;
let active_session = sessions
.iter()
.find(|s| s.name.starts_with("sprite-") && s.attached)
.or_else(|| sessions.iter().find(|s| s.name.starts_with("sprite-")));
if active_session.is_none() {
println!("📭 No active sprite session found.");
println!("💡 Use 'sprite start' to create a new session.");
return Ok(());
}
let active_session = active_session.unwrap();
println!("🎬 Active Session: {}", active_session.name);
let panes = tmux::get_session_panes(&active_session.name)
.with_context(|| format!("Failed to get panes for session '{}'", active_session.name))?;
if panes.is_empty() {
println!(" No panes found in session.");
return Ok(());
}
println!("\n📋 Available Panes:");
println!("==================");
for (i, pane) in panes.iter().enumerate() {
let command = pane.current_command.as_deref().unwrap_or("idle");
let path = pane.current_path.as_deref().unwrap_or("unknown");
let agent_info = extract_agent_info(pane);
println!("{}. {} ({})", i + 1, command, path);
if let Some(info) = agent_info {
println!(" -> Agent: {}", info);
}
}
println!();
println!("💡 Usage:");
println!(" sprite zoom <agent_number> # Focus on specific agent pane");
println!(" sprite zoom --unzoom # Return to normal layout");
println!(" sprite zoom --list # Show this pane list");
Ok(())
}
fn list_panes_with_prompt() -> Result<()> {
list_panes()?;
println!();
println!("Please specify an agent number or name to zoom to.");
println!("Example: sprite zoom 1 # Zoom to agent 1");
Ok(())
}
fn find_target_pane(panes: &[tmux::PaneInfo], agent_id: &str) -> Result<usize> {
if let Ok(agent_num) = agent_id.parse::<usize>() {
let expected_pane = agent_num - 1; if expected_pane < panes.len() {
return Ok(expected_pane);
}
}
for (i, pane) in panes.iter().enumerate() {
if let Some(path) = &pane.current_path {
if path.contains(&format!("agents/{}", agent_id)) || path.ends_with(agent_id) {
return Ok(i);
}
}
}
for (i, pane) in panes.iter().enumerate() {
if let Some(command) = &pane.current_command {
if command.contains(agent_id) {
return Ok(i);
}
}
}
Err(SpriteError::validation(
format!("Agent '{}' not found or no active pane", agent_id),
Some("agent".to_string()),
Some(agent_id.to_string()),
)
.into())
}
fn zoom_to_pane(_session_name: &str, pane_index: usize) -> Result<()> {
println!("🔍 Zooming to pane {}...", pane_index + 1);
let output = std::process::Command::new("tmux")
.args(["select-pane", "-t", &pane_index.to_string()])
.output()
.with_context(|| "Failed to select pane")?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(
SpriteError::tmux_with_source("Failed to select pane", stderr.to_string()).into(),
);
}
let zoom_output = std::process::Command::new("tmux")
.args(["resize-pane", "-Z"])
.output()
.with_context(|| "Failed to zoom pane")?;
if !zoom_output.status.success() {
let stderr = String::from_utf8_lossy(&zoom_output.stderr);
eprintln!("⚠️ Warning: Could not maximize pane: {}", stderr);
}
println!("✓ Zoomed to pane {}", pane_index + 1);
println!("💡 Press Ctrl+B then Z to unzoom and return to normal layout");
Ok(())
}
fn unzoom_session() -> Result<()> {
println!("🔍 Returning to normal layout...");
let output = std::process::Command::new("tmux")
.args(["resize-pane", "-Z"])
.output()
.with_context(|| "Failed to unzoom session")?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(
SpriteError::tmux_with_source("Failed to unzoom session", stderr.to_string()).into(),
);
}
println!("✓ Returned to normal layout");
Ok(())
}
fn extract_agent_info(pane: &tmux::PaneInfo) -> Option<String> {
if let Some(path) = &pane.current_path {
if path.contains("agents/") {
if let Some(agent_part) = path.split("agents/").nth(1) {
if let Some(agent_id) = agent_part.split('/').next() {
return Some(format!("Agent {}", agent_id));
}
}
}
}
if let Some(command) = &pane.current_command {
if command.contains("agent") {
let words: Vec<&str> = command.split_whitespace().collect();
for word in words {
if word.contains("agent") {
if let Some(agent_part) = word.split("agent").nth(1) {
let agent_id = agent_part
.trim_start_matches('_')
.trim_start_matches('-')
.trim();
if !agent_id.is_empty() {
return Some(format!("Agent {}", agent_id));
}
}
}
}
}
}
None
}
#[cfg(test)]
mod tests {
#[test]
fn test_zoom_execution() {
}
}