automagik-forge 0.1.13 → 0.1.14

package/backend/src/models/task_template.rs

@@ -1,146 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use sqlx::{FromRow, SqlitePool};
-use ts_rs::TS;
-use utoipa::ToSchema;
-use uuid::Uuid;
-
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct TaskTemplate {
-    pub id: Uuid,
-    pub project_id: Option<Uuid>, // None for global templates
-    pub title: String,
-    pub description: Option<String>,
-    pub template_name: String,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct CreateTaskTemplate {
-    pub project_id: Option<Uuid>,
-    pub title: String,
-    pub description: Option<String>,
-    pub template_name: String,
-}
-
-#[derive(Debug, Deserialize, TS, ToSchema)]
-#[ts(export)]
-pub struct UpdateTaskTemplate {
-    pub title: Option<String>,
-    pub description: Option<String>,
-    pub template_name: Option<String>,
-}
-
-impl TaskTemplate {
-    pub async fn find_all(pool: &SqlitePool) -> Result<Vec<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            TaskTemplate,
-            r#"SELECT id as "id!: Uuid", project_id as "project_id?: Uuid", title, description, template_name, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>"
-               FROM task_templates 
-               ORDER BY project_id IS NULL DESC, template_name ASC"#
-        )
-        .fetch_all(pool)
-        .await
-    }
-
-    pub async fn find_by_project_id(
-        pool: &SqlitePool,
-        project_id: Option<Uuid>,
-    ) -> Result<Vec<Self>, sqlx::Error> {
-        if let Some(pid) = project_id {
-            // Return only project-specific templates
-            sqlx::query_as::<_, TaskTemplate>(
-                r#"SELECT id, project_id, title, description, template_name, created_at, updated_at
-                   FROM task_templates 
-                   WHERE project_id = ?
-                   ORDER BY template_name ASC"#,
-            )
-            .bind(pid)
-            .fetch_all(pool)
-            .await
-        } else {
-            // Return only global templates
-            sqlx::query_as!(
-                TaskTemplate,
-                r#"SELECT id as "id!: Uuid", project_id as "project_id?: Uuid", title, description, template_name, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>"
-                   FROM task_templates 
-                   WHERE project_id IS NULL
-                   ORDER BY template_name ASC"#
-            )
-            .fetch_all(pool)
-            .await
-        }
-    }
-
-    pub async fn find_by_id(pool: &SqlitePool, id: Uuid) -> Result<Option<Self>, sqlx::Error> {
-        sqlx::query_as!(
-            TaskTemplate,
-            r#"SELECT id as "id!: Uuid", project_id as "project_id?: Uuid", title, description, template_name, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>"
-               FROM task_templates 
-               WHERE id = $1"#,
-            id
-        )
-        .fetch_optional(pool)
-        .await
-    }
-
-    pub async fn create(pool: &SqlitePool, data: &CreateTaskTemplate) -> Result<Self, sqlx::Error> {
-        let id = Uuid::new_v4();
-        sqlx::query_as!(
-            TaskTemplate,
-            r#"INSERT INTO task_templates (id, project_id, title, description, template_name) 
-               VALUES ($1, $2, $3, $4, $5) 
-               RETURNING id as "id!: Uuid", project_id as "project_id?: Uuid", title, description, template_name, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>""#,
-            id,
-            data.project_id,
-            data.title,
-            data.description,
-            data.template_name
-        )
-        .fetch_one(pool)
-        .await
-    }
-
-    pub async fn update(
-        pool: &SqlitePool,
-        id: Uuid,
-        data: &UpdateTaskTemplate,
-    ) -> Result<Self, sqlx::Error> {
-        // Get existing template first
-        let existing = Self::find_by_id(pool, id)
-            .await?
-            .ok_or(sqlx::Error::RowNotFound)?;
-
-        // Use let bindings to create longer-lived values
-        let title = data.title.as_ref().unwrap_or(&existing.title);
-        let description = data.description.as_ref().or(existing.description.as_ref());
-        let template_name = data
-            .template_name
-            .as_ref()
-            .unwrap_or(&existing.template_name);
-
-        sqlx::query_as!(
-            TaskTemplate,
-            r#"UPDATE task_templates 
-               SET title = $2, description = $3, template_name = $4, updated_at = datetime('now', 'subsec')
-               WHERE id = $1 
-               RETURNING id as "id!: Uuid", project_id as "project_id?: Uuid", title, description, template_name, created_at as "created_at!: DateTime<Utc>", updated_at as "updated_at!: DateTime<Utc>""#,
-            id,
-            title,
-            description,
-            template_name
-        )
-        .fetch_one(pool)
-        .await
-    }
-
-    pub async fn delete(pool: &SqlitePool, id: Uuid) -> Result<u64, sqlx::Error> {
-        let result = sqlx::query!("DELETE FROM task_templates WHERE id = $1", id)
-            .execute(pool)
-            .await?;
-        Ok(result.rows_affected())
-    }
-}

