@jtalk22/slack-mcp 1.0.4 → 1.0.6

package/lib/tools.js

@@ -5,6 +5,14 @@
  */
 
 export const TOOLS = [
+  {
+    name: "slack_token_status",
+    description: "Check token health, age, auto-refresh status, and cache stats",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
   {
     name: "slack_health_check",
     description: "Check if Slack tokens are valid and show authentication status",
@@ -23,7 +31,7 @@ export const TOOLS = [
   },
   {
     name: "slack_list_conversations",
-    description: "List all DMs and channels with user names resolved",
+    description: "List all DMs and channels with user names resolved. Uses cached DMs by default for speed.",
     inputSchema: {
       type: "object",
       properties: {
@@ -35,6 +43,10 @@ export const TOOLS = [
         limit: {
           type: "number",
           description: "Maximum results (default 100)"
+        },
+        discover_dms: {
+          type: "boolean",
+          description: "If true, actively discover all DMs (slower, may hit rate limits on large workspaces). Default false uses cached DMs."
         }
       }
     }
@@ -183,7 +195,7 @@ export const TOOLS = [
       properties: {
         limit: {
           type: "number",
-          description: "Maximum users to return (default 100)"
+          description: "Maximum users to return (default 500, supports pagination)"
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jtalk22/slack-mcp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "MCP server for Slack - Full access to DMs, channels, and messages from Claude. Browser token auth, no OAuth required.",
   "type": "module",
   "main": "src/server.js",

package/scripts/verify-v106.js

@@ -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/src/server.js

@@ -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.0.6
  */
 
 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.0.6";
 
 // 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);

package/src/web-server.js

@@ -5,16 +5,21 @@
  * Exposes Slack MCP tools as REST endpoints for browser access.
  * Run alongside or instead of the MCP server for web-based access.
  *
- * @version 1.0.0
+ * @version 1.0.5
  */
 
 import express from "express";
+import { randomBytes } from "crypto";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
+import { homedir } from "os";
 import { loadTokens } from "../lib/token-store.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 import {
+  handleTokenStatus,
   handleHealthCheck,
   handleRefreshTokens,
   handleListConversations,
@@ -30,9 +35,33 @@ import {
 const app = express();
 const PORT = process.env.PORT || 3000;
 
-// Default API key for convenience - override with SLACK_API_KEY env var for production
-const DEFAULT_API_KEY = "slack-mcp-local";
-const API_KEY = process.env.SLACK_API_KEY || DEFAULT_API_KEY;
+// Secure API key management
+const API_KEY_FILE = join(homedir(), ".slack-mcp-api-key");
+
+function getOrCreateAPIKey() {
+  // Priority 1: Environment variable
+  if (process.env.SLACK_API_KEY) {
+    return process.env.SLACK_API_KEY;
+  }
+
+  // Priority 2: Key file
+  if (existsSync(API_KEY_FILE)) {
+    try {
+      return readFileSync(API_KEY_FILE, "utf-8").trim();
+    } catch {}
+  }
+
+  // Priority 3: Generate new secure key
+  const newKey = `smcp_${randomBytes(24).toString('base64url')}`;
+  try {
+    writeFileSync(API_KEY_FILE, newKey);
+    execSync(`chmod 600 "${API_KEY_FILE}"`);
+  } catch {}
+
+  return newKey;
+}
+
+const API_KEY = getOrCreateAPIKey();
 
 // Middleware
 app.use(express.json());
@@ -94,6 +123,16 @@ app.get("/", (req, res) => {
   });
 });
 
+// Token status (detailed health + cache info)
+app.get("/token-status", authenticate, async (req, res) => {
+  try {
+    const result = await handleTokenStatus();
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
 // Health check
 app.get("/health", authenticate, async (req, res) => {
   try {