jenkins-slack-mcp 1.0.0

package/.gitnexus/meta.json

@@ -0,0 +1,13 @@
+{
+  "repoPath": "/Users/seetharam/Documents/PANDO/slack-jenkins-trigger",
+  "lastCommit": "04fe0edbd4d1e1a4afbae2cd1a54eea2ae306197",
+  "indexedAt": "2026-06-24T14:41:59.735Z",
+  "stats": {
+    "files": 7,
+    "nodes": 35,
+    "edges": 75,
+    "communities": 11,
+    "processes": 5,
+    "embeddings": 0
+  }
+}

package/README.md

@@ -0,0 +1,116 @@
+# jenkins-slack-mcp
+
+MCP server to trigger Jenkins builds from any IDE (Amazon Q, VS Code, Cursor) with Slack notifications. Zero config — login once and it remembers.
+
+## Install
+
+```bash
+npm install -g github:Seetharam1999/jenkins-slack-mcp
+```
+
+## Register in your IDE
+
+**Amazon Q** (`~/.aws/amazonq/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "jenkins-slack": {
+      "command": "jenkins-slack-mcp",
+      "args": [],
+      "disabled": false
+    }
+  }
+}
+```
+
+**VS Code / Cursor** (`.vscode/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "jenkins-slack": {
+      "command": "jenkins-slack-mcp"
+    }
+  }
+}
+```
+
+**Without global install** (npx):
+```json
+{
+  "mcpServers": {
+    "jenkins-slack": {
+      "command": "npx",
+      "args": ["github:Seetharam1999/jenkins-slack-mcp"]
+    }
+  }
+}
+```
+
+## First-time Setup (from IDE chat)
+
+### 1. Login to Jenkins
+```
+login_jenkins:
+  baseUrl: https://your-jenkins.com
+  user: your_username
+  apiToken: your_api_token
+  buildToken: your_remote_trigger_token
+```
+
+### 2. Login to Slack
+```
+login_slack:
+  clientId: your_slack_app_client_id
+  clientSecret: your_slack_app_client_secret
+```
+Opens browser → OAuth → done.
+
+### 3. Register Jobs
+```
+add_job:
+  command: /buildtt
+  jobPath: /view/track-and-trace/job/track-and-trace
+  name: Track & Trace
+  defaultBranch: main
+```
+
+### 4. Trigger Builds
+```
+trigger_build:
+  job: /buildtt
+  branch: feature/my-branch
+  slackChannel: #deployments
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `login_jenkins` | Authenticate with Jenkins |
+| `login_slack` | OAuth login to Slack |
+| `status` | Check login status |
+| `whoami` | Get user details from both services |
+| `add_job` | Register a Jenkins job |
+| `list_jobs` | Show registered jobs |
+| `trigger_build` | Build + optional Slack notify |
+| `logout` | Clear stored credentials |
+
+## Slack Slash Commands (bonus)
+
+If you also want `/buildtt main` from Slack directly:
+
+```bash
+node server.js
+# Expose with ngrok:
+ngrok http 3001
+```
+
+Set Slack app slash command URL to `https://your-ngrok-url/slack/command`
+
+## Credentials
+
+Stored at `~/.jenkins-slack-mcp/config.json` (600 permissions, owner-only).
+
+## Author
+
+[Seetharam1999](https://github.com/Seetharam1999)

package/auth/credentials.js

@@ -0,0 +1,63 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.jenkins-slack-mcp');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { mode: 0o700 });
+}
+
+function loadConfig() {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_FILE)) return {};
+  return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+}
+
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+function getCredentials() {
+  const config = loadConfig();
+  return {
+    jenkins: config.jenkins || null,
+    slack: config.slack || null,
+  };
+}
+
+function saveJenkinsCredentials({ baseUrl, user, apiToken, buildToken }) {
+  const config = loadConfig();
+  config.jenkins = { baseUrl, user, apiToken, buildToken };
+  saveConfig(config);
+}
+
+function saveSlackCredentials({ botToken, userToken, teamName, userName }) {
+  const config = loadConfig();
+  config.slack = { botToken, userToken, teamName, userName };
+  saveConfig(config);
+}
+
+function saveJobs(jobs) {
+  const config = loadConfig();
+  config.jobs = jobs;
+  saveConfig(config);
+}
+
+function getJobs() {
+  const config = loadConfig();
+  return config.jobs || {};
+}
+
+function isConfigured() {
+  const creds = getCredentials();
+  return !!(creds.jenkins && creds.slack);
+}
+
+function clearAll() {
+  if (fs.existsSync(CONFIG_FILE)) fs.unlinkSync(CONFIG_FILE);
+}
+
+module.exports = { getCredentials, saveJenkinsCredentials, saveSlackCredentials, saveJobs, getJobs, isConfigured, clearAll };

