jenkins-slack-mcp 1.0.3 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # jenkins-slack-mcp
 
-MCP server to trigger Jenkins builds from any IDE (Amazon Q, VS Code, Cursor, Claude Desktop) with Slack notifications. Zero config — login once and it remembers.
+MCP server to trigger Jenkins builds from any IDE with Slack DM notifications. Auto-discovers all jobs on login — no manual configuration.
 
 ## Install
 
@@ -10,10 +10,9 @@ npm install -g jenkins-slack-mcp
 
 ## Register in your IDE
 
-### Amazon Q (VS Code / JetBrains)
-
-Edit `~/.aws/amazonq/mcp.json`:
+### Amazon Q
 
+`~/.aws/amazonq/mcp.json`:
 ```json
 {
   "mcpServers": {
@@ -26,51 +25,40 @@ Edit `~/.aws/amazonq/mcp.json`:
 }
 ```
 
-### VS Code (Copilot / Cline / Roo)
-
-Edit `.vscode/mcp.json` in your workspace:
+### VS Code
 
+`.vscode/mcp.json`:
 ```json
 {
   "mcpServers": {
-    "jenkins-slack": {
-      "command": "jenkins-slack-mcp"
-    }
+    "jenkins-slack": { "command": "jenkins-slack-mcp" }
   }
 }
 ```
 
 ### Claude Desktop
 
-Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
-
+`~/Library/Application Support/Claude/claude_desktop_config.json` (macOS):
 ```json
 {
   "mcpServers": {
-    "jenkins-slack": {
-      "command": "jenkins-slack-mcp"
-    }
+    "jenkins-slack": { "command": "jenkins-slack-mcp" }
   }
 }
 ```
 
 ### Cursor
 
-Edit `.cursor/mcp.json` in your workspace:
-
+`.cursor/mcp.json`:
 ```json
 {
   "mcpServers": {
-    "jenkins-slack": {
-      "command": "jenkins-slack-mcp"
-    }
+    "jenkins-slack": { "command": "jenkins-slack-mcp" }
   }
 }
 ```
 
-### Without global install (npx)
-
-Use this in any of the above configs instead:
+### Without global install
 
 ```json
 {
@@ -83,72 +71,130 @@ Use this in any of the above configs instead:
 }
 ```
 
-## First-time Setup (from IDE chat)
+---
+
+## Flow of Work
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  1. login_jenkins (baseUrl only)                        │
+│     → Opens browser to Jenkins token page               │
+│     → User copies API token + build trigger token       │
+│                                                         │
+│  2. login_jenkins (all params)                          │
+│     → Validates credentials                             │
+│     → Auto-discovers ALL jobs from Jenkins              │
+│     → Stores securely at ~/.jenkins-slack-mcp/          │
+│                                                         │
+│  3. list_jobs / list_jobs filter="tms"                  │
+│     → Shows jobs in table with status (✅ ❌ ⏸️)        │
+│                                                         │
+│  4. job_details jobName="my-job"                        │
+│     → Shows all parameters (name, type, default,        │
+│       choices) in table format                          │
+│                                                         │
+│  5. trigger_build jobName="my-job" params={...}         │
+│     → Triggers build with params                        │
+│     → Sends Slack DM to you (if configured)             │
+│     → Posts to channel (if notifyChannel provided)      │
+│                                                         │
+│  (Optional) setup_slack                                 │
+│     → Configure bot token + your Slack User ID          │
+│     → Get DM notifications on every build trigger       │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Usage
+
+### Step 1: Login to Jenkins
 
-Once the MCP is registered, use these tools from your IDE chat:
+First time — just provide the URL, browser opens automatically:
+```
+login_jenkins baseUrl="https://jenkins.example.com"
+```
+→ Browser opens Jenkins → Copy your API token and build trigger token.
 
-### 1. Login to Jenkins
+Then login with full credentials:
 ```
 login_jenkins:
   baseUrl: https://jenkins.example.com
   user: your_username
   apiToken: your_api_token
-  buildToken: your_remote_trigger_token
+  buildToken: your_build_trigger_token
 ```
+→ All jobs auto-discovered!
+
+### Step 2: Browse Jobs
 
