mod claude;
mod codex;
mod opencode;
use crate::GraphQLResponse;
use crate::graphql::mock_response_prompt::MockResponsePrompt;
use crate::llm_provider::ProviderError;
pub use claude::ClaudeCliProvider;
pub use codex::CodexCliProvider;
pub use opencode::OpenCodeCliProvider;
use std::env;
use std::process::Output;
use std::time::Duration;
use tokio::process::Child;
use tokio::time::timeout;
#[derive(Debug, Clone)]
pub enum CliProvider {
Claude(ClaudeCliProvider),
Codex(CodexCliProvider),
OpenCode(OpenCodeCliProvider),
}
impl CliProvider {
pub(crate) async fn run(
&self,
prompt: &MockResponsePrompt,
timeout: Duration,
) -> Result<GraphQLResponse, ProviderError> {
if env::var("MOCKQL_DEBUG").is_ok()
&& let Ok(markdown) = prompt.to_markdown()
{
let _ = std::fs::write("prompt.dbg.txt", markdown);
}
match self {
Self::Claude(claude) => claude.run(prompt, timeout).await,
Self::Codex(codex) => codex.run(prompt, timeout).await,
Self::OpenCode(opencode) => opencode.run(prompt, timeout).await,
}
}
}
pub(crate) async fn exec_cli(timeout_duration: Duration, child: Child) -> Result<Output, ProviderError> {
let output = timeout(timeout_duration, child.wait_with_output())
.await
.map_err(|_| ProviderError::Request("CLI command timed out".to_string()))?
.map_err(|error| ProviderError::Request(format!("CLI command failed while waiting for output: {error}")))?;
if !output.status.success() {
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
let details = if stderr.trim().is_empty() {
stdout.trim()
} else {
stderr.trim()
};
return Err(ProviderError::Request(if details.is_empty() {
format!("CLI command exited with status {}", output.status)
} else {
format!("CLI command exited with status {}: {details}", output.status)
}));
}
Ok(output)
}