@jtalk22/slack-mcp 1.2.2 → 1.2.4

package/scripts/setup-wizard.js

@@ -12,11 +12,19 @@
 
 import { platform } from "os";
 import * as readline from "readline";
-import { loadTokens, saveTokens, extractFromChrome, isAutoRefreshAvailable, TOKEN_FILE } from "../lib/token-store.js";
-import { slackAPI } from "../lib/slack-client.js";
+import {
+  saveTokens,
+  extractFromChrome,
+  getLastExtractionError,
+  isAutoRefreshAvailable,
+  TOKEN_FILE,
+  getFromFile,
+  getFromKeychain,
+} from "../lib/token-store.js";
 
 const IS_MACOS = platform() === 'darwin';
-const VERSION = "1.2.2";
+const VERSION = "1.2.4";
+const MIN_NODE_MAJOR = 20;
 
 // ANSI colors
 const colors = {
@@ -69,27 +77,25 @@ async function pressEnterToContinue(rl) {
 }
 
 async function validateTokens(token, cookie) {
-  const hadOldToken = Object.prototype.hasOwnProperty.call(process.env, "SLACK_TOKEN");
-  const hadOldCookie = Object.prototype.hasOwnProperty.call(process.env, "SLACK_COOKIE");
-  const oldToken = process.env.SLACK_TOKEN;
-  const oldCookie = process.env.SLACK_COOKIE;
-
-  // Temporarily set env vars for validation
-  process.env.SLACK_TOKEN = token;
-  process.env.SLACK_COOKIE = cookie;
-
   try {
-    const result = await slackAPI("auth.test", {});
-    return { valid: true, user: result.user, team: result.team };
+    const response = await fetch("https://slack.com/api/auth.test", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Cookie": `d=${cookie}`,
+        "Content-Type": "application/json; charset=utf-8",
+      },
+      body: JSON.stringify({}),
+    });
+
+    const result = await response.json();
+    if (!result.ok) {
+      return { valid: false, error: result.error || "auth.test_failed" };
+    }
+
+    return { valid: true, user: result.user, team: result.team, userId: result.user_id };
   } catch (e) {
     return { valid: false, error: e.message };
-  } finally {
-    // Always restore prior process env state
-    if (hadOldToken) process.env.SLACK_TOKEN = oldToken;
-    else delete process.env.SLACK_TOKEN;
-
-    if (hadOldCookie) process.env.SLACK_COOKIE = oldCookie;
-    else delete process.env.SLACK_COOKIE;
   }
 }
 