-### 2. Login to Slack (optional, for notifications)
 ```
-login_slack:
-  clientId: your_slack_app_client_id
-  clientSecret: your_slack_app_client_secret
+list_jobs                    # all jobs
+list_jobs filter="tms"       # filter by name
 ```
-Opens browser → OAuth → done.
 
-### 3. Register Jobs
+Output:
+| # | Job Name | Status |
+|---|----------|--------|
+| 1 | tms-docker-build-new | ✅ Success |
+| 2 | tms-constants | ✅ Success |
+| 3 | TMS-version-update | ✅ Success |
+
+### Step 3: Check Parameters
+
 ```
-add_job:
-  command: /build-backend
-  jobPath: /job/my-backend-service
-  name: Backend Service
-  defaultBranch: main
+job_details jobName="tms-docker-build-new"
 ```
 
-### 4. Trigger Builds
+Output:
+| Parameter | Type | Default | Choices | Description |
+|-----------|------|---------|---------|-------------|
+| BRANCH | String | main | - | Branch to build |
+
+### Step 4: Trigger Build
+
 ```
-trigger_build:
-  job: /build-backend
-  branch: feature/my-branch
-  slackChannel: #deployments
+trigger_build jobName="tms-docker-build-new" params={"BRANCH": "feature/xyz"}
 ```
 
-## Available Tools
+### Step 5 (Optional): Setup Slack DMs
 
-| Tool | Description |
-|------|-------------|
-| `login_jenkins` | Authenticate with Jenkins |
-| `login_slack` | OAuth login to Slack (opens browser) |
-| `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 |
+```
+setup_slack:
+  botToken: xoxb-your-bot-token
+  userId: U0123456789
+```
 
-## Credentials
+**How to get your Slack User ID:**
+1. Open Slack → Click your profile picture
+2. Click "Profile" → Click "..." (more)
+3. Click "Copy Member ID"
 
-Stored at `~/.jenkins-slack-mcp/config.json` (600 permissions, owner-only). Shared across all IDEs.
+**How to get bot token:**
+1. Go to https://api.slack.com/apps → Your App
+2. OAuth & Permissions → Bot User OAuth Token (starts with `xoxb-`)
 
-## Slack Slash Commands (bonus)
+After setup, every `trigger_build` sends you a DM automatically.
 
-If you also want `/build-app main` from Slack directly:
+---
 
-```bash
-node server.js
-# Expose with ngrok:
-ngrok http 3001
-```
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `login_jenkins` | Login + auto-discover jobs (opens browser for new users) |
+| `setup_slack` | Configure Slack bot token + User ID for DM notifications |
+| `status` | Check login status + job count |
+| `list_jobs` | All jobs in table format (filterable) |
+| `job_details` | Show parameters for a job |
+| `trigger_build` | Trigger build + Slack DM + channel notify |
+| `refresh_jobs` | Re-fetch jobs from Jenkins |
+| `whoami` | Current user details |
+| `logout` | Clear all credentials |
+
+## Credentials
 
-Set Slack app slash command URL to `https://your-ngrok-url/slack/command`
+Stored at `~/.jenkins-slack-mcp/config.json` (600 permissions, owner-only).
 
 ## Author
 

package/auth/credentials.js