package/backend/src/openapi.rs

@@ -1,93 +0,0 @@
-use utoipa::OpenApi;
-
-#[derive(OpenApi)]
-#[openapi(
-    info(
-        title = "Automagik Forge API",
-        version = "1.0.0",
-        description = "A task and project management API for Automagik Forge",
-        contact(
-            name = "Automagik Forge Team",
-            url = "https://github.com/your-org/automagik-forge"
-        )
-    ),
-    paths(
-        crate::routes::health::health_check,
-        crate::routes::projects::get_projects,
-        crate::routes::projects::get_project,
-        crate::routes::projects::create_project,
-        crate::routes::projects::update_project,
-        crate::routes::projects::delete_project,
-        crate::routes::tasks::get_project_tasks,
-        crate::routes::tasks::get_task,
-        crate::routes::tasks::create_task,
-        crate::routes::tasks::update_task,
-        crate::routes::tasks::delete_task,
-        crate::routes::task_attempts::get_task_attempts,
-        crate::routes::task_attempts::create_task_attempt,
-        crate::routes::task_templates::list_templates,
-        crate::routes::task_templates::list_project_templates,
-        crate::routes::task_templates::list_global_templates,
-        crate::routes::task_templates::get_template,
-        crate::routes::task_templates::create_template,
-        crate::routes::task_templates::update_template,
-        crate::routes::task_templates::delete_template,
-        // Auth routes
-        crate::routes::auth::device_start,
-        crate::routes::auth::device_poll,
-        crate::routes::auth::github_check_token,
-        // Config routes
-        crate::routes::config::get_config,
-        crate::routes::config::update_config,
-        crate::routes::config::get_config_constants,
-        crate::routes::config::get_mcp_servers,
-        crate::routes::config::update_mcp_servers,
-        // Filesystem routes
-        crate::routes::filesystem::list_directory,
-        crate::routes::filesystem::validate_git_path,
-        crate::routes::filesystem::create_git_repo,
-    ),
-    components(
-        schemas(
-            crate::models::project::Project,
-            crate::models::project::CreateProject,
-            crate::models::project::UpdateProject,
-            crate::models::project::ProjectWithBranch,
-            crate::models::project::GitBranch,
-            crate::models::task::Task,
-            crate::models::task::TaskStatus,
-            crate::models::task::TaskWithAttemptStatus,
-            crate::models::task::CreateTask,
-            crate::models::task::UpdateTask,
-            crate::models::task_attempt::TaskAttempt,
-            crate::models::task_attempt::TaskAttemptStatus,
-            crate::models::task_attempt::CreateTaskAttempt,
-            crate::models::task_template::TaskTemplate,
-            crate::models::task_template::CreateTaskTemplate,
-            crate::models::task_template::UpdateTaskTemplate,
-            crate::executor::ExecutorConfig,
-            crate::executor::NormalizedConversation,
-            crate::executor::NormalizedEntry,
-            crate::executor::NormalizedEntryType,
-            crate::executor::ActionType,
-            // Auth schemas
-            crate::routes::auth::DeviceStartResponse,
-            // Config schemas
-            crate::routes::config::ConfigConstants,
-            // Filesystem schemas
-            crate::routes::filesystem::DirectoryEntry,
-            crate::routes::filesystem::DirectoryListResponse,
-        )
-    ),
-    tags(
-        (name = "health", description = "Health check operations"),
-        (name = "projects", description = "Project management operations"),
-        (name = "tasks", description = "Task management operations"),
-        (name = "task_attempts", description = "Task execution attempt operations"),
-        (name = "task_templates", description = "Task template operations"),
-        (name = "auth", description = "Authentication operations"),
-        (name = "config", description = "Configuration operations"),
-        (name = "filesystem", description = "File system operations"),
-    )
-)]
-pub struct ApiDoc;

package/backend/src/routes/auth.rs

