@masyv/relay 0.3.0 → 0.4.0

package/core/src/agents/aider.rs

@@ -0,0 +1,75 @@
+//! Aider agent adapter — launches the aider TUI interactively.
+//! https://github.com/paul-gauthier/aider
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct AiderAgent {
+    model: String,
+}
+
+impl AiderAgent {
+    pub fn new(model: Option<&str>) -> Self {
+        Self {
+            model: model.unwrap_or("sonnet").to_string(),
+        }
+    }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("aider").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for AiderAgent {
+    fn name(&self) -> &str { "aider" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "aider".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: Command::new(&path).arg("--version").output().ok()
+                    .filter(|o| o.status.success())
+                    .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()),
+            },
+            None => AgentStatus {
+                name: "aider".into(),
+                available: false,
+                reason: "Not found. Install: pip install aider-chat".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("aider".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg("--model")
+            .arg(&self.model)
+            .arg("--message")
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "aider".into(),
+            success: status.success(),
+            message: format!("Aider ({}) session ended", self.model),
+            handoff_file: Some(tmp.to_string_lossy().to_string()),
+        })
+    }
+}

package/core/src/agents/claude.rs

@@ -0,0 +1,68 @@
+//! Claude CLI agent — starts a new Claude Code session with full context.
+//! Useful when the rate limit resets or you have a second subscription.
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct ClaudeAgent;
+
+impl ClaudeAgent {
+    pub fn new() -> Self { Self }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("claude").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for ClaudeAgent {
+    fn name(&self) -> &str { "claude" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "claude".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: Command::new(&path).arg("--version").output().ok()
+                    .filter(|o| o.status.success())
+                    .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()),
+            },
+            None => AgentStatus {
+                name: "claude".into(),
+                available: false,
+                reason: "Not found. Install: npm install -g @anthropic-ai/claude-code".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("claude".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        // Launch Claude interactively with the handoff as initial prompt
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg("--resume")
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "claude".into(),
+            success: status.success(),
+            message: "Claude session ended".into(),
+            handoff_file: Some(tmp.to_string_lossy().to_string()),
+        })
+    }
+}

package/core/src/agents/copilot.rs

@@ -0,0 +1,63 @@
+//! GitHub Copilot CLI agent adapter.
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct CopilotAgent;
+
+impl CopilotAgent {
+    pub fn new() -> Self { Self }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("copilot").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for CopilotAgent {
+    fn name(&self) -> &str { "copilot" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "copilot".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: None, // copilot --version hangs, skip it
+            },
+            None => AgentStatus {
+                name: "copilot".into(),
+                available: false,
+                reason: "Not found. Install: gh extension install github/gh-copilot".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("copilot".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "copilot".into(),
+            success: status.success(),
+            message: "Copilot session ended".into(),
+            handoff_file: Some(tmp.to_string_lossy().to_string()),
+        })
+    }
+}

package/core/src/agents/mod.rs

@@ -1,7 +1,11 @@
+pub mod aider;
+pub mod claude;
 pub mod codex;
+pub mod copilot;
 pub mod gemini;
 pub mod ollama;
 pub mod openai;
+pub mod opencode;
 
 use crate::{AgentStatus, Config, HandoffResult};
 use anyhow::Result;