@@ -22,10 +22,7 @@ function saveConfig(config) {
 
 function getCredentials() {
   const config = loadConfig();
-  return {
-    jenkins: config.jenkins || null,
-    slack: config.slack || null,
-  };
+  return { jenkins: config.jenkins || null, slack: config.slack || null };
 }
 
 function saveJenkinsCredentials({ baseUrl, user, apiToken, buildToken }) {
@@ -34,9 +31,9 @@ function saveJenkinsCredentials({ baseUrl, user, apiToken, buildToken }) {
   saveConfig(config);
 }
 
-function saveSlackCredentials({ botToken, userToken, teamName, userName }) {
+function saveSlackConfig({ botToken, userId }) {
   const config = loadConfig();
-  config.slack = { botToken, userToken, teamName, userName };
+  config.slack = { botToken, userId };
   saveConfig(config);
 }
 
@@ -51,13 +48,8 @@ function getJobs() {
   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 };
+module.exports = { getCredentials, saveJenkinsCredentials, saveSlackConfig, saveJobs, getJobs, clearAll };

package/auth/jenkins-auth.js

@@ -1,4 +1,11 @@
 const axios = require('axios');
+const open = require('open');
+
+async function openJenkinsTokenPage(baseUrl) {
+  const tokenUrl = `${baseUrl}/me/configure`;
+  await open(tokenUrl);
+  return tokenUrl;
+}
 
 async function validateAndFetchUser(baseUrl, user, apiToken) {
   const resp = await axios.get(`${baseUrl}/me/api/json`, {
@@ -7,19 +14,33 @@ async function validateAndFetchUser(baseUrl, user, 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]`, {
+async function fetchAllJobs(baseUrl, user, apiToken) {
+  const resp = await axios.get(`${baseUrl}/api/json?tree=jobs[name,url,color,_class]`, {
     auth: { username: user, password: apiToken },
   });
   return resp.data.jobs || [];
 }
 
-async function triggerBuild({ baseUrl, user, apiToken, buildToken, jobPath, branch }) {
+async function fetchJobParams(baseUrl, user, apiToken, jobPath) {
+  try {
+    const url = `${baseUrl}${jobPath}/api/json?tree=property[parameterDefinitions[name,type,defaultParameterValue[value],description,choices]]`;
+    const resp = await axios.get(url, { auth: { username: user, password: apiToken } });
+    const props = resp.data.property || [];
+    for (const p of props) {
+      if (p.parameterDefinitions) return p.parameterDefinitions;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+async function triggerBuild({ baseUrl, user, apiToken, buildToken, jobPath, params }) {
   const url = `${baseUrl}${jobPath}/buildWithParameters`;
   await axios.post(url, null, {
-    params: { token: buildToken, BRANCH: branch, cause: `MCP trigger for ${branch}` },
+    params: { token: buildToken, cause: 'MCP trigger', ...params },
     auth: { username: user, password: apiToken },
   });
 }
 
-module.exports = { validateAndFetchUser, fetchJobs, triggerBuild };
+module.exports = { openJenkinsTokenPage, validateAndFetchUser, fetchAllJobs, fetchJobParams, triggerBuild };

package/auth/slack-auth.js

@@ -1,72 +1,31 @@
-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 sendSlackDM(botToken, userId, message) {
+  // Open DM channel with user
+  const openResp = await axios.post('https://slack.com/api/conversations.open', 
+    { users: userId },
+    { headers: { Authorization: `Bearer ${botToken}`, 'Content-Type': 'application/json' } }
+  );
+  
+  if (!openResp.data.ok) throw new Error(`Slack DM open failed: ${openResp.data.error}`);
+  
+  const channelId = openResp.data.channel.id;
+  
+  // Send message
+  const msgResp = await axios.post('https://slack.com/api/chat.postMessage',
+    { channel: channelId, text: message },
+    { headers: { Authorization: `Bearer ${botToken}`, 'Content-Type': 'application/json' } }
+  );
+  
+  if (!msgResp.data.ok) throw new Error(`Slack message failed: ${msgResp.data.error}`);
 }
 
-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' },
-  });
+async function postToChannel(botToken, channel, message) {
+  const resp = await axios.post('https://slack.com/api/chat.postMessage',
+    { channel, text: message },
+    { headers: { Authorization: `Bearer ${botToken}`, 'Content-Type': 'application/json' } }
+  );
+  if (!resp.data.ok) throw new Error(`Slack post failed: ${resp.data.error}`);
 }
 
-module.exports = { slackOAuthFlow, getSlackUserInfo, postToSlack };
+module.exports = { sendSlackDM, postToChannel };

package/mcp-server.js

@@ -2,38 +2,38 @@
 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 { getCredentials, saveJenkinsCredentials, saveSlackConfig, saveJobs, getJobs, clearAll } = require('./auth/credentials');
+const { openJenkinsTokenPage, validateAndFetchUser, fetchAllJobs, fetchJobParams, triggerBuild } = require('./auth/jenkins-auth');
+const { sendSlackDM, postToChannel } = require('./auth/slack-auth');
 
-const server = new Server({ name: 'jenkins-slack-mcp', version: '1.0.0' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'jenkins-slack-mcp', version: '1.0.4' }, { capabilities: { tools: {} } });
 
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
     {
       name: 'login_jenkins',
-      description: 'Login to Jenkins. Validates credentials and stores them securely in ~/.jenkins-slack-mcp/',
+      description: 'Login to Jenkins. Opens browser to Jenkins token page for new users. Validates credentials and auto-discovers all jobs.',
       inputSchema: {
         type: 'object',
         properties: {
           baseUrl: { type: 'string', description: 'Jenkins base URL (e.g. https://jenkins.example.com)' },
           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' },
+          apiToken: { type: 'string', description: 'Jenkins API token (get from Jenkins → User → Configure → API Token)' },
+          buildToken: { type: 'string', description: 'Remote build trigger token' },
         },
-        required: ['baseUrl', 'user', 'apiToken', 'buildToken'],
+        required: ['baseUrl'],
       },
     },
     {
-      name: 'login_slack',
-      description: 'Login to Slack via OAuth. Opens browser for authentication.',
+      name: 'setup_slack',
+      description: 'Configure Slack notifications. Set bot token and your Slack User ID to receive DMs on build trigger.',
       inputSchema: {
         type: 'object',
         properties: {
-          clientId: { type: 'string', description: 'Slack App Client ID' },
-          clientSecret: { type: 'string', description: 'Slack App Client Secret' },
+          botToken: { type: 'string', description: 'Slack Bot OAuth Token (xoxb-...)' },
+          userId: { type: 'string', description: 'Your Slack User ID (found in Profile → ... → Copy Member ID)' },
         },
-        required: ['clientId', 'clientSecret'],
+        required: ['botToken', 'userId'],
       },
     },
     {
@@ -42,37 +42,44 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
       inputSchema: { type: 'object', properties: {} },
     },
     {
-      name: 'add_job',
-      description: 'Register a Jenkins job that can be triggered',
+      name: 'list_jobs',
+      description: 'List all available Jenkins jobs in table format with status. Supports filtering by name.',
       inputSchema: {
         type: 'object',
         properties: {
-          command: { type: 'string', description: 'Trigger command name (e.g. /build-app)' },
-          jobPath: { type: 'string', description: 'Jenkins job path (e.g. /job/my-app or /view/my-view/job/my-app)' },
-          name: { type: 'string', description: 'Friendly job name' },
-          defaultBranch: { type: 'string', description: 'Default branch if none specified' },
+          filter: { type: 'string', description: 'Filter jobs by name (e.g. "tms", "optima")' },
         },
-        required: ['command', 'jobPath', 'name'],
       },
     },
     {
-      name: 'list_jobs',
-      description: 'List all registered Jenkins jobs',
-      inputSchema: { type: 'object', properties: {} },
+      name: 'job_details',
+      description: 'Get build parameters for a specific Jenkins job in table format.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          jobName: { type: 'string', description: 'Jenkins job name (e.g. tms-docker-build-new)' },
+        },
+        required: ['jobName'],
+      },
     },
     {
       name: 'trigger_build',
-      description: 'Trigger a Jenkins build and optionally notify Slack',
+      description: 'Trigger a Jenkins build with parameters. Sends Slack DM if configured.',
       inputSchema: {
         type: 'object',
         properties: {
-          job: { type: 'string', description: 'Job command (e.g. /build-app) or job name' },
-          branch: { type: 'string', description: 'Branch to build' },
-          slackChannel: { type: 'string', description: 'Slack channel to notify (optional)' },
+          jobName: { type: 'string', description: 'Jenkins job name' },
+          params: { type: 'object', description: 'Build parameters as key-value pairs (e.g. {"BRANCH": "main"})' },
+          notifyChannel: { type: 'string', description: 'Slack channel to notify (optional, e.g. #deployments)' },
         },
-        required: ['job'],
+        required: ['jobName'],
       },
     },
+    {
+      name: 'refresh_jobs',
+      description: 'Re-fetch all jobs from Jenkins (use after new jobs are created)',
+      inputSchema: { type: 'object', properties: {} },
+    },
     {
       name: 'whoami',
       description: 'Get current Jenkins and Slack user details',
@@ -80,7 +87,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'logout',
-      description: 'Clear all stored credentials',
+      description: 'Clear all stored credentials and jobs',
       inputSchema: { type: 'object', properties: {} },
     },
   ],
@@ -92,109 +99,214 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     switch (name) {
       case 'login_jenkins': {
+        // If only baseUrl provided, open browser for user to get token
+        if (!args.user || !args.apiToken) {
+          const tokenUrl = await openJenkinsTokenPage(args.baseUrl);
+          return text(
+            `🌐 Opening Jenkins in your browser...\n\n` +
+            `**Steps to get your credentials:**\n` +
+            `1. Login at: ${args.baseUrl}\n` +
+            `2. Go to: ${tokenUrl}\n` +
+            `3. Under "API Token" → Click "Add new Token" → Generate\n` +
+            `4. Copy the token\n` +
+            `5. For build trigger token: Go to Job → Configure → Build Triggers → "Trigger builds remotely" → Copy token\n\n` +
+            `Then call login_jenkins again with all 4 parameters:\n` +
+            `- baseUrl: ${args.baseUrl}\n` +
+            `- user: your_username\n` +
+            `- apiToken: (the token you just generated)\n` +
+            `- buildToken: (the remote trigger token)`
+          );
+        }
+
+        // Validate credentials
         const userInfo = await validateAndFetchUser(args.baseUrl, args.user, args.apiToken);
         saveJenkinsCredentials(args);
-        return text(`✅ Jenkins login successful! Welcome, ${userInfo.fullName} (${userInfo.id})`);
+
+        // Auto-discover all jobs
+        const allJobs = await fetchAllJobs(args.baseUrl, args.user, args.apiToken);
+        const buildableJobs = {};
+        for (const j of allJobs) {
+          if (j._class === 'com.cloudbees.hudson.plugins.folder.Folder') continue;
+          buildableJobs[j.name] = { path: `/job/${encodeURIComponent(j.name)}`, name: j.name, color: j.color || 'unknown' };
+        }
+        saveJobs(buildableJobs);
+
+        const jobCount = Object.keys(buildableJobs).length;
+        let msg = `✅ Jenkins login successful! Welcome, ${userInfo.fullName}\n`;
+        msg += `📋 Auto-discovered ${jobCount} jobs.\n\n`;
+        msg += `Use **list_jobs** to see all jobs or **list_jobs filter="tms"** to search.\n`;
+        msg += `Use **job_details** to see parameters before triggering.`;
+
+        const creds = getCredentials();
+        if (!creds.slack) {
+          msg += `\n\n💡 Set up Slack notifications with **setup_slack** to get DMs on build trigger.`;
+        }
+        return text(msg);
       }
 
-      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 'setup_slack': {
+        saveSlackConfig({ botToken: args.botToken, userId: args.userId });
+
+        // Test by sending a welcome DM
+        try {
+          await sendSlackDM(args.botToken, args.userId, '✅ Jenkins-Slack MCP connected! You will receive build notifications here.');
+          return text(`✅ Slack configured!\n- User ID: ${args.userId}\n- ✉️ Test DM sent to you successfully.`);
+        } catch (err) {
+          return text(`⚠️ Slack config saved but test DM failed: ${err.message}\nCheck your bot token and user ID.`);
+        }
       }
 
       case 'status': {
         const creds = getCredentials();
-        const jenkins = creds.jenkins ? `✅ Jenkins: ${creds.jenkins.user} @ ${creds.jenkins.baseUrl}` : '❌ Jenkins: not logged in. Use login_jenkins to connect.';
-        const slack = creds.slack ? `✅ Slack: ${creds.slack.teamName}` : '❌ Slack: not logged in. Use login_slack to connect.';
-        return text(`${jenkins}\n${slack}`);
+        const jobCount = Object.keys(getJobs()).length;
+        const jenkins = creds.jenkins
+          ? `✅ Jenkins: ${creds.jenkins.user} @ ${creds.jenkins.baseUrl}`
+          : '❌ Jenkins: not logged in. Use **login_jenkins** to connect.';
+        const slack = creds.slack
+          ? `✅ Slack: User ID ${creds.slack.userId} (DM notifications enabled)`
+          : '❌ Slack: not configured. Use **setup_slack** to enable notifications.';
+        return text(`${jenkins}\n${slack}\n📋 Jobs available: ${jobCount}`);
       }
 
-      case 'add_job': {
+      case 'list_jobs': {
         const creds = getCredentials();
-        if (!creds.jenkins) return text('❌ Not logged into Jenkins. Use login_jenkins first.');
+        if (!creds.jenkins) return text('❌ Not logged into Jenkins. Use **login_jenkins** first.');
 
         const jobs = getJobs();
-        jobs[args.command] = { path: args.jobPath, name: args.name, defaultBranch: args.defaultBranch || 'main' };
-        saveJobs(jobs);
+        if (!Object.keys(jobs).length) return text('No jobs found. Use **refresh_jobs** to re-fetch.');
 
-        let msg = `✅ Job registered: ${args.command} → ${args.name} (default: ${args.defaultBranch || 'main'})`;
-        if (!creds.slack) {
-          msg += `\n\n💡 Tip: Connect Slack with login_slack to get build notifications in your channels.`;
+        let filtered = Object.entries(jobs);
+        if (args.filter) {
+          const f = args.filter.toLowerCase();
+          filtered = filtered.filter(([n]) => n.toLowerCase().includes(f));
         }
-        return text(msg);
+
+        if (!filtered.length) return text(`No jobs matching "${args.filter}".`);
+
+        let table = `| # | Job Name | Status |\n|---|----------|--------|\n`;
+        filtered.slice(0, 50).forEach(([, job], i) => {
+          const status = job.color === 'blue' ? '✅ Success' : job.color === 'red' ? '❌ Failed' : job.color === 'disabled' ? '⏸️ Disabled' : job.color === 'notbuilt' ? '⬜ Not built' : `⚠️ ${job.color}`;
+          table += `| ${i + 1} | ${job.name} | ${status} |\n`;
+        });
+
+        if (filtered.length > 50) table += `\n_...${filtered.length - 50} more. Narrow with filter._`;
+        table += `\n\nUse **job_details jobName="<name>"** to see parameters.`;
+        return text(table);
       }
 
-      case 'list_jobs': {
+      case 'job_details': {
+        const creds = getCredentials();
+        if (!creds.jenkins) return text('❌ Not logged into Jenkins. Use **login_jenkins** first.');
+
         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);
+        const job = jobs[args.jobName];
+        if (!job) return text(`❌ Job "${args.jobName}" not found. Use **list_jobs** to see available jobs.`);
+
+        const params = await fetchJobParams(creds.jenkins.baseUrl, creds.jenkins.user, creds.jenkins.apiToken, job.path);
+
+        let msg = `## ${job.name}\n`;
+        msg += `**Status:** ${job.color === 'blue' ? '✅ Success' : job.color === 'red' ? '❌ Failed' : job.color}\n\n`;
+
+        if (params.length === 0) {
+          msg += `**Parameters:** None required\n`;
+          msg += `\n→ Trigger with: **trigger_build jobName="${job.name}"**`;
+        } else {
+          msg += `| Parameter | Type | Default | Choices | Description |\n|-----------|------|---------|---------|-------------|\n`;
+          params.forEach(p => {
+            const def = p.defaultParameterValue?.value || '-';
+            const type = (p.type || '').replace('ParameterDefinition', '');
+            const desc = p.description || '-';
+            const choices = p.choices ? p.choices.join(', ') : '-';
+            msg += `| ${p.name} | ${type} | ${def} | ${choices} | ${desc} |\n`;
+          });
+          const example = params.map(p => `"${p.name}": "${p.defaultParameterValue?.value || 'value'}"`).join(', ');
+          msg += `\n→ Trigger with: **trigger_build jobName="${job.name}" params={${example}}**`;
+        }
+        return text(msg);
       }
 
       case 'trigger_build': {
         const creds = getCredentials();
-        if (!creds.jenkins) return text('❌ Not logged into Jenkins. Use login_jenkins first.');
+        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 job = jobs[args.jobName];
+        if (!job) return text(`❌ Job "${args.jobName}" not found. Use **list_jobs** to see available jobs.`);
 
-        const branch = args.branch || job.defaultBranch;
+        const params = args.params || {};
         await triggerBuild({
           baseUrl: creds.jenkins.baseUrl,
           user: creds.jenkins.user,
           apiToken: creds.jenkins.apiToken,
           buildToken: creds.jenkins.buildToken,
           jobPath: job.path,
-          branch,
+          params,
         });
 
-        let msg = `✅ *${job.name}* build triggered on \`${branch}\``;
+        const paramStr = Object.entries(params).map(([k, v]) => `${k}=${v}`).join(', ') || 'defaults';
+        let msg = `✅ **${job.name}** build triggered (${paramStr})`;
+
+        // Send Slack DM to user
+        if (creds.slack?.botToken && creds.slack?.userId) {
+          try {
+            await sendSlackDM(creds.slack.botToken, creds.slack.userId, `🚀 *${job.name}* build triggered\nParams: ${paramStr}\nTriggered by: ${creds.jenkins.user}`);
+            msg += `\n✉️ Slack DM sent to you.`;
+          } catch (err) {
+            msg += `\n⚠️ Slack DM failed: ${err.message}`;
+          }
+        }
 
-        // 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}`;
-        } else if (args.slackChannel && !creds.slack) {
-          msg += `\n⚠️ Slack not connected. Use login_slack to enable Slack notifications.`;
+        // Notify channel if specified
+        if (args.notifyChannel && creds.slack?.botToken) {
+          try {
+            await postToChannel(creds.slack.botToken, args.notifyChannel, `🚀 *${job.name}* build triggered (${paramStr}) by ${creds.jenkins.user}`);
+            msg += `\n📢 Posted to ${args.notifyChannel}`;
+          } catch (err) {
+            msg += `\n⚠️ Channel notify failed: ${err.message}`;
+          }
         }
 
-        // Remind to connect Slack if not logged in
         if (!creds.slack) {
-          msg += `\n\n💡 Tip: Connect Slack with login_slack to get build notifications in your channels.`;
+          msg += `\n\n💡 Set up **setup_slack** to get DM notifications on every build.`;
         }
 
         return text(msg);
       }
 
+      case 'refresh_jobs': {
+        const creds = getCredentials();
+        if (!creds.jenkins) return text('❌ Not logged into Jenkins. Use **login_jenkins** first.');
+
+        const allJobs = await fetchAllJobs(creds.jenkins.baseUrl, creds.jenkins.user, creds.jenkins.apiToken);
+        const buildableJobs = {};
+        for (const j of allJobs) {
+          if (j._class === 'com.cloudbees.hudson.plugins.folder.Folder') continue;
+          buildableJobs[j.name] = { path: `/job/${encodeURIComponent(j.name)}`, name: j.name, color: j.color || 'unknown' };
+        }
+        saveJobs(buildableJobs);
+        return text(`✅ Refreshed! ${Object.keys(buildableJobs).length} jobs discovered.`);
+      }
+
       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}`);
+          parts.push(`**Jenkins:** ${userInfo.fullName} (${userInfo.id}) @ ${creds.jenkins.baseUrl}`);
         } else {
-          parts.push('Jenkins: not logged in');
+          parts.push('**Jenkins:** not logged in');
         }
-        if (creds.slack?.botToken) {
-          const slackInfo = await getSlackUserInfo(creds.slack.botToken);
-          parts.push(`Slack: ${slackInfo.user} @ ${slackInfo.team}`);
+        if (creds.slack) {
+          parts.push(`**Slack:** User ID ${creds.slack.userId} (DM enabled)`);
         } else {
-          parts.push('Slack: not logged in');
+          parts.push('**Slack:** not configured');
         }
         return text(parts.join('\n'));
       }
 
       case 'logout': {
         clearAll();
-        return text('✅ All credentials cleared.');
+        return text('✅ All credentials and jobs cleared.');
       }
 
       default:

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "jenkins-slack-mcp",
-  "version": "1.0.3",
-  "description": "MCP server to trigger Jenkins builds from any IDE with Slack notifications. Auto-configures via interactive login.",
+  "version": "2.0.0",
+  "description": "MCP server to trigger Jenkins builds from any IDE. Auto-discovers jobs, browser login, Slack DM notifications.",
   "main": "mcp-server.js",
   "bin": {
     "jenkins-slack-mcp": "mcp-server.js"
   },
   "scripts": {
-    "start": "node mcp-server.js",
-    "server": "node server.js"
+    "start": "node mcp-server.js"
   },
   "keywords": [
     "mcp",

package/server.js

@@ -1,39 +0,0 @@
-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}`));