Bolt.new AI and JIRA integration: Step-by-Step Guide 2025

 

Setting Up JIRA Integration in Your Bolt.new AI Project

 

This guide will help you integrate JIRA into your Bolt.new AI project using TypeScript. We will create a dedicated file for JIRA interactions, add the necessary HTTP client code, and insert the integration code into your main project. Follow these steps carefully.

 

Prerequisites and Adding Dependencies

 

• You need a JIRA instance (Cloud or Server) with API access.
• Have your JIRA domain, username (or email), and API token ready.
• Since Bolt.new AI does not have a terminal, include the HTTP client dependency by adding its code snippet directly. We will use Axios as our HTTP client. Insert the Axios dependency code at the top of your main file.

 

Step One: Adding Axios Dependency Directly

 

• Open your main project file (for example, index.ts). At the very top, add the following code snippet to load Axios. This snippet uses an online CDN for Axios. Insert it at the beginning of your TypeScript file:

• 
  import axios from 'https://cdn.jsdelivr.net/npm/[email protected]/dist/axios.min.js';
  

 

Step Two: Creating a JIRA Integration File

 

• Create a new file called jira.ts in your project’s source directory.
• This file will contain all functions to interact with the JIRA REST API. Paste the following code snippet into jira.ts:

• 
  // Replace these with your JIRA details; you can secure these by using environment variables if supported
  const JIRA_DOMAIN = 'https://your-domain.atlassian.net';
  const JIRA_USER = '[email protected]';
  const JIRAAPITOKEN = 'yourapitoken';
  
  // Create a basic auth header for JIRA
  const authBuffer = btoa(${JIRA_USER}:${JIRA_API_TOKEN});
  const authHeader = { 'Authorization': Basic ${authBuffer} };
  export interface JiraIssue {
    fields: {
      project: {
        key: string;
      };
      summary: string;
      description: string;
      issuetype: {
        name: string;
      };
    };
  }
  /**
  
  Creates a new issue in JIRA.
  @param issueData An object containing the issue details.
  @returns A Promise resolving to the created issue data.
  
   */
  export async function createJiraIssue(issueData: JiraIssue): Promise {
    const url = ${JIRA_DOMAIN}/rest/api/2/issue;
    try {
      const response = await axios.post(url, issueData, {
        headers: {
          ...authHeader,
          'Content-Type': 'application/json'
        }
      });
      return response.data;
    } catch (error) {
      console.error('Error creating JIRA issue:', error);
      throw error;
    }
  }
  

  
  

 

Step Three: Integrating JIRA Code into Your Main Project

 

• Open your main project file (e.g., index.ts).
• Import the function you just created by adding the following line:

• 
  import { createJiraIssue } from './jira';
  

• Add a function call to create a JIRA issue wherever needed in your project. For example, you can add the snippet below to test the integration:

• 
  async function testJiraIntegration() {
    const newIssue = {
      fields: {
        project: {
          key: 'PROJ'  // Replace with your project's key
        },
        summary: 'Test Issue from Bolt.new AI Integration',
        description: 'This issue was created via the Bolt.new AI project's JIRA integration.',
        issuetype: {
          name: 'Task'
        }
      }
    };
  
    try {
      const result = await createJiraIssue(newIssue);
      console.log('JIRA Issue Created:', result);
    } catch (error) {
      console.error('Failed to create JIRA issue');
    }
  }
  // Call the test function (remove this call in production)
  testJiraIntegration();
  

  
  

 

Step Four: Ensuring Secure Storage of Credentials

 

• If Bolt.new AI supports environment variables, remove the hard-coded credentials in jira.ts and access them from the environment. For example:

• 
  // Instead of hardcoding, use environment variables if available
  const JIRADOMAIN = process.env.JIRADOMAIN;
  const JIRAUSER = process.env.JIRAUSER;
  const JIRAAPITOKEN = process.env.JIRAAPITOKEN;
  

• Then, add your environment variable configurations using Bolt.new AI's secrets management feature.

 

Step Five: Testing and Debugging

 

• Run your project by using the Bolt.new AI interface. Your code that calls testJiraIntegration() should attempt to create a JIRA issue.
• Open the browser console or use any logging facility provided by Bolt.new AI to view feedback from the integration.
• Check the JIRA dashboard to verify that the issue has been successfully created.
• If you encounter errors, review the console logs and verify your credentials and JIRA API permissions.

 

Final Integration Notes

 

• After confirming the integration works as expected, remove or comment out the test calls from your code.
• Keep your API tokens secure and consider advanced authentication (like OAuth) if necessary.
• Enhance the integration by adding more JIRA API functionalities as needed for your project.