package/auth/jenkins-auth.js

@@ -0,0 +1,25 @@
+const axios = require('axios');
+
+async function validateAndFetchUser(baseUrl, user, apiToken) {
+  const resp = await axios.get(`${baseUrl}/me/api/json`, {
+    auth: { username: user, password: apiToken },
+  });
+  return { fullName: resp.data.fullName, id: resp.data.id };
+}
+
+async function fetchJobs(baseUrl, user, apiToken) {
+  const resp = await axios.get(`${baseUrl}/api/json?tree=jobs[name,url,color]`, {
+    auth: { username: user, password: apiToken },
+  });
+  return resp.data.jobs || [];
+}
+
+async function triggerBuild({ baseUrl, user, apiToken, buildToken, jobPath, branch }) {
+  const url = `${baseUrl}${jobPath}/buildWithParameters`;
+  await axios.post(url, null, {
+    params: { token: buildToken, BRANCH: branch, cause: `MCP trigger for ${branch}` },
+    auth: { username: user, password: apiToken },
+  });
+}
+
+module.exports = { validateAndFetchUser, fetchJobs, triggerBuild };

package/auth/slack-auth.js

@@ -0,0 +1,72 @@
+const express = require('express');
+const axios = require('axios');
+const open = require('open');
+const { saveSlackCredentials } = require('./credentials');
+
+const SLACK_OAUTH_URL = 'https://slack.com/oauth/v2/authorize';
+const SLACK_TOKEN_URL = 'https://slack.com/api/oauth.v2.access';
+
+async function slackOAuthFlow({ clientId, clientSecret, scopes, port = 9876 }) {
+  return new Promise((resolve, reject) => {
+    const app = express();
+    const redirectUri = `http://localhost:${port}/slack/callback`;
+
+    const authUrl = `${SLACK_OAUTH_URL}?client_id=${clientId}&scope=${scopes.bot.join(',')}&user_scope=${scopes.user.join(',')}&redirect_uri=${encodeURIComponent(redirectUri)}`;
+
+    app.get('/slack/callback', async (req, res) => {
+      const { code, error } = req.query;
+      if (error) {
+        res.send('❌ Slack auth denied');
+        server.close();
+        return reject(new Error(error));
+      }
+
+      try {
+        const resp = await axios.post(SLACK_TOKEN_URL, null, {
+          params: { client_id: clientId, client_secret: clientSecret, code, redirect_uri: redirectUri },
+        });
+
+        const data = resp.data;
+        if (!data.ok) throw new Error(data.error);
+
+        const creds = {
+          botToken: data.access_token,
+          userToken: data.authed_user?.access_token,
+          teamName: data.team?.name,
+          userName: data.authed_user?.id,
+        };
+
+        saveSlackCredentials(creds);
+        res.send('✅ Slack connected! You can close this window.');
+        server.close();
+        resolve(creds);
+      } catch (err) {
+        res.send(`❌ Error: ${err.message}`);
+        server.close();
+        reject(err);
+      }
+    });
+
+    const server = app.listen(port, () => {
+      console.error(`Opening Slack OAuth... (listening on port ${port})`);
+      open(authUrl);
+    });
+
+    setTimeout(() => { server.close(); reject(new Error('OAuth timeout')); }, 120000);
+  });
+}
+
+async function getSlackUserInfo(token) {
+  const resp = await axios.get('https://slack.com/api/auth.test', {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  return resp.data;
+}
+
+async function postToSlack(token, channel, text) {
+  await axios.post('https://slack.com/api/chat.postMessage', { channel, text }, {
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+  });
+}
+
+module.exports = { slackOAuthFlow, getSlackUserInfo, postToSlack };

package/mcp-server.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { CallToolRequestSchema, ListToolsRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+const { getCredentials, saveJenkinsCredentials, saveJobs, getJobs, isConfigured, clearAll } = require('./auth/credentials');
+const { validateAndFetchUser, triggerBuild } = require('./auth/jenkins-auth');
+const { slackOAuthFlow, getSlackUserInfo, postToSlack } = require('./auth/slack-auth');
+
+const server = new Server({ name: 'jenkins-slack-mcp', version: '1.0.0' }, { capabilities: { tools: {} } });
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'login_jenkins',
+      description: 'Login to Jenkins. Validates credentials and stores them securely in ~/.jenkins-slack-mcp/',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          baseUrl: { type: 'string', description: 'Jenkins base URL (e.g. https://ci-ind.gopando.in)' },
+          user: { type: 'string', description: 'Jenkins username' },
+          apiToken: { type: 'string', description: 'Jenkins API token' },
+          buildToken: { type: 'string', description: 'Remote build trigger token configured in Jenkins job' },
+        },
+        required: ['baseUrl', 'user', 'apiToken', 'buildToken'],
+      },
+    },
+    {
+      name: 'login_slack',
+      description: 'Login to Slack via OAuth. Opens browser for authentication.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          clientId: { type: 'string', description: 'Slack App Client ID' },
+          clientSecret: { type: 'string', description: 'Slack App Client Secret' },
+        },
+        required: ['clientId', 'clientSecret'],
+      },
+    },
+    {
+      name: 'status',
+      description: 'Check current login status for Jenkins and Slack',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'add_job',
+      description: 'Register a Jenkins job that can be triggered',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Trigger command name (e.g. /buildtt)' },
+          jobPath: { type: 'string', description: 'Jenkins job path (e.g. /view/track-and-trace/job/track-and-trace)' },
+          name: { type: 'string', description: 'Friendly job name' },
+          defaultBranch: { type: 'string', description: 'Default branch if none specified' },
+        },
+        required: ['command', 'jobPath', 'name'],
+      },
+    },
+    {
+      name: 'list_jobs',
+      description: 'List all registered Jenkins jobs',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'trigger_build',
+      description: 'Trigger a Jenkins build and optionally notify Slack',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          job: { type: 'string', description: 'Job command (e.g. /buildtt) or job name' },
+          branch: { type: 'string', description: 'Branch to build' },
+          slackChannel: { type: 'string', description: 'Slack channel to notify (optional)' },
+        },
+        required: ['job'],
+      },
+    },
+    {
+      name: 'whoami',
+      description: 'Get current Jenkins and Slack user details',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'logout',
+      description: 'Clear all stored credentials',
+      inputSchema: { type: 'object', properties: {} },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'login_jenkins': {
+        const userInfo = await validateAndFetchUser(args.baseUrl, args.user, args.apiToken);
+        saveJenkinsCredentials(args);
+        return text(`✅ Jenkins login successful! Welcome, ${userInfo.fullName} (${userInfo.id})`);
+      }
+
+      case 'login_slack': {
+        const creds = await slackOAuthFlow({
+          clientId: args.clientId,
+          clientSecret: args.clientSecret,
+          scopes: {
+            bot: ['commands', 'chat:write', 'channels:read'],
+            user: ['chat:write'],
+          },
+        });
+        return text(`✅ Slack connected! Team: ${creds.teamName}`);
+      }
+
+      case 'status': {
+        const creds = getCredentials();
+        const jenkins = creds.jenkins ? `✅ Jenkins: ${creds.jenkins.user} @ ${creds.jenkins.baseUrl}` : '❌ Jenkins: not logged in';
+        const slack = creds.slack ? `✅ Slack: ${creds.slack.teamName}` : '❌ Slack: not logged in';
+        return text(`${jenkins}\n${slack}`);
+      }
+
+      case 'add_job': {
+        const jobs = getJobs();
+        jobs[args.command] = { path: args.jobPath, name: args.name, defaultBranch: args.defaultBranch || 'main' };
+        saveJobs(jobs);
+        return text(`✅ Job registered: ${args.command} → ${args.name} (default: ${args.defaultBranch || 'main'})`);
+      }
+
+      case 'list_jobs': {
+        const jobs = getJobs();
+        if (!Object.keys(jobs).length) return text('No jobs configured. Use add_job to register one.');
+        const list = Object.entries(jobs).map(([cmd, j]) => `• ${cmd} → ${j.name} (default: ${j.defaultBranch})`).join('\n');
+        return text(list);
+      }
+
+      case 'trigger_build': {
+        const creds = getCredentials();
+        if (!creds.jenkins) return text('❌ Not logged into Jenkins. Use login_jenkins first.');
+
+        const jobs = getJobs();
+        const job = jobs[args.job];
+        if (!job) return text(`❌ Unknown job: ${args.job}. Available: ${Object.keys(jobs).join(', ')}`);
+
+        const branch = args.branch || job.defaultBranch;
+        await triggerBuild({
+          baseUrl: creds.jenkins.baseUrl,
+          user: creds.jenkins.user,
+          apiToken: creds.jenkins.apiToken,
+          buildToken: creds.jenkins.buildToken,
+          jobPath: job.path,
+          branch,
+        });
+
+        let msg = `✅ *${job.name}* build triggered on \`${branch}\``;
+
+        // Notify Slack if channel provided and logged in
+        if (args.slackChannel && creds.slack?.botToken) {
+          await postToSlack(creds.slack.botToken, args.slackChannel, `🚀 ${job.name} build triggered on branch: ${branch}`);
+          msg += `\n📢 Notified Slack channel: ${args.slackChannel}`;
+        }
+
+        return text(msg);
+      }
+
+      case 'whoami': {
+        const creds = getCredentials();
+        const parts = [];
+        if (creds.jenkins) {
+          const userInfo = await validateAndFetchUser(creds.jenkins.baseUrl, creds.jenkins.user, creds.jenkins.apiToken);
+          parts.push(`Jenkins: ${userInfo.fullName} (${userInfo.id}) @ ${creds.jenkins.baseUrl}`);
+        } else {
+          parts.push('Jenkins: not logged in');
+        }
+        if (creds.slack?.botToken) {
+          const slackInfo = await getSlackUserInfo(creds.slack.botToken);
+          parts.push(`Slack: ${slackInfo.user} @ ${slackInfo.team}`);
+        } else {
+          parts.push('Slack: not logged in');
+        }
+        return text(parts.join('\n'));
+      }
+
+      case 'logout': {
+        clearAll();
+        return text('✅ All credentials cleared.');
+      }
+
+      default:
+        return text(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    return { content: [{ type: 'text', text: `❌ Error: ${err.message}` }], isError: true };
+  }
+});
+
+function text(msg) {
+  return { content: [{ type: 'text', text: msg }] };
+}
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Jenkins-Slack MCP server running');
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "jenkins-slack-mcp",
+  "version": "1.0.0",
+  "description": "MCP server to trigger Jenkins builds from any IDE with Slack notifications. Auto-configures via interactive login.",
+  "main": "mcp-server.js",
+  "bin": {
+    "jenkins-slack-mcp": "mcp-server.js"
+  },
+  "scripts": {
+    "start": "node mcp-server.js",
+    "server": "node server.js"
+  },
+  "keywords": [
+    "mcp",
+    "jenkins",
+    "slack",
+    "ci",
+    "build",
+    "model-context-protocol",
+    "amazon-q",
+    "ide"
+  ],
+  "author": "Seetharam1999 (https://github.com/Seetharam1999)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.0",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "open": "^9.1.0"
+  }
+}