@@ -1,297 +0,0 @@
-use axum::{
-    extract::{Request, State},
-    middleware::Next,
-    response::{Json as ResponseJson, Response},
-    routing::{get, post},
-    Json, Router,
-};
-use ts_rs::TS;
-use utoipa::ToSchema;
-
-use crate::{app_state::AppState, models::ApiResponse};
-
-pub fn auth_router() -> Router<AppState> {
-    Router::new()
-        .route("/auth/github/device/start", post(device_start))
-        .route("/auth/github/device/poll", post(device_poll))
-        .route("/auth/github/check", get(github_check_token))
-}
-
-#[derive(serde::Deserialize, ToSchema)]
-struct DeviceStartRequest {}
-
-#[derive(serde::Serialize, TS, ToSchema)]
-#[ts(export)]
-pub struct DeviceStartResponse {
-    pub device_code: String,
-    pub user_code: String,
-    pub verification_uri: String,
-    pub expires_in: u32,
-    pub interval: u32,
-}
-
-#[derive(serde::Deserialize, ToSchema)]
-pub struct DevicePollRequest {
-    device_code: String,
-}
-
-/// POST /auth/github/device/start
-#[utoipa::path(
-    post,
-    path = "/auth/github/device/start",
-    tag = "auth",
-    summary = "Start GitHub OAuth device flow",
-    description = "Initiates GitHub OAuth device authorization flow, returning device and user codes",
-    responses(
-        (status = 200, description = "Device authorization flow started successfully", body = ApiResponse<DeviceStartResponse>),
-        (status = 500, description = "Failed to contact GitHub or parse response", body = ApiResponse<String>)
-    )
-)]
-pub async fn device_start() -> ResponseJson<ApiResponse<DeviceStartResponse>> {
-    let client_id = std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "Ov23li2nd1KF5nCPbgoj".to_string());
-
-    let params = [("client_id", client_id.as_str()), ("scope", "user:email,repo")];
-    let client = reqwest::Client::new();
-    let res = client
-        .post("https://github.com/login/device/code")
-        .header("Accept", "application/json")
-        .form(&params)
-        .send()
-        .await;
-    let res = match res {
-        Ok(r) => r,
-        Err(e) => {
-            return ResponseJson(ApiResponse::error(&format!(
-                "Failed to contact GitHub: {e}"
-            )));
-        }
-    };
-    let json: serde_json::Value = match res.json().await {
-        Ok(j) => j,
-        Err(e) => {
-            return ResponseJson(ApiResponse::error(&format!(
-                "Failed to parse GitHub response: {e}"
-            )));
-        }
-    };
-    if let (
-        Some(device_code),
-        Some(user_code),
-        Some(verification_uri),
-        Some(expires_in),
-        Some(interval),
-    ) = (
-        json.get("device_code").and_then(|v| v.as_str()),
-        json.get("user_code").and_then(|v| v.as_str()),
-        json.get("verification_uri").and_then(|v| v.as_str()),
-        json.get("expires_in").and_then(|v| v.as_u64()),
-        json.get("interval").and_then(|v| v.as_u64()),
-    ) {
-        ResponseJson(ApiResponse::success(DeviceStartResponse {
-            device_code: device_code.to_string(),
-            user_code: user_code.to_string(),
-            verification_uri: verification_uri.to_string(),
-            expires_in: expires_in.try_into().unwrap_or(600),
-            interval: interval.try_into().unwrap_or(5),
-        }))
-    } else {
-        ResponseJson(ApiResponse::error(&format!("GitHub error: {}", json)))
-    }
-}
-
-/// POST /auth/github/device/poll
-#[utoipa::path(
-    post,
-    path = "/auth/github/device/poll",
-    tag = "auth",
-    summary = "Poll GitHub OAuth device flow",
-    description = "Polls GitHub for OAuth device flow completion and saves access token",
-    request_body = DevicePollRequest,
-    responses(
-        (status = 200, description = "GitHub login successful or still pending", body = ApiResponse<String>),
-        (status = 400, description = "OAuth error or invalid device code", body = ApiResponse<String>)
-    )
-)]
-pub async fn device_poll(
-    State(app_state): State<AppState>,
-    Json(payload): Json<DevicePollRequest>,
-) -> ResponseJson<ApiResponse<String>> {
-    let client_id = std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "Ov23li2nd1KF5nCPbgoj".to_string());
-
-    let params = [
-        ("client_id", client_id.as_str()),
-        ("device_code", payload.device_code.as_str()),
-        ("grant_type", "urn:ietf:params:oauth:grant-type:device_code"),
-    ];
-    let client = reqwest::Client::new();
-    let res = client
-        .post("https://github.com/login/oauth/access_token")
-        .header("Accept", "application/json")
-        .form(&params)
-        .send()
-        .await;
-    let res = match res {
-        Ok(r) => r,
-        Err(e) => {
-            return ResponseJson(ApiResponse::error(&format!(
-                "Failed to contact GitHub: {e}"
-            )));
-        }
-    };
-    let json: serde_json::Value = match res.json().await {
-        Ok(j) => j,
-        Err(e) => {
-            return ResponseJson(ApiResponse::error(&format!(
-                "Failed to parse GitHub response: {e}"
-            )));
-        }
-    };
-    if let Some(error) = json.get("error").and_then(|v| v.as_str()) {
-        // Not authorized yet, or other error
-        return ResponseJson(ApiResponse::error(error));
-    }
-    let access_token = json.get("access_token").and_then(|v| v.as_str());
-    if let Some(access_token) = access_token {
-        // Fetch user info
-        let user_res = client
-            .get("https://api.github.com/user")
-            .bearer_auth(access_token)
-            .header("User-Agent", "automagik-forge-app")
-            .send()
-            .await;
-        let user_json: serde_json::Value = match user_res {
-            Ok(res) => match res.json().await {
-                Ok(json) => json,
-                Err(e) => {
-                    return ResponseJson(ApiResponse::error(&format!(
-                        "Failed to parse GitHub user response: {e}"
-                    )));
-                }
-            },
-            Err(e) => {
-                return ResponseJson(ApiResponse::error(&format!(
-                    "Failed to fetch user info: {e}"
-                )));
-            }
-        };
-        let username = user_json
-            .get("login")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string());
-        // Fetch user emails
-        let emails_res = client
-            .get("https://api.github.com/user/emails")
-            .bearer_auth(access_token)
-            .header("User-Agent", "automagik-forge-app")
-            .send()
-            .await;
-        let emails_json: serde_json::Value = match emails_res {
-            Ok(res) => match res.json().await {
-                Ok(json) => json,
-                Err(e) => {
-                    return ResponseJson(ApiResponse::error(&format!(
-                        "Failed to parse GitHub emails response: {e}"
-                    )));
-                }
-            },
-            Err(e) => {
-                return ResponseJson(ApiResponse::error(&format!(
-                    "Failed to fetch user emails: {e}"
-                )));
-            }
-        };
-        let primary_email = emails_json
-            .as_array()
-            .and_then(|arr| {
-                arr.iter()
-                    .find(|email| {
-                        email
-                            .get("primary")
-                            .and_then(|v| v.as_bool())
-                            .unwrap_or(false)
-                    })
-                    .and_then(|email| email.get("email").and_then(|v| v.as_str()))
-            })
-            .map(|s| s.to_string());
-        // Save to config
-        {
-            let mut config = app_state.get_config().write().await;
-            config.github.username = username.clone();
-            config.github.primary_email = primary_email.clone();
-            config.github.token = Some(access_token.to_string());
-            config.github_login_acknowledged = true; // Also acknowledge the GitHub login step
-            let config_path = crate::utils::config_path();
-            if config.save(&config_path).is_err() {
-                return ResponseJson(ApiResponse::error("Failed to save config"));
-            }
-        }
-        app_state.update_sentry_scope().await;
-        // Identify user in PostHog
-        let mut props = serde_json::Map::new();
-        if let Some(ref username) = username {
-            props.insert(
-                "username".to_string(),
-                serde_json::Value::String(username.clone()),
-            );
-        }
-        if let Some(ref email) = primary_email {
-            props.insert(
-                "email".to_string(),
-                serde_json::Value::String(email.clone()),
-            );
-        }
-        {
-            let props = serde_json::Value::Object(props);
-            app_state
-                .track_analytics_event("$identify", Some(props))
-                .await;
-        }
-
-        ResponseJson(ApiResponse::success("GitHub login successful".to_string()))
-    } else {
-        ResponseJson(ApiResponse::error("No access token yet"))
-    }
-}
-
-/// GET /auth/github/check
-#[utoipa::path(
-    get,
-    path = "/auth/github/check",
-    tag = "auth",
-    summary = "Check GitHub token validity",
-    description = "Validates the stored GitHub access token by making a test API call",
-    responses(
-        (status = 200, description = "GitHub token is valid"),
-        (status = 400, description = "GitHub token is invalid or missing")
-    )
-)]
-pub async fn github_check_token(State(app_state): State<AppState>) -> ResponseJson<ApiResponse<()>> {
-    let config = app_state.get_config().read().await;
-    let token = config.github.token.clone();
-    drop(config);
-    if let Some(token) = token {
-        let client = reqwest::Client::new();
-        let res = client
-            .get("https://api.github.com/user")
-            .bearer_auth(&token)
-            .header("User-Agent", "automagik-forge-app")
-            .send()
-            .await;
-        match res {
-            Ok(r) if r.status().is_success() => ResponseJson(ApiResponse::success(())),
-            _ => ResponseJson(ApiResponse::error("github_token_invalid")),
-        }
-    } else {
-        ResponseJson(ApiResponse::error("github_token_invalid"))
-    }
-}
-
-/// Middleware to set Sentry user context for every request
-pub async fn sentry_user_context_middleware(
-    State(app_state): State<AppState>,
-    req: Request,
-    next: Next,
-) -> Response {
-    app_state.update_sentry_scope().await;
-    next.run(req).await
-}