automagik-forge 0.1.11 → 0.1.13

package/backend/src/models/task_template.rs

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,297 @@
+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
+}