@@ -18,10 +22,14 @@ pub fn get_agents(config: &Config) -> Vec<Box<dyn Agent>> {
     let mut agents: Vec<Box<dyn Agent>> = Vec::new();
     for name in &config.general.priority {
         match name.as_str() {
-            "codex"  => agents.push(Box::new(codex::CodexAgent::new(&config.agents.codex))),
-            "gemini" => agents.push(Box::new(gemini::GeminiAgent::new(&config.agents.gemini))),
-            "ollama" => agents.push(Box::new(ollama::OllamaAgent::new(&config.agents.ollama))),
-            "openai" => agents.push(Box::new(openai::OpenAIAgent::new(&config.agents.openai))),
+            "codex"    => agents.push(Box::new(codex::CodexAgent::new(&config.agents.codex))),
+            "gemini"   => agents.push(Box::new(gemini::GeminiAgent::new(&config.agents.gemini))),
+            "ollama"   => agents.push(Box::new(ollama::OllamaAgent::new(&config.agents.ollama))),
+            "openai"   => agents.push(Box::new(openai::OpenAIAgent::new(&config.agents.openai))),
+            "aider"    => agents.push(Box::new(aider::AiderAgent::new(None))),
+            "claude"   => agents.push(Box::new(claude::ClaudeAgent::new())),
+            "copilot"  => agents.push(Box::new(copilot::CopilotAgent::new())),
+            "opencode" => agents.push(Box::new(opencode::OpenCodeAgent::new())),
             _ => {} // unknown agent, skip
         }
     }

package/core/src/agents/ollama.rs

@@ -3,6 +3,7 @@
 use super::Agent;
 use crate::{AgentStatus, HandoffResult, OllamaConfig};
 use anyhow::Result;
+use std::process::Command;
 
 pub struct OllamaAgent {
     url: String,
@@ -22,43 +23,24 @@ impl Agent for OllamaAgent {
     fn name(&self) -> &str { "ollama" }
 
     fn check_available(&self) -> AgentStatus {
-        // Ping Ollama's API
+        // Use curl with a 2s timeout — avoids ureq hanging on refused connections
         let tag_url = format!("{}/api/tags", self.url);
-        match ureq::get(&tag_url).call() {
-            Ok(resp) => {
-                let body: serde_json::Value = resp.into_json().unwrap_or_default();
-                let models = body.get("models")
-                    .and_then(|m| m.as_array())
-                    .map(|a| a.len())
-                    .unwrap_or(0);
+        let output = Command::new("curl")
+            .args(["--silent", "--max-time", "2", &tag_url])
+            .output();
 
-                // Check if our target model is available
-                let has_model = body.get("models")
-                    .and_then(|m| m.as_array())
-                    .map(|arr| arr.iter().any(|m| {
-                        m.get("name").and_then(|n| n.as_str())
-                            .map(|n| n.starts_with(&self.model))
-                            .unwrap_or(false)
-                    }))
-                    .unwrap_or(false);
-
-                if has_model {
-                    AgentStatus {
-                        name: "ollama".into(),
-                        available: true,
-                        reason: format!("Running at {}, {} models, '{}' available", self.url, models, self.model),
-                        version: Some(self.model.clone()),
-                    }
-                } else {
-                    AgentStatus {
-                        name: "ollama".into(),
-                        available: true,
-                        reason: format!("Running but model '{}' not pulled. {} models available", self.model, models),
-                        version: None,
-                    }
+        match output {
+            Ok(o) if o.status.success() => {
+                let body: serde_json::Value = serde_json::from_slice(&o.stdout).unwrap_or_default();
+                let models = body.get("models").and_then(|m| m.as_array()).map(|a| a.len()).unwrap_or(0);
+                AgentStatus {
+                    name: "ollama".into(),
+                    available: true,
+                    reason: format!("Running at {}, {} models available", self.url, models),
+                    version: Some(self.model.clone()),
                 }
             }
-            Err(_) => AgentStatus {
+            _ => AgentStatus {
                 name: "ollama".into(),
                 available: false,
                 reason: format!("Not reachable at {}", self.url),
@@ -69,7 +51,6 @@ impl Agent for OllamaAgent {
 
     fn execute(&self, handoff_prompt: &str, _project_dir: &str) -> Result<HandoffResult> {
         let url = format!("{}/api/generate", self.url);
-
         let body = serde_json::json!({
             "model": self.model,
             "prompt": handoff_prompt,
@@ -81,11 +62,7 @@ impl Agent for OllamaAgent {
             .send_json(&body)?;
 
         let resp_json: serde_json::Value = resp.into_json()?;
-        let text = resp_json
-            .get("response")
-            .and_then(|r| r.as_str())
-            .unwrap_or("(no response)");
-
+        let text = resp_json.get("response").and_then(|r| r.as_str()).unwrap_or("(no response)");
         println!("{text}");
 
         Ok(HandoffResult {

package/core/src/agents/opencode.rs

@@ -0,0 +1,66 @@
+//! OpenCode agent adapter — Go-based coding agent.
+//! https://github.com/opencode-ai/opencode
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct OpenCodeAgent;
+
+impl OpenCodeAgent {
+    pub fn new() -> Self { Self }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("opencode").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for OpenCodeAgent {
+    fn name(&self) -> &str { "opencode" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "opencode".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: Command::new(&path).arg("--version").output().ok()
+                    .filter(|o| o.status.success())
+                    .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()),
+            },
+            None => AgentStatus {
+                name: "opencode".into(),
+                available: false,
+                reason: "Not found. Install: go install github.com/opencode-ai/opencode@latest".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("opencode".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "opencode".into(),
+            success: status.success(),
+            message: "OpenCode session ended".into(),
+            handoff_file: Some(tmp.to_string_lossy().to_string()),
+        })
+    }
+}

package/core/src/handoff/mod.rs

@@ -117,19 +117,26 @@ pub fn build_handoff(
     }
 
     // ── Instructions for agent ─────────────────────────────────
+    let deadline_note = if snapshot.deadline.is_some() {
+        "\nIMPORTANT: There is a DEADLINE. If the user asks you to continue, prioritise the current task."
+    } else { "" };
+
     let instructions = format!(
         "## INSTRUCTIONS\n\n\
-        You are continuing work that was started in a Claude Code session.\n\
-        The session was interrupted by a rate limit.\n\
-        Pick up EXACTLY where it left off. Do NOT re-explain context.\n\
-        The user is waiting — be efficient and direct.\n\
+        You have been given the full context from a Claude Code session.\n\
+        The context above shows what was being worked on, what decisions were made,\n\
+        what files were changed, and what the last state was.\n\
+        \n\
+        DO NOT immediately start working on anything.\n\
+        Instead, briefly confirm you have the context by saying something like:\n\
+        \"Context restored from your Claude session. I can see you were working on [brief summary]. What would you like me to do?\"\n\
+        \n\
+        Then WAIT for the user to tell you what to do next.\n\
         \n\
-        Working directory: {}\n\
+        Working directory: {}\
         {}",
         snapshot.project_dir,
-        if snapshot.deadline.is_some() {
-            "THERE IS A DEADLINE. Prioritise completing the current task."
-        } else { "" }
+        deadline_note
     );
     sections.push(instructions);
 

package/core/src/lib.rs

@@ -43,7 +43,11 @@ impl Default for GeneralConfig {
 fn default_priority() -> Vec<String> {
     vec![
         "codex".into(),
+        "claude".into(),
+        "aider".into(),
         "gemini".into(),
+        "copilot".into(),
+        "opencode".into(),
         "ollama".into(),
         "openai".into(),
     ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masyv/relay",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Relay — When Claude's rate limit hits, another agent picks up exactly where you left off. Captures session state and hands off to Codex, Gemini, Ollama, or GPT-4.",
   "scripts": {
     "build": "./scripts/build.sh",