@@ -112,13 +118,27 @@ async function runMacOSSetup(rl) {
   const tokens = extractFromChrome();
 
   if (!tokens) {
+    const extractionError = getLastExtractionError();
     print();
     error("Could not extract tokens from Chrome.");
+    if (extractionError) {
+      print(`Reason: ${extractionError.message}`);
+      if (extractionError.detail) {
+        print(`Detail: ${extractionError.detail}`);
+      }
+    }
     print();
-    print("Make sure:");
-    print("  1. Chrome is running");
-    print("  2. You have a Slack tab open (app.slack.com)");
-    print("  3. You're logged into that workspace");
+    if (extractionError?.code === "apple_events_javascript_disabled") {
+      print("Fix and retry:");
+      print("  1. In Chrome menu: View > Developer > Allow JavaScript from Apple Events");
+      print("  2. Keep Slack open in a Chrome tab (app.slack.com)");
+      print("  3. Re-run: npx -y @jtalk22/slack-mcp --setup");
+    } else {
+      print("Make sure:");
+      print("  1. Chrome is running");
+      print("  2. You have a Slack tab open (app.slack.com)");
+      print("  3. You're logged into that workspace");
+    }
     print();
 
     const retry = await question(rl, "Try manual entry instead? (y/n): ");
@@ -227,7 +247,7 @@ async function runManualSetup(rl) {
 }
 
 async function showStatus() {
-  const creds = loadTokens();
+  const creds = getDoctorCredentials();
 
   if (!creds) {
     error("No tokens found");
@@ -237,29 +257,126 @@ async function showStatus() {
   }
 
   print(`Token source: ${creds.source}`);
-  print(`Token file: ${TOKEN_FILE}`);
+  if (creds.path) {
+    print(`Token file: ${creds.path}`);
+  }
   if (creds.updatedAt) {
     print(`Last updated: ${creds.updatedAt}`);
   }
   print();
 
-  try {
-    // Need to set env vars for slackAPI to work
-    process.env.SLACK_TOKEN = creds.token;
-    process.env.SLACK_COOKIE = creds.cookie;
-
-    const result = await slackAPI("auth.test", {});
-    success("Status: VALID");
-    print(`User: ${result.user}`);
-    print(`Team: ${result.team}`);
-    print(`User ID: ${result.user_id}`);
-  } catch (e) {
+  const result = await validateTokens(creds.token, creds.cookie);
+  if (!result.valid) {
     error("Status: INVALID");
-    print(`Error: ${e.message}`);
+    print(`Error: ${result.error}`);
     print();
     print("Run setup wizard to refresh: npx -y @jtalk22/slack-mcp --setup");
     process.exit(1);
   }
+
+  success("Status: VALID");
+  print(`User: ${result.user}`);
+  print(`Team: ${result.team}`);
+  print(`User ID: ${result.userId}`);
+}
+
+function getDoctorCredentials() {
+  if (process.env.SLACK_TOKEN && process.env.SLACK_COOKIE) {
+    return { token: process.env.SLACK_TOKEN, cookie: process.env.SLACK_COOKIE, source: "environment" };
+  }
+
+  const fileTokens = getFromFile();
+  if (fileTokens?.token && fileTokens?.cookie) {
+    return {
+      token: fileTokens.token,
+      cookie: fileTokens.cookie,
+      source: "file",
+      path: TOKEN_FILE,
+      updatedAt: fileTokens.updatedAt,
+    };
+  }
+
+  if (IS_MACOS) {
+    const keychainToken = getFromKeychain("token");
+    const keychainCookie = getFromKeychain("cookie");
+    if (keychainToken && keychainCookie) {
+      return { token: keychainToken, cookie: keychainCookie, source: "keychain" };
+    }
+  }
+
+  return null;
+}
+
+function classifyAuthError(rawError) {
+  const msg = String(rawError || "").toLowerCase();
+  if (
+    msg.includes("invalid_auth") ||
+    msg.includes("token_expired") ||
+    msg.includes("not_authed") ||
+    msg.includes("account_inactive")
+  ) {
+    return 2;
+  }
+  return 3;
+}
+
+function parseNodeMajor() {
+  return Number.parseInt(process.versions.node.split(".")[0], 10);
+}
+
+async function runDoctor() {
+  print(`${colors.bold}slack-mcp-server doctor${colors.reset}`);
+  print();
+
+  const nodeMajor = parseNodeMajor();
+  if (Number.isNaN(nodeMajor) || nodeMajor < MIN_NODE_MAJOR) {
+    error(`Node.js ${process.versions.node} detected (requires Node ${MIN_NODE_MAJOR}+)`);
+    print();
+    print("Next action:");
+    print(`  npx -y @jtalk22/slack-mcp --doctor  # rerun after upgrading Node ${MIN_NODE_MAJOR}+`);
+    process.exit(3);
+  }
+  success(`Node.js ${process.versions.node} (supported)`);
+
+  const creds = getDoctorCredentials();
+  if (!creds) {
+    error("Credentials: not found");
+    print();
+    print("Next action:");
+    print("  npx -y @jtalk22/slack-mcp --setup");
+    process.exit(1);
+  }
+
+  success(`Credentials loaded from: ${creds.source}`);
+  if (creds.path) {
+    print(`Path: ${creds.path}`);
+  }
+  if (creds.updatedAt) {
+    print(`Last updated: ${creds.updatedAt}`);
+  }
+
+  print();
+  print("Validating Slack auth...");
+  const validation = await validateTokens(creds.token, creds.cookie);
+  if (!validation.valid) {
+    const exitCode = classifyAuthError(validation.error);
+    error(`Slack auth failed: ${validation.error}`);
+    print();
+    print("Next action:");
+    if (exitCode === 2) {
+      print("  npx -y @jtalk22/slack-mcp --setup");
+    } else {
+      print("  Check network connectivity and retry:");
+      print("  npx -y @jtalk22/slack-mcp --doctor");
+    }
+    process.exit(exitCode);
+  }
+
+  success(`Slack auth valid for ${validation.user} @ ${validation.team}`);
+  print();
+  print("Ready. Next command:");
+  print("  npx -y @jtalk22/slack-mcp");
+  process.exit(0);
 }
 
 async function showHelp() {
@@ -271,6 +388,7 @@ async function showHelp() {
   print("  npx -y @jtalk22/slack-mcp             Start MCP server (stdio)");
   print("  npx -y @jtalk22/slack-mcp --setup     Interactive token setup wizard");
   print("  npx -y @jtalk22/slack-mcp --status    Check token health");
+  print("  npx -y @jtalk22/slack-mcp --doctor    Run runtime and auth diagnostics");
   print("  npx -y @jtalk22/slack-mcp --version   Print version");
   print("  npx -y @jtalk22/slack-mcp --help      Show this help");
   print();
@@ -296,6 +414,10 @@ async function main() {
     case 'status':
       await showStatus();
       return;
+    case '--doctor':
+    case 'doctor':
+      await runDoctor();
+      return;
     case '--version':
     case '-v':
       print(`slack-mcp-server v${VERSION}`);

package/scripts/token-cli.js

@@ -3,7 +3,7 @@
  * Token CLI - Manage Slack tokens
  */
 
-import { loadTokens, saveTokens, extractFromChrome, getFromFile, TOKEN_FILE, KEYCHAIN_SERVICE } from "../lib/token-store.js";
+import { loadTokensReadOnly, saveTokens, extractFromChrome, getFromFile, TOKEN_FILE, KEYCHAIN_SERVICE } from "../lib/token-store.js";
 import { slackAPI } from "../lib/slack-client.js";
 import * as readline from "readline";
 
@@ -35,7 +35,7 @@ async function main() {
 }
 
 async function showStatus() {
-  const creds = loadTokens();
+  const creds = loadTokensReadOnly();
   if (!creds) {
     console.log("No tokens found");
     console.log("");
@@ -46,11 +46,13 @@ async function showStatus() {
   }
 
   console.log("Token source:", creds.source);
-  console.log("Token file:", TOKEN_FILE);
+  if (creds.source === "file") {
+    console.log("Token file:", TOKEN_FILE);
+  }
   console.log("");
 
   try {
-    const result = await slackAPI("auth.test", {});
+    const result = await slackAPI("auth.test", {}, { retryOnAuthFail: false });
     console.log("Status: VALID");
     console.log("User:", result.user);
     console.log("Team:", result.team);

package/scripts/verify-install-flow.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG = "@jtalk22/slack-mcp";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+function runNpx(args, options = {}) {
+  const cmdArgs = ["-y", PKG, ...args];
+  const result = spawnSync("npx", cmdArgs, {
+    cwd: options.cwd,
+    env: options.env,
+    encoding: "utf8",
+    timeout: 120000,
+  });
+
+  return {
+    args: cmdArgs.join(" "),
+    status: result.status,
+    stdout: (result.stdout || "").trim(),
+    stderr: (result.stderr || "").trim(),
+    error: result.error,
+  };
+}
+
+function assert(condition, message, details = "") {
+  if (!condition) {
+    const suffix = details ? `\n${details}` : "";
+    throw new Error(`${message}${suffix}`);
+  }
+}
+
+function printResult(label, result) {
+  console.log(`\n[${label}] npx ${result.args}`);
+  console.log(`exit=${result.status}`);
+  if (result.stdout) {
+    console.log("stdout:");
+    console.log(result.stdout);
+  }
+  if (result.stderr) {
+    console.log("stderr:");
+    console.log(result.stderr);
+  }
+}
+
+function runLocalSetupStatus(options = {}) {
+  const result = spawnSync("node", [join(repoRoot, "scripts/setup-wizard.js"), "--status"], {
+    cwd: repoRoot,
+    env: options.env,
+    encoding: "utf8",
+    timeout: 120000,
+  });
+
+  return {
+    args: "node scripts/setup-wizard.js --status",
+    status: result.status,
+    stdout: (result.stdout || "").trim(),
+    stderr: (result.stderr || "").trim(),
+    error: result.error,
+  };
+}
+
+function runLocalDoctor(options = {}) {
+  const result = spawnSync("node", [join(repoRoot, "scripts/setup-wizard.js"), "--doctor"], {
+    cwd: repoRoot,
+    env: options.env,
+    encoding: "utf8",
+    timeout: 120000,
+  });
+
+  return {
+    args: "node scripts/setup-wizard.js --doctor",
+    status: result.status,
+    stdout: (result.stdout || "").trim(),
+    stderr: (result.stderr || "").trim(),
+    error: result.error,
+  };
+}
+
+function main() {
+  const testHome = mkdtempSync(join(tmpdir(), "slack-mcp-install-check-"));
+
+  // Force a clean environment so --status reflects missing credentials.
+  const env = { ...process.env, HOME: testHome, USERPROFILE: testHome };
+  delete env.SLACK_TOKEN;
+  delete env.SLACK_COOKIE;
+
+  try {
+    const versionResult = runNpx(["--version"], { cwd: testHome, env });
+    printResult("version", versionResult);
+    assert(
+      versionResult.status === 0,
+      "Expected --version to exit 0",
+      versionResult.stderr || versionResult.stdout,
+    );
+
+    const helpResult = runNpx(["--help"], { cwd: testHome, env });
+    printResult("help", helpResult);
+    assert(
+      helpResult.status === 0,
+      "Expected --help to exit 0",
+      helpResult.stderr || helpResult.stdout,
+    );
+
+    const statusResult = runNpx(["--status"], { cwd: testHome, env });
+    printResult("status", statusResult);
+    assert(
+      statusResult.status !== 0,
+      "Expected --status to exit non-zero when credentials are missing",
+      statusResult.stderr || statusResult.stdout,
+    );
+
+    const localStatusResult = runLocalSetupStatus({ env });
+    printResult("local-status", localStatusResult);
+    assert(
+      localStatusResult.status !== 0,
+      "Expected local --status to exit non-zero when credentials are missing",
+      localStatusResult.stderr || localStatusResult.stdout,
+    );
+    assert(
+      !localStatusResult.stderr.includes("Attempting Chrome auto-extraction"),
+      "Expected local --status to be read-only without auto-extraction side effects",
+      localStatusResult.stderr,
+    );
+
+    const localDoctorMissingResult = runLocalDoctor({ env });
+    printResult("local-doctor-missing", localDoctorMissingResult);
+    assert(
+      localDoctorMissingResult.status === 1,
+      "Expected local --doctor to exit 1 when credentials are missing",
+      localDoctorMissingResult.stderr || localDoctorMissingResult.stdout,
+    );
+
+    const invalidEnv = {
+      ...env,
+      SLACK_TOKEN: "xoxc-invalid-token",
+      SLACK_COOKIE: "xoxd-invalid-cookie",
+    };
+    const localDoctorInvalidResult = runLocalDoctor({ env: invalidEnv });
+    printResult("local-doctor-invalid", localDoctorInvalidResult);
+    assert(
+      localDoctorInvalidResult.status === 2,
+      "Expected local --doctor to exit 2 when credentials are invalid",
+      localDoctorInvalidResult.stderr || localDoctorInvalidResult.stdout,
+    );
+
+    console.log("\nInstall flow verification passed.");
+  } finally {
+    rmSync(testHome, { recursive: true, force: true });
+  }
+}
+
+main();

package/src/cli.js

@@ -20,6 +20,7 @@ const firstArg = args[0];
 const WIZARD_ARGS = new Set([
   "--setup", "setup",
   "--status", "status",
+  "--doctor", "doctor",
   "--version", "-v",
   "--help", "-h", "help",
 ]);

package/src/server-http.js

@@ -30,7 +30,7 @@ import {
 } from "../lib/handlers.js";
 
 const SERVER_NAME = "slack-mcp-server";
-const SERVER_VERSION = "1.2.2";
+const SERVER_VERSION = "1.2.4";
 const PORT = process.env.PORT || 3000;
 
 // Create MCP server

package/src/server.js

@@ -11,7 +11,7 @@
  * - Network error retry with exponential backoff
  * - Background token health monitoring
  *
- * @version 1.2.2
+ * @version 1.2.4
  */
 
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -25,7 +25,7 @@ import {
   ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 
-import { loadTokens } from "../lib/token-store.js";
+import { loadTokensReadOnly } from "../lib/token-store.js";
 import { checkTokenHealth } from "../lib/slack-client.js";
 import { TOOLS } from "../lib/tools.js";
 import {
@@ -47,7 +47,7 @@ const BACKGROUND_REFRESH_INTERVAL = 4 * 60 * 60 * 1000;
 
 // Package info
 const SERVER_NAME = "slack-mcp-server";
-const SERVER_VERSION = "1.2.2";
+const SERVER_VERSION = "1.2.4";
 
 // MCP Prompts - predefined prompt templates for common Slack operations
 const PROMPTS = [
@@ -271,10 +271,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Main entry point
 async function main() {
   // Check for credentials at startup
-  const credentials = loadTokens();
+  const credentials = loadTokensReadOnly();
   if (!credentials) {
     console.error("WARNING: No Slack credentials found at startup");
-    console.error("Will attempt Chrome auto-extraction on first API call");
+    console.error("Use npx -y @jtalk22/slack-mcp --setup to configure credentials");
   } else {
     console.error(`Credentials loaded from: ${credentials.source}`);
 

package/src/web-server.js

@@ -5,7 +5,7 @@
  * Exposes Slack MCP tools as REST endpoints for browser access.
  * Run alongside or instead of the MCP server for web-based access.
  *
- * @version 1.2.2
+ * @version 1.2.4
  */
 
 import express from "express";
@@ -15,7 +15,7 @@ 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";
+import { loadTokensReadOnly } from "../lib/token-store.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 import {
@@ -116,7 +116,7 @@ function extractContent(result) {
 app.get("/", (req, res) => {
   res.json({
     name: "Slack Web API Server",
-    version: "1.2.2",
+    version: "1.2.4",
     status: "running",
     endpoints: [
       "GET  /health",
@@ -283,10 +283,10 @@ app.get("/users/:id", authenticate, async (req, res) => {
 // Start server
 async function main() {
   // Check for credentials
-  const credentials = loadTokens();
+  const credentials = loadTokensReadOnly();
   if (!credentials) {
     console.error("WARNING: No Slack credentials found");
-    console.error("Run: npm run tokens:auto");
+    console.error("Run: npx -y @jtalk22/slack-mcp --setup");
   } else {
     console.log(`Credentials loaded from: ${credentials.source}`);
   }
@@ -295,7 +295,7 @@ async function main() {
   app.listen(PORT, '127.0.0.1', () => {
     // Print to stderr to keep logs clean (stdout reserved for JSON in some setups)
     console.error(`\n${"═".repeat(60)}`);
-    console.error(`  Slack Web API Server v1.2.2`);
+    console.error(`  Slack Web API Server v1.2.4`);
     console.error(`${"═".repeat(60)}`);
     console.error(`\n  Dashboard: http://localhost:${PORT}/?key=${API_KEY}`);
     console.error(`\n  API Key:   ${API_KEY}`);