Crate threatflux_atlassian_sdk 

Atlassian Rust SDK

A comprehensive Rust SDK for Atlassian products with dual architecture support: Remote MCP Server (recommended) and Direct API access for Jira, Confluence, and Compass.

Features

• 🌐 Remote MCP Server: OAuth 2.1 authentication via https://mcp.atlassian.com/v1/sse
• 🔑 OAuth 2.1 + PKCE: Secure browser-based authentication with MCP auth screen
• 📋 Jira Operations: Complete ticket CRUD, search, custom fields (story points, complexity)
• 📖 Confluence: Content management and documentation operations
• 🧭 Compass: Service landscape and component management
• 🔒 Security: Respects existing Atlassian Cloud permissions and access controls
• ⚡ Async Support: Built on Tokio for high-performance operations
• 🏢 Enterprise Ready: SSL verification and corporate environment support

Remote MCP Server (Recommended)

Use Atlassian’s cloud-based Remote MCP Server for secure, permission-respecting operations:

use threatflux_atlassian_sdk::AtlassianRemoteClient;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create Remote MCP client
    let client = AtlassianRemoteClient::new(
        "your-oauth-client-id".to_string(),
        8080  // Local callback port
    )?;

    // Initialize OAuth 2.1 authentication (shows auth screen)
    let auth_response = client.initialize_auth().await?;
    println!("Visit auth URL: {}", auth_response["auth_url"]);

    // After OAuth completion...
    // client.complete_auth(auth_code, state).await?;

    // Use Jira operations via Remote MCP Server
    let issue = client.get_issue("PROJ-123").await?;
    client.update_story_points("PROJ-123", 8.0, "customfield_10100").await?;

    Ok(())
}

Direct API Client (Legacy)

For direct Jira API access (requires API tokens):

use threatflux_atlassian_sdk::{AtlassianClient, AtlassianConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = AtlassianClient::from_env()?;
    let issue = client.get_issue("PROJ-123").await?;
    Ok(())
}

OAuth Configuration

For Remote MCP Server (OAuth 2.1):

export ATLASSIAN_CLIENT_ID="your-oauth-client-id"
export ATLASSIAN_CALLBACK_PORT="8080"           # Optional: OAuth callback port

For Direct API (Legacy):

export JIRA_URL="https://company.atlassian.net"
export JIRA_USERNAME="user@company.com"
export JIRA_API_TOKEN="your-api-token"

Advanced Usage

use threatflux_atlassian_sdk::{AtlassianConfig, AtlassianClient};
use threatflux_atlassian_sdk::{CreateIssueRequest, CreateIssueFields};
use threatflux_atlassian_sdk::{ProjectReference, IssueTypeReference, UserReference};
use std::time::Duration;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create custom configuration
    let config = AtlassianConfig::builder()
        .base_url("https://company.atlassian.net")
        .username("user@company.com")
        .api_token("your-api-token")
        .timeout(Duration::from_secs(30))
        .verify_ssl(true)
        .retries(5, Duration::from_millis(500))
        .build()?;

    let client = AtlassianClient::new(config)?;

    // Create a new issue
    let mut custom_fields = HashMap::new();
    custom_fields.insert("customfield_11024".to_string(),
                         serde_json::json!({"value": "Security"}));

    let create_request = CreateIssueRequest {
        fields: CreateIssueFields {
            project: ProjectReference::by_key("TMP"),
            summary: "New security task".to_string(),
            issue_type: IssueTypeReference::by_name("Task"),
            description: Some("Security enhancement task".to_string()),
            assignee: Some(UserReference::by_account_id("account123")),
            priority: None,
            labels: Some(vec!["security".to_string(), "automation".to_string()]),
            components: None,
            parent: None,
            custom_fields,
        },
    };

    let created_issue = client.create_issue(create_request).await?;
    println!("Created issue: {}", created_issue.key);

    Ok(())
}

Re-exports

pub use auth::AccessToken;

pub use auth::AuthManager;

pub use auth::AuthorizationResponse;

pub use auth::McpAuthHandler;

pub use auth::OAuthConfig;

pub use client::AtlassianClient;

pub use config::AtlassianConfig;

pub use config::AtlassianConfigBuilder;

pub use error::AtlassianError;

pub use error::Result;

pub use remote_client::AtlassianRemoteClient;

pub use types::*;

Modules

auth

OAuth 2.1 authentication for Atlassian Remote MCP Server

client

Jira API client implementation

config

Configuration management for the Atlassian Rust SDK

error

Error handling for the Atlassian Rust SDK

remote_client

Atlassian Remote MCP Server client implementation

types

Data structures for Jira API objects

Enums

JsonValue

Represents any valid JSON value.

Constants

API_VERSION

Default Jira API version

VERSION

SDK version information

Functions

version

Get SDK version