npm - @jtalk22/slack-mcp - Versions diffs - 1.0.4 → 1.1.0 - Mend

@jtalk22/slack-mcp 1.0.4 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/public/index.html CHANGED Viewed

@@ -127,16 +127,73 @@
       cursor: pointer;
     }
     .tabs button.active { background: #4ecdc4; color: #1a1a2e; }
+    /* Auth Modal */
+    .modal-overlay {
+      position: fixed;
+      top: 0; left: 0; right: 0; bottom: 0;
+      background: rgba(0,0,0,0.85);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 1000;
+    }
+    .modal-overlay.hidden { display: none; }
+    .modal {
+      background: #16213e;
+      padding: 40px;
+      border-radius: 12px;
+      max-width: 450px;
+      text-align: center;
+      border: 2px solid #4ecdc4;
+    }
+    .modal h2 { color: #4ecdc4; margin-bottom: 20px; }
+    .modal p { color: #aaa; margin-bottom: 25px; line-height: 1.6; }
+    .modal code {
+      background: #0f3460;
+      padding: 3px 8px;
+      border-radius: 4px;
+      color: #4ecdc4;
+    }
+    .modal input {
+      width: 100%;
+      padding: 14px;
+      border: 2px solid #0f3460;
+      border-radius: 6px;
+      background: #0f3460;
+      color: #fff;
+      font-size: 14px;
+      margin-bottom: 15px;
+    }
+    .modal input:focus { border-color: #4ecdc4; outline: none; }
+    .modal button {
+      width: 100%;
+      padding: 14px;
+      background: #4ecdc4;
+      color: #1a1a2e;
+      border: none;
+      border-radius: 6px;
+      cursor: pointer;
+      font-weight: bold;
+      font-size: 16px;
+    }
+    .modal button:hover { background: #45b7aa; }
+    .modal .error { color: #ff6b6b; margin-top: 10px; font-size: 14px; }
   </style>
 </head>
 <body>
-  <div class="container">
-    <h1>Slack Web API</h1>
-    <div class="auth-section">
-      <input type="text" id="apiKey" placeholder="API Key (default: slack-mcp-local)">
-      <button onclick="connect()">Connect</button>
-      <span id="status" class="status"></span>
+  <!-- Auth Modal -->
+  <div id="authModal" class="modal-overlay">
+    <div class="modal">
+      <h2>Enter API Key</h2>
+      <p>Copy the API key from the console where you ran<br><code>npm run web</code></p>
+      <input type="text" id="modalApiKey" placeholder="smcp_xxxxxxxxxxxx" autofocus>
+      <button onclick="submitApiKey()">Connect</button>
+      <div id="modalError" class="error"></div>
     </div>
+  </div>
+  <div class="container">
+    <h1>Slack Web API <span id="status" class="status"></span></h1>
     <div class="grid">
       <div class="sidebar">
         <h3>CONVERSATIONS</h3>
@@ -165,33 +222,88 @@
     </div>
   </div>
   <script>
-    // Default API key matches server default - auto-connects on first visit
-    const DEFAULT_KEY = 'slack-mcp-local';
-    let apiKey = localStorage.getItem('slackApiKey') || DEFAULT_KEY;
+    let apiKey = null;
     let currentChannel = null;
-    document.getElementById('apiKey').value = apiKey;
-    setTimeout(connect, 100);
+    // Initialize: check URL param, then localStorage
+    (function init() {
+      const params = new URLSearchParams(window.location.search);
+      const keyFromUrl = params.get('key');
+      if (keyFromUrl) {
+        // Save key from magic link and strip from URL
+        apiKey = keyFromUrl;
+        localStorage.setItem('slackApiKey', apiKey);
+        history.replaceState({}, '', window.location.pathname);
+      } else {
+        apiKey = localStorage.getItem('slackApiKey');
+      }
+      if (apiKey) {
+        hideModal();
+        connect();
+      } else {
+        showModal();
+      }
+    })();
+    function showModal(errorMsg) {
+      document.getElementById('authModal').classList.remove('hidden');
+      document.getElementById('modalError').textContent = errorMsg || '';
+      document.getElementById('modalApiKey').focus();
+    }
+    function hideModal() {
+      document.getElementById('authModal').classList.add('hidden');
+    }
+    function submitApiKey() {
+      const input = document.getElementById('modalApiKey').value.trim();
+      if (!input) {
+        document.getElementById('modalError').textContent = 'Please enter an API key';
+        return;
+      }
+      apiKey = input;
+      localStorage.setItem('slackApiKey', apiKey);
+      hideModal();
+      connect();
+    }
+    // Handle Enter key in modal
+    document.getElementById('modalApiKey').addEventListener('keypress', (e) => {
+      if (e.key === 'Enter') submitApiKey();
+    });
     async function api(endpoint, options = {}) {
       const res = await fetch(endpoint, {
         ...options,
         headers: { 'Authorization': 'Bearer ' + apiKey, 'Content-Type': 'application/json', ...options.headers }
       });
+      if (res.status === 401 || res.status === 403) {
+        // Auth failed - clear stored key and show modal
+        localStorage.removeItem('slackApiKey');
+        apiKey = null;
+        showModal('Invalid or expired API key. Check console for current key.');
+        throw new Error('Authentication failed');
+      }
       if (!res.ok) { const err = await res.json(); throw new Error(err.error || 'API error'); }
       return res.json();
     }
     async function connect() {
-      apiKey = document.getElementById('apiKey').value.trim() || DEFAULT_KEY;
-      localStorage.setItem('slackApiKey', apiKey);
       const status = document.getElementById('status');
+      status.textContent = 'Connecting...';
+      status.className = 'status';
       try {
         const health = await api('/health');
-        status.textContent = 'Connected as ' + health.user + ' @ ' + health.team;
+        status.textContent = '● ' + health.user + ' @ ' + health.team;
         status.className = 'status ok';
         loadConversations('im,mpim');
       } catch (e) {
-        status.textContent = 'Error: ' + e.message;
-        status.className = 'status error';
+        if (e.message !== 'Authentication failed') {
+          status.textContent = 'Error: ' + e.message;
+          status.className = 'status error';
+        }
       }
     }
     async function loadConversations(types) {

package/scripts/verify-v106.js ADDED Viewed

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * v1.0.6 Verification Script
+ *
+ * Tests:
+ * 1. Atomic write - no .tmp artifacts remain after write
+ * 2. Server exits cleanly (unref timer doesn't cause zombie)
+ */
+import { writeFileSync, readFileSync, existsSync, renameSync, unlinkSync, readdirSync } from "fs";
+import { spawn } from "child_process";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEST_DIR = join(homedir(), ".slack-mcp-test");
+const TEST_FILE = join(TEST_DIR, "test-atomic.json");
+// ============ Test 1: Atomic Write ============
+function atomicWriteSync(filePath, content) {
+  const tempPath = `${filePath}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tempPath, content);
+    renameSync(tempPath, filePath);
+  } catch (e) {
+    try { unlinkSync(tempPath); } catch {}
+    throw e;
+  }
+}
+async function testAtomicWrite() {
+  console.log("\n[TEST 1] Atomic Write");
+  console.log("─".repeat(40));
+  // Setup - ensure test directory exists
+  const { execSync } = await import("child_process");
+  try {
+    execSync(`mkdir -p "${TEST_DIR}"`);
+  } catch {}
+  // Test successful write
+  const testData = { test: "data", timestamp: Date.now() };
+  atomicWriteSync(TEST_FILE, JSON.stringify(testData, null, 2));
+  // Verify file exists
+  if (!existsSync(TEST_FILE)) {
+    console.log("  FAIL: File was not created");
+    return false;
+  }
+  // Verify content
+  const readBack = JSON.parse(readFileSync(TEST_FILE, "utf-8"));
+  if (readBack.test !== "data") {
+    console.log("  FAIL: Content mismatch");
+    return false;
+  }
+  // Check for .tmp artifacts in test dir
+  const files = readdirSync(TEST_DIR);
+  const tmpFiles = files.filter(f => f.endsWith(".tmp"));
+  if (tmpFiles.length > 0) {
+    console.log(`  FAIL: Found .tmp artifacts: ${tmpFiles.join(", ")}`);
+    return false;
+  }
+  // Cleanup
+  try { unlinkSync(TEST_FILE); } catch {}
+  console.log("  PASS: Atomic write completed, no .tmp artifacts");
+  return true;
+}
+// ============ Test 2: Server Exit (No Zombie) ============
+async function testServerExit() {
+  console.log("\n[TEST 2] Server Clean Exit (No Zombie)");
+  console.log("─".repeat(40));
+  const serverPath = join(__dirname, "../src/server.js");
+  return new Promise((resolve) => {
+    const timeout = 5000; // 5 second timeout
+    let exitCode = null;
+    let timedOut = false;
+    // Spawn server process
+    const proc = spawn("node", [serverPath], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, SLACK_TOKEN: "test", SLACK_COOKIE: "test" }
+    });
+    // Set timeout - if process doesn't exit after stdin closes, it's a zombie
+    const timer = setTimeout(() => {
+      timedOut = true;
+      console.log("  FAIL: Server did not exit within 5s (zombie process detected)");
+      proc.kill("SIGKILL");
+      resolve(false);
+    }, timeout);
+    proc.on("exit", (code) => {
+      exitCode = code;
+      clearTimeout(timer);
+      if (!timedOut) {
+        console.log(`  PASS: Server exited cleanly (code: ${code})`);
+        resolve(true);
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      console.log(`  INFO: Server spawn error (expected if no SDK): ${err.message}`);
+      // This is OK - we're testing exit behavior, not full functionality
+      resolve(true);
+    });
+    // Close stdin immediately to simulate MCP client disconnect
+    proc.stdin.end();
+    // Give it a moment then send SIGTERM
+    setTimeout(() => {
+      if (exitCode === null && !timedOut) {
+        proc.kill("SIGTERM");
+      }
+    }, 1000);
+  });
+}
+// ============ Main ============
+async function main() {
+  console.log("╔════════════════════════════════════════╗");
+  console.log("║  v1.0.6 Verification Tests             ║");
+  console.log("╚════════════════════════════════════════╝");
+  const results = [];
+  results.push(await testAtomicWrite());
+  results.push(await testServerExit());
+  console.log("\n" + "═".repeat(40));
+  const passed = results.filter(r => r).length;
+  const total = results.length;
+  if (passed === total) {
+    console.log(`\n✓ ALL TESTS PASSED (${passed}/${total})`);
+    console.log("\nReady to deploy v1.0.6");
+    process.exit(0);
+  } else {
+    console.log(`\n✗ TESTS FAILED (${passed}/${total})`);
+    process.exit(1);
+  }
+}
+main().catch(e => {
+  console.error("Test error:", e);
+  process.exit(1);
+});

package/scripts/verify-web.js ADDED Viewed

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * Web UI Verification Script
+ *
+ * Tests:
+ * 1. Server starts and prints Magic Link
+ * 2. /demo.html contains "STATIC PREVIEW" banner
+ * 3. /?key=... serves the dashboard (index.html)
+ * 4. Server shuts down cleanly
+ */
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SERVER_PATH = join(__dirname, "../src/web-server.js");
+const PORT = 3456; // Use non-standard port to avoid conflicts
+const TIMEOUT = 15000;
+let serverProc = null;
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+function cleanup() {
+  if (serverProc) {
+    serverProc.kill("SIGTERM");
+    serverProc = null;
+  }
+}
+process.on("exit", cleanup);
+process.on("SIGINT", () => { cleanup(); process.exit(1); });
+process.on("SIGTERM", () => { cleanup(); process.exit(1); });
+async function startServer() {
+  return new Promise((resolve, reject) => {
+    let magicLink = null;
+    let apiKey = null;
+    let output = "";
+    serverProc = spawn("node", [SERVER_PATH], {
+      env: { ...process.env, PORT: String(PORT) },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timeout = setTimeout(() => {
+      reject(new Error("Server startup timeout - no magic link detected"));
+    }, TIMEOUT);
+    serverProc.stderr.on("data", (data) => {
+      const text = data.toString();
+      output += text;
+      // Look for magic link pattern
+      const match = text.match(/Dashboard:\s*(http:\/\/[^\s]+)/);
+      if (match) {
+        magicLink = match[1];
+        // Extract key from URL
+        const keyMatch = magicLink.match(/[?&]key=([^&\s]+)/);
+        if (keyMatch) {
+          apiKey = keyMatch[1];
+        }
+      }
+      // Server is ready when we see the full banner
+      if (output.includes("Dashboard:") && output.includes("API Key:")) {
+        clearTimeout(timeout);
+        resolve({ magicLink, apiKey });
+      }
+    });
+    serverProc.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+    serverProc.on("exit", (code) => {
+      if (code !== null && code !== 0) {
+        clearTimeout(timeout);
+        reject(new Error(`Server exited with code ${code}`));
+      }
+    });
+  });
+}
+async function testDemoPage() {
+  const url = `http://localhost:${PORT}/demo.html`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch demo.html: ${res.status}`);
+  }
+  const html = await res.text();
+  if (!html.includes("STATIC PREVIEW")) {
+    throw new Error("demo.html missing 'STATIC PREVIEW' banner");
+  }
+  if (!html.includes("Who is Alex?")) {
+    throw new Error("demo.html missing anonymized 'Who is Alex?' scenario");
+  }
+  return true;
+}
+async function testDashboard(apiKey) {
+  const url = `http://localhost:${PORT}/?key=${apiKey}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch dashboard: ${res.status}`);
+  }
+  const html = await res.text();
+  // Should serve index.html (the dashboard)
+  if (!html.includes("Slack Web API")) {
+    throw new Error("Dashboard page missing 'Slack Web API' title");
+  }
+  if (!html.includes("authModal")) {
+    throw new Error("Dashboard missing auth modal");
+  }
+  return true;
+}
+async function testApiWithKey(apiKey) {
+  // Test that API rejects bad key
+  const badRes = await fetch(`http://localhost:${PORT}/health`, {
+    headers: { "Authorization": "Bearer bad-key" }
+  });
+  if (badRes.status !== 401) {
+    throw new Error(`Expected 401 for bad key, got ${badRes.status}`);
+  }
+  return true;
+}
+async function main() {
+  console.log("╔════════════════════════════════════════╗");
+  console.log("║  Web UI Verification Tests             ║");
+  console.log("╚════════════════════════════════════════╝");
+  const results = [];
+  try {
+    // Test 1: Server starts with magic link
+    console.log("\n[TEST 1] Server Startup & Magic Link");
+    console.log("─".repeat(40));
+    const { magicLink, apiKey } = await startServer();
+    if (!magicLink) {
+      throw new Error("No magic link found");
+    }
+    if (!apiKey) {
+      throw new Error("No API key found in magic link");
+    }
+    log(`Magic Link: ${magicLink}`);
+    log(`API Key: ${apiKey.substring(0, 20)}...`);
+    log("PASS: Server started with magic link");
+    results.push(true);
+    // Test 2: Demo page
+    console.log("\n[TEST 2] Demo Page (/demo.html)");
+    console.log("─".repeat(40));
+    await testDemoPage();
+    log("PASS: Demo page serves correctly with STATIC PREVIEW banner");
+    results.push(true);
+    // Test 3: Dashboard
+    console.log("\n[TEST 3] Dashboard (/?key=...)");
+    console.log("─".repeat(40));
+    await testDashboard(apiKey);
+    log("PASS: Dashboard serves with auth modal");
+    results.push(true);
+    // Test 4: API auth
+    console.log("\n[TEST 4] API Authentication");
+    console.log("─".repeat(40));
+    await testApiWithKey(apiKey);
+    log("PASS: API correctly rejects bad keys");
+    results.push(true);
+  } catch (err) {
+    console.log(`  FAIL: ${err.message}`);
+    results.push(false);
+  } finally {
+    cleanup();
+  }
+  // Summary
+  console.log("\n" + "═".repeat(40));
+  const passed = results.filter(r => r).length;
+  const total = results.length;
+  if (passed === total) {
+    console.log(`\n✓ ALL TESTS PASSED (${passed}/${total})`);
+    console.log("\nReady to bump version to 1.1.0");
+    process.exit(0);
+  } else {
+    console.log(`\n✗ TESTS FAILED (${passed}/${total})`);
+    process.exit(1);
+  }
+}
+main().catch(e => {
+  console.error("Test error:", e);
+  cleanup();
+  process.exit(1);
+});

package/src/server.js CHANGED Viewed

@@ -5,7 +5,13 @@
  * A Model Context Protocol server for Slack integration.
  * Provides read/write access to Slack messages, channels, and users.
  *
- * @version 1.0.0
+ * Features:
+ * - Automatic token refresh from Chrome
+ * - LRU user cache with TTL
+ * - Network error retry with exponential backoff
+ * - Background token health monitoring
+ *
+ * @version 1.1.0
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -16,8 +22,10 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { loadTokens } from "../lib/token-store.js";
+import { checkTokenHealth } from "../lib/slack-client.js";
 import { TOOLS } from "../lib/tools.js";
 import {
+  handleTokenStatus,
   handleHealthCheck,
   handleRefreshTokens,
   handleListConversations,
@@ -30,9 +38,12 @@ import {
   handleListUsers,
 } from "../lib/handlers.js";
+// Background refresh interval (4 hours)
+const BACKGROUND_REFRESH_INTERVAL = 4 * 60 * 60 * 1000;
 // Package info
 const SERVER_NAME = "slack-mcp-server";
-const SERVER_VERSION = "1.0.0";
+const SERVER_VERSION = "1.1.0";
 // Initialize server
 const server = new Server(
@@ -51,6 +62,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     switch (name) {
+      case "slack_token_status":
+        return await handleTokenStatus();
       case "slack_health_check":
         return await handleHealthCheck();
@@ -104,8 +118,27 @@ async function main() {
     console.error("Will attempt Chrome auto-extraction on first API call");
   } else {
     console.error(`Credentials loaded from: ${credentials.source}`);
+    // Check token health on startup
+    const health = await checkTokenHealth({ error: () => {} });
+    if (health.warning) {
+      console.error(`Token age: ${health.age_hours}h - ${health.message}`);
+    }
   }
+  // Background token health check (every 4 hours)
+  // Use unref() so this timer doesn't prevent the process from exiting
+  // when the MCP transport closes (prevents zombie processes)
+  const backgroundTimer = setInterval(async () => {
+    const health = await checkTokenHealth(console);
+    if (health.refreshed) {
+      console.error("Background: tokens refreshed successfully");
+    } else if (health.critical) {
+      console.error("Background: tokens critical - open Slack in Chrome");
+    }
+  }, BACKGROUND_REFRESH_INTERVAL);
+  backgroundTimer.unref();
   // Start server
   const transport = new StdioServerTransport();
   await server.connect(transport);