package/server.js

@@ -0,0 +1,39 @@
+const express = require('express');
+const { getCredentials, getJobs } = require('./auth/credentials');
+const { triggerBuild } = require('./auth/jenkins-auth');
+
+const app = express();
+app.use(express.urlencoded({ extended: true }));
+
+app.post('/slack/command', async (req, res) => {
+  const { command, text, user_name } = req.body;
+  const branch = text.trim() || undefined;
+  const creds = getCredentials();
+  const jobs = getJobs();
+
+  if (!creds.jenkins) return res.json({ text: '❌ Jenkins not configured. Run MCP login_jenkins first.' });
+
+  const job = jobs[command];
+  if (!job) return res.json({ text: `❌ Unknown job: ${command}` });
+
+  const branchName = branch || job.defaultBranch;
+
+  try {
+    await triggerBuild({
+      baseUrl: creds.jenkins.baseUrl,
+      user: creds.jenkins.user,
+      apiToken: creds.jenkins.apiToken,
+      buildToken: creds.jenkins.buildToken,
+      jobPath: job.path,
+      branch: branchName,
+    });
+    res.json({ response_type: 'in_channel', text: `✅ *${job.name}* build triggered on \`${branchName}\` by @${user_name}` });
+  } catch (err) {
+    res.json({ response_type: 'ephemeral', text: `❌ Failed: ${err.message}` });
+  }
+});
+
+app.get('/health', (_, res) => res.send('ok'));
+
+const PORT = process.env.PORT || 3001;
+app.listen(PORT, () => console.log(`Slack command server on port ${PORT}`));