automagik-forge 0.1.11 → 0.1.13

package/backend/src/services/github_service.rs

@@ -0,0 +1,307 @@
+use std::time::Duration;
+
+use octocrab::{Octocrab, OctocrabBuilder};
+use serde::{Deserialize, Serialize};
+use tokio::time::sleep;
+use tracing::{info, warn};
+
+#[derive(Debug)]
+pub enum GitHubServiceError {
+    Client(octocrab::Error),
+    Auth(String),
+    Repository(String),
+    PullRequest(String),
+    Branch(String),
+    TokenInvalid,
+}
+
+impl std::fmt::Display for GitHubServiceError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GitHubServiceError::Client(e) => write!(f, "GitHub client error: {}", e),
+            GitHubServiceError::Auth(e) => write!(f, "Authentication error: {}", e),
+            GitHubServiceError::Repository(e) => write!(f, "Repository error: {}", e),
+            GitHubServiceError::PullRequest(e) => write!(f, "Pull request error: {}", e),
+            GitHubServiceError::Branch(e) => write!(f, "Branch error: {}", e),
+            GitHubServiceError::TokenInvalid => write!(f, "GitHub token is invalid or expired."),
+        }
+    }
+}
+
+impl std::error::Error for GitHubServiceError {}
+
+impl From<octocrab::Error> for GitHubServiceError {
+    fn from(err: octocrab::Error) -> Self {
+        match &err {
+            octocrab::Error::GitHub { source, .. } => {
+                let status = source.status_code.as_u16();
+                let msg = source.message.to_ascii_lowercase();
+                if status == 401
+                    || status == 403
+                    || msg.contains("bad credentials")
+                    || msg.contains("token expired")
+                {
+                    GitHubServiceError::TokenInvalid
+                } else {
+                    GitHubServiceError::Client(err)
+                }
+            }
+            _ => GitHubServiceError::Client(err),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct GitHubRepoInfo {
+    pub owner: String,
+    pub repo_name: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct CreatePrRequest {
+    pub title: String,
+    pub body: Option<String>,
+    pub head_branch: String,
+    pub base_branch: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PullRequestInfo {
+    pub number: i64,
+    pub url: String,
+    pub status: String,
+    pub merged: bool,
+    pub merged_at: Option<chrono::DateTime<chrono::Utc>>,
+    pub merge_commit_sha: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct GitHubService {
+    client: Octocrab,
+    retry_config: RetryConfig,
+}
+
+#[derive(Debug, Clone)]
+pub struct RetryConfig {
+    pub max_retries: u32,
+    pub base_delay: Duration,
+    pub max_delay: Duration,
+}
+
+impl Default for RetryConfig {
+    fn default() -> Self {
+        Self {
+            max_retries: 3,
+            base_delay: Duration::from_secs(1),
+            max_delay: Duration::from_secs(30),
+        }
+    }
+}
+
+impl GitHubService {
+    /// Create a new GitHub service with authentication
+    pub fn new(github_token: &str) -> Result<Self, GitHubServiceError> {
+        let client = OctocrabBuilder::new()
+            .personal_token(github_token.to_string())
+            .build()
+            .map_err(|e| {
+                GitHubServiceError::Auth(format!("Failed to create GitHub client: {}", e))
+            })?;
+
+        Ok(Self {
+            client,
+            retry_config: RetryConfig::default(),
+        })
+    }
+
+    /// Create a pull request on GitHub
+    pub async fn create_pr(
+        &self,
+        repo_info: &GitHubRepoInfo,
+        request: &CreatePrRequest,
+    ) -> Result<PullRequestInfo, GitHubServiceError> {
+        self.with_retry(|| async { self.create_pr_internal(repo_info, request).await })
+            .await
+    }
+
+    async fn create_pr_internal(
+        &self,
+        repo_info: &GitHubRepoInfo,
+        request: &CreatePrRequest,
+    ) -> Result<PullRequestInfo, GitHubServiceError> {
+        // Verify repository access
+        self.client
+            .repos(&repo_info.owner, &repo_info.repo_name)
+            .get()
+            .await
+            .map_err(|e| {
+                GitHubServiceError::Repository(format!(
+                    "Cannot access repository {}/{}: {}",
+                    repo_info.owner, repo_info.repo_name, e
+                ))
+            })?;
+
+        // Check if the base branch exists
+        self.client
+            .repos(&repo_info.owner, &repo_info.repo_name)
+            .get_ref(&octocrab::params::repos::Reference::Branch(
+                request.base_branch.clone(),
+            ))
+            .await
+            .map_err(|e| {
+                GitHubServiceError::Branch(format!(
+                    "Base branch '{}' does not exist: {}",
+                    request.base_branch, e
+                ))
+            })?;
+
+        // Check if the head branch exists
+        self.client
+            .repos(&repo_info.owner, &repo_info.repo_name)
+            .get_ref(&octocrab::params::repos::Reference::Branch(
+                request.head_branch.clone(),
+            ))
+            .await
+            .map_err(|e| {
+                GitHubServiceError::Branch(format!(
+                    "Head branch '{}' does not exist. Make sure the branch was pushed successfully: {}",
+                    request.head_branch, e
+                ))
+            })?;
+
+        // Create the pull request
+        let pr = self
+            .client
+            .pulls(&repo_info.owner, &repo_info.repo_name)
+            .create(&request.title, &request.head_branch, &request.base_branch)
+            .body(request.body.as_deref().unwrap_or(""))
+            .send()
+            .await
+            .map_err(|e| match e {
+                octocrab::Error::GitHub { source, .. } => {
+                    if source.status_code.as_u16() == 401
+                        || source.status_code.as_u16() == 403
+                        || source
+                            .message
+                            .to_ascii_lowercase()
+                            .contains("bad credentials")
+                        || source
+                            .message
+                            .to_ascii_lowercase()
+                            .contains("token expired")
+                    {
+                        GitHubServiceError::TokenInvalid
+                    } else {
+                        GitHubServiceError::PullRequest(format!(
+                            "GitHub API error: {} (status: {})",
+                            source.message,
+                            source.status_code.as_u16()
+                        ))
+                    }
+                }
+                _ => GitHubServiceError::PullRequest(format!("Failed to create PR: {}", e)),
+            })?;
+
+        let pr_info = PullRequestInfo {
+            number: pr.number as i64,
+            url: pr.html_url.map(|url| url.to_string()).unwrap_or_default(),
+            status: "open".to_string(),
+            merged: false,
+            merged_at: None,
+            merge_commit_sha: None,
+        };
+
+        info!(
+            "Created GitHub PR #{} for branch {} in {}/{}",
+            pr_info.number, request.head_branch, repo_info.owner, repo_info.repo_name
+        );
+
+        Ok(pr_info)
+    }
+
+    /// Update and get the status of a pull request
+    pub async fn update_pr_status(
+        &self,
+        repo_info: &GitHubRepoInfo,
+        pr_number: i64,
+    ) -> Result<PullRequestInfo, GitHubServiceError> {
+        self.with_retry(|| async { self.update_pr_status_internal(repo_info, pr_number).await })
+            .await
+    }
+
+    async fn update_pr_status_internal(
+        &self,
+        repo_info: &GitHubRepoInfo,
+        pr_number: i64,
+    ) -> Result<PullRequestInfo, GitHubServiceError> {
+        let pr = self
+            .client
+            .pulls(&repo_info.owner, &repo_info.repo_name)
+            .get(pr_number as u64)
+            .await
+            .map_err(|e| {
+                GitHubServiceError::PullRequest(format!("Failed to get PR #{}: {}", pr_number, e))
+            })?;
+
+        let status = match pr.state {
+            Some(octocrab::models::IssueState::Open) => "open",
+            Some(octocrab::models::IssueState::Closed) => {
+                if pr.merged_at.is_some() {
+                    "merged"
+                } else {
+                    "closed"
+                }
+            }
+            None => "unknown",
+            Some(_) => "unknown", // Handle any other states
+        };
+
+        let pr_info = PullRequestInfo {
+            number: pr.number as i64,
+            url: pr.html_url.map(|url| url.to_string()).unwrap_or_default(),
+            status: status.to_string(),
+            merged: pr.merged_at.is_some(),
+            merged_at: pr.merged_at.map(|dt| dt.naive_utc().and_utc()),
+            merge_commit_sha: pr.merge_commit_sha.clone(),
+        };
+
+        Ok(pr_info)
+    }
+
+    /// Retry wrapper for GitHub API calls with exponential backoff
+    async fn with_retry<F, Fut, T>(&self, operation: F) -> Result<T, GitHubServiceError>
+    where
+        F: Fn() -> Fut,
+        Fut: std::future::Future<Output = Result<T, GitHubServiceError>>,
+    {
+        let mut last_error = None;
+
+        for attempt in 0..=self.retry_config.max_retries {
+            match operation().await {
+                Ok(result) => return Ok(result),
+                Err(e) => {
+                    last_error = Some(e);
+
+                    if attempt < self.retry_config.max_retries {
+                        let delay = std::cmp::min(
+                            self.retry_config.base_delay * 2_u32.pow(attempt),
+                            self.retry_config.max_delay,
+                        );
+
+                        warn!(
+                            "GitHub API call failed (attempt {}/{}), retrying in {:?}: {}",
+                            attempt + 1,
+                            self.retry_config.max_retries + 1,
+                            delay,
+                            last_error.as_ref().unwrap()
+                        );
+
+                        sleep(delay).await;
+                    }
+                }
+            }
+        }
+
+        Err(last_error.unwrap())
+    }
+}

package/backend/src/services/mod.rs

@@ -0,0 +1,13 @@
+pub mod analytics;
+pub mod git_service;
+pub mod github_service;
+pub mod notification_service;
+pub mod pr_monitor;
+pub mod process_service;
+
+pub use analytics::{generate_user_id, AnalyticsConfig, AnalyticsService};
+pub use git_service::{GitService, GitServiceError};
+pub use github_service::{CreatePrRequest, GitHubRepoInfo, GitHubService, GitHubServiceError};
+pub use notification_service::{NotificationConfig, NotificationService};
+pub use pr_monitor::PrMonitorService;
+pub use process_service::ProcessService;

package/backend/src/services/notification_service.rs

@@ -0,0 +1,263 @@
+use std::sync::OnceLock;
+
+use crate::models::config::SoundFile;
+
+/// Service for handling cross-platform notifications including sound alerts and push notifications
+#[derive(Debug, Clone)]
+pub struct NotificationService {
+    sound_enabled: bool,
+    push_enabled: bool,
+}
+
+/// Configuration for notifications
+#[derive(Debug, Clone)]
+pub struct NotificationConfig {
+    pub sound_enabled: bool,
+    pub push_enabled: bool,
+}
+
+impl Default for NotificationConfig {
+    fn default() -> Self {
+        Self {
+            sound_enabled: true,
+            push_enabled: true,
+        }
+    }
+}
+
+/// Cache for WSL root path from PowerShell
+static WSL_ROOT_PATH_CACHE: OnceLock<Option<String>> = OnceLock::new();
+
+impl NotificationService {
+    /// Create a new NotificationService with the given configuration
+    pub fn new(config: NotificationConfig) -> Self {
+        Self {
+            sound_enabled: config.sound_enabled,
+            push_enabled: config.push_enabled,
+        }
+    }
+
+    /// Send both sound and push notifications if enabled
+    pub async fn notify(&self, title: &str, message: &str, sound_file: &SoundFile) {
+        if self.sound_enabled {
+            self.play_sound_notification(sound_file).await;
+        }
+
+        if self.push_enabled {
+            self.send_push_notification(title, message).await;
+        }
+    }
+
+    /// Play a system sound notification across platforms
+    pub async fn play_sound_notification(&self, sound_file: &SoundFile) {
+        if !self.sound_enabled {
+            return;
+        }
+
+        let file_path = match sound_file.get_path().await {
+            Ok(path) => path,
+            Err(e) => {
+                tracing::error!("Failed to create cached sound file: {}", e);
+                return;
+            }
+        };
+
+        // Use platform-specific sound notification
+        // Note: spawn() calls are intentionally not awaited - sound notifications should be fire-and-forget
+        if cfg!(target_os = "macos") {
+            let _ = tokio::process::Command::new("afplay")
+                .arg(&file_path)
+                .spawn();
+        } else if cfg!(target_os = "linux") && !crate::utils::is_wsl2() {
+            // Try different Linux audio players
+            if tokio::process::Command::new("paplay")
+                .arg(&file_path)
+                .spawn()
+                .is_ok()
+            {
+                // Success with paplay
+            } else if tokio::process::Command::new("aplay")
+                .arg(&file_path)
+                .spawn()
+                .is_ok()
+            {
+                // Success with aplay
+            } else {
+                // Try system bell as fallback
+                let _ = tokio::process::Command::new("echo")
+                    .arg("-e")
+                    .arg("\\a")
+                    .spawn();
+            }
+        } else if cfg!(target_os = "windows")
+            || (cfg!(target_os = "linux") && crate::utils::is_wsl2())
+        {
+            // Convert WSL path to Windows path if in WSL2
+            let file_path = if crate::utils::is_wsl2() {
+                if let Some(windows_path) = Self::wsl_to_windows_path(&file_path).await {
+                    windows_path
+                } else {
+                    file_path.to_string_lossy().to_string()
+                }
+            } else {
+                file_path.to_string_lossy().to_string()
+            };
+
+            let _ = tokio::process::Command::new("powershell.exe")
+                .arg("-c")
+                .arg(format!(
+                    r#"(New-Object Media.SoundPlayer "{}").PlaySync()"#,
+                    file_path
+                ))
+                .spawn();
+        }
+    }
+
+    /// Send a cross-platform push notification
+    pub async fn send_push_notification(&self, title: &str, message: &str) {
+        if !self.push_enabled {
+            return;
+        }
+
+        if cfg!(target_os = "macos") {
+            self.send_macos_notification(title, message).await;
+        } else if cfg!(target_os = "linux") && !crate::utils::is_wsl2() {
+            self.send_linux_notification(title, message).await;
+        } else if cfg!(target_os = "windows")
+            || (cfg!(target_os = "linux") && crate::utils::is_wsl2())
+        {
+            self.send_windows_notification(title, message).await;
+        }
+    }
+
+    /// Send macOS notification using osascript
+    async fn send_macos_notification(&self, title: &str, message: &str) {
+        let script = format!(
+            r#"display notification "{message}" with title "{title}" sound name "Glass""#,
+            message = message.replace('"', r#"\""#),
+            title = title.replace('"', r#"\""#)
+        );
+
+        let _ = tokio::process::Command::new("osascript")
+            .arg("-e")
+            .arg(script)
+            .spawn();
+    }
+
+    /// Send Linux notification using notify-rust
+    async fn send_linux_notification(&self, title: &str, message: &str) {
+        use notify_rust::Notification;
+
+        let title = title.to_string();
+        let message = message.to_string();
+
+        let _handle = tokio::task::spawn_blocking(move || {
+            if let Err(e) = Notification::new()
+                .summary(&title)
+                .body(&message)
+                .timeout(10000)
+                .show()
+            {
+                tracing::error!("Failed to send Linux notification: {}", e);
+            }
+        });
+        drop(_handle); // Don't await, fire-and-forget
+    }
+
+    /// Send Windows/WSL notification using PowerShell toast script
+    async fn send_windows_notification(&self, title: &str, message: &str) {
+        let script_path = match crate::utils::get_powershell_script().await {
+            Ok(path) => path,
+            Err(e) => {
+                tracing::error!("Failed to get PowerShell script: {}", e);
+                return;
+            }
+        };
+
+        // Convert WSL path to Windows path if in WSL2
+        let script_path_str = if crate::utils::is_wsl2() {
+            if let Some(windows_path) = Self::wsl_to_windows_path(&script_path).await {
+                windows_path
+            } else {
+                script_path.to_string_lossy().to_string()
+            }
+        } else {
+            script_path.to_string_lossy().to_string()
+        };
+
+        let _ = tokio::process::Command::new("powershell.exe")
+            .arg("-NoProfile")
+            .arg("-ExecutionPolicy")
+            .arg("Bypass")
+            .arg("-File")
+            .arg(script_path_str)
+            .arg("-Title")
+            .arg(title)
+            .arg("-Message")
+            .arg(message)
+            .spawn();
+    }
+
+    /// Get WSL root path via PowerShell (cached)
+    async fn get_wsl_root_path() -> Option<String> {
+        if let Some(cached) = WSL_ROOT_PATH_CACHE.get() {
+            return cached.clone();
+        }
+
+        match tokio::process::Command::new("powershell.exe")
+            .arg("-c")
+            .arg("(Get-Location).Path -replace '^.*::', ''")
+            .current_dir("/")
+            .output()
+            .await
+        {
+            Ok(output) => {
+                match String::from_utf8(output.stdout) {
+                    Ok(pwd_str) => {
+                        let pwd = pwd_str.trim();
+                        tracing::info!("WSL root path detected: {}", pwd);
+
+                        // Cache the result
+                        let _ = WSL_ROOT_PATH_CACHE.set(Some(pwd.to_string()));
+                        return Some(pwd.to_string());
+                    }
+                    Err(e) => {
+                        tracing::error!("Failed to parse PowerShell pwd output as UTF-8: {}", e);
+                    }
+                }
+            }
+            Err(e) => {
+                tracing::error!("Failed to execute PowerShell pwd command: {}", e);
+            }
+        }
+
+        // Cache the failure result
+        let _ = WSL_ROOT_PATH_CACHE.set(None);
+        None
+    }
+
+    /// Convert WSL path to Windows UNC path for PowerShell
+    async fn wsl_to_windows_path(wsl_path: &std::path::Path) -> Option<String> {
+        let path_str = wsl_path.to_string_lossy();
+
+        // Relative paths work fine as-is in PowerShell
+        if !path_str.starts_with('/') {
+            tracing::debug!("Using relative path as-is: {}", path_str);
+            return Some(path_str.to_string());
+        }
+
+        // Get cached WSL root path from PowerShell
+        if let Some(wsl_root) = Self::get_wsl_root_path().await {
+            // Simply concatenate WSL root with the absolute path - PowerShell doesn't mind /
+            let windows_path = format!("{}{}", wsl_root, path_str);
+            tracing::debug!("WSL path converted: {} -> {}", path_str, windows_path);
+            Some(windows_path)
+        } else {
+            tracing::error!(
+                "Failed to determine WSL root path for conversion: {}",
+                path_str
+            );
+            None
+        }
+    }
+}