@jtalk22/slack-mcp 1.2.4 → 3.0.0

package/scripts/capture-screenshots.js

@@ -1,17 +1,34 @@
 #!/usr/bin/env node
 /**
  * Screenshot capture script using Playwright
- * Captures polished screenshots of the demo UI for README/docs
+ * Captures desktop + mobile screenshots for README/docs
  */
 
 import { chromium } from 'playwright';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { readFileSync } from 'fs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const projectRoot = join(__dirname, '..');
+const imagesDir = join(projectRoot, 'docs', 'images');
+
+const viewports = [
+  { width: 390, height: 844, suffix: '390x844' },
+  { width: 360, height: 800, suffix: '360x800' }
+];
+
+async function openPage(browser, filePath, viewport) {
+  const context = await browser.newContext({
+    viewport,
+    deviceScaleFactor: 2,
+    colorScheme: 'dark'
+  });
+  const page = await context.newPage();
+  await page.goto(`file://${filePath}`);
+  await page.waitForTimeout(1000);
+  return { context, page };
+}
 
 async function captureScreenshots() {
   console.log('Launching browser...');
@@ -20,68 +37,94 @@ async function captureScreenshots() {
     headless: true
   });
 
-  const context = await browser.newContext({
-    viewport: { width: 1400, height: 900 },
-    deviceScaleFactor: 2, // Retina quality
-    colorScheme: 'dark'
-  });
-
-  const page = await context.newPage();
-
-  // Load the demo.html file directly
   const demoPath = join(projectRoot, 'public', 'demo.html');
-  const demoHtml = readFileSync(demoPath, 'utf-8');
-
-  // Serve it as a data URL or file URL
-  await page.goto(`file://${demoPath}`);
+  const demoClaudePath = join(projectRoot, 'public', 'demo-claude.html');
+  const indexPath = join(projectRoot, 'public', 'index.html');
 
-  // Wait for content to render
-  await page.waitForTimeout(1000);
+  // Desktop captures from demo.html
+  {
+    const { context, page } = await openPage(browser, demoPath, { width: 1400, height: 900 });
 
-  const imagesDir = join(projectRoot, 'docs', 'images');
+    console.log('Capturing desktop demo screenshots...');
+    await page.screenshot({
+      path: join(imagesDir, 'demo-main.png'),
+      clip: { x: 0, y: 0, width: 1400, height: 800 }
+    });
 
-  // Screenshot 1: Full UI with DMs
-  console.log('Capturing main UI screenshot...');
-  await page.screenshot({
-    path: join(imagesDir, 'demo-main.png'),
-    clip: { x: 0, y: 0, width: 1400, height: 800 }
-  });
+    const mainPanel = await page.$('.main-panel');
+    if (mainPanel) {
+      await mainPanel.screenshot({
+        path: join(imagesDir, 'demo-messages.png')
+      });
+    }
+
+    const sidebar = await page.$('.sidebar');
+    if (sidebar) {
+      await sidebar.screenshot({
+        path: join(imagesDir, 'demo-sidebar.png')
+      });
+    }
+
+    await page.evaluate(() => runScenario('listChannels'));
+    await page.waitForTimeout(2600);
+    await page.screenshot({
+      path: join(imagesDir, 'demo-channels.png'),
+      clip: { x: 0, y: 0, width: 1400, height: 800 }
+    });
 
-  // Screenshot 2: Conversation view (zoomed)
-  console.log('Capturing conversation screenshot...');
-  const mainPanel = await page.$('.main-panel');
-  if (mainPanel) {
-    await mainPanel.screenshot({
-      path: join(imagesDir, 'demo-messages.png')
+    await page.click('.conversation-item:first-child');
+    await page.waitForTimeout(600);
+    await page.screenshot({
+      path: join(imagesDir, 'demo-channel-messages.png'),
+      clip: { x: 0, y: 0, width: 1400, height: 800 }
     });
+
+    await context.close();
   }
 
-  // Screenshot 3: Sidebar with conversations
-  console.log('Capturing sidebar screenshot...');
-  const sidebar = await page.$('.sidebar');
-  if (sidebar) {
-    await sidebar.screenshot({
-      path: join(imagesDir, 'demo-sidebar.png')
+  // Poster from the Claude demo
+  {
+    const { context, page } = await openPage(browser, demoClaudePath, { width: 1280, height: 800 });
+    console.log('Capturing poster image...');
+    await page.screenshot({
+      path: join(imagesDir, 'demo-poster.png'),
+      clip: { x: 0, y: 0, width: 1280, height: 800 }
     });
+    await context.close();
   }
 
-  // Screenshot 4: Switch to channels view
-  console.log('Capturing channels view...');
-  await page.click('.tabs button:nth-child(2)'); // Click Channels tab
-  await page.waitForTimeout(300);
-  await page.screenshot({
-    path: join(imagesDir, 'demo-channels.png'),
-    clip: { x: 0, y: 0, width: 1400, height: 800 }
-  });
-
-  // Screenshot 5: Engineering channel messages
-  console.log('Capturing channel messages...');
-  await page.click('.conversation-item:first-child'); // Click first channel
-  await page.waitForTimeout(300);
-  await page.screenshot({
-    path: join(imagesDir, 'demo-channel-messages.png'),
-    clip: { x: 0, y: 0, width: 1400, height: 800 }
-  });
+  // Mobile captures for web, demo, and claude demo pages
+  for (const viewport of viewports) {
+    const label = `${viewport.width}x${viewport.height}`;
+    console.log(`Capturing mobile screenshots (${label})...`);
+
+    {
+      const { context, page } = await openPage(browser, demoPath, viewport);
+      await page.screenshot({
+        path: join(imagesDir, `demo-main-mobile-${viewport.suffix}.png`),
+        fullPage: true
+      });
+      await context.close();
+    }
+
+    {
+      const { context, page } = await openPage(browser, demoClaudePath, viewport);
+      await page.screenshot({
+        path: join(imagesDir, `demo-claude-mobile-${viewport.suffix}.png`),
+        fullPage: true
+      });
+      await context.close();
+    }
+
+    {
+      const { context, page } = await openPage(browser, indexPath, viewport);
+      await page.screenshot({
+        path: join(imagesDir, `web-api-mobile-${viewport.suffix}.png`),
+        fullPage: true
+      });
+      await context.close();
+    }
+  }
 
   await browser.close();
 
@@ -91,6 +134,13 @@ async function captureScreenshots() {
   console.log('  - demo-sidebar.png');
   console.log('  - demo-channels.png');
   console.log('  - demo-channel-messages.png');
+  console.log('  - demo-poster.png');
+  console.log('  - demo-main-mobile-390x844.png');
+  console.log('  - demo-main-mobile-360x800.png');
+  console.log('  - demo-claude-mobile-390x844.png');
+  console.log('  - demo-claude-mobile-360x800.png');
+  console.log('  - web-api-mobile-390x844.png');
+  console.log('  - web-api-mobile-360x800.png');
 }
 
 captureScreenshots().catch(console.error);

package/scripts/check-version-parity.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(__dirname, "..");
+
+const pkg = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"));
+const serverMeta = JSON.parse(readFileSync(join(repoRoot, "server.json"), "utf8"));
+
+const outputArg = process.argv.includes("--out")
+  ? process.argv[process.argv.indexOf("--out") + 1]
+  : "docs/release-health/version-parity.md";
+const allowPropagation = process.argv.includes("--allow-propagation");
+
+const mcpServerName = serverMeta.name;
+const smitheryEndpoint = "https://server.smithery.ai/jtalk22/slack-mcp-server";
+const smitheryListingUrl = "https://smithery.ai/server/jtalk22/slack-mcp-server";
+
+async function fetchJson(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} for ${url}`);
+  }
+  return res.json();
+}
+
+async function fetchStatus(url) {
+  const res = await fetch(url);
+  const text = await res.text().catch(() => "");
+  return { ok: res.ok, status: res.status, text };
+}
+
+function row(surface, version, status, note = "") {
+  return `| ${surface} | ${version || "n/a"} | ${status} | ${note} |`;
+}
+
+async function main() {
+  const localVersion = pkg.version;
+  const localServerVersion = serverMeta.version;
+  const localServerPkgVersion = serverMeta.packages?.[0]?.version || null;
+
+  let npmVersion = null;
+  let mcpRegistryVersion = null;
+  let smitheryReachable = null;
+  let smitheryStatus = null;
+  let npmError = null;
+  let mcpError = null;
+  let smitheryError = null;
+
+  try {
+    const npmMeta = await fetchJson(`https://registry.npmjs.org/${encodeURIComponent(pkg.name)}`);
+    npmVersion = npmMeta?.["dist-tags"]?.latest || null;
+  } catch (error) {
+    npmError = String(error?.message || error);
+  }
+
+  try {
+    const registry = await fetchJson(
+      `https://registry.modelcontextprotocol.io/v0/servers/${encodeURIComponent(mcpServerName)}/versions/latest`
+    );
+    mcpRegistryVersion = registry?.server?.version || null;
+  } catch (error) {
+    mcpError = String(error?.message || error);
+  }
+
+  try {
+    const apiResult = await fetchStatus(smitheryEndpoint);
+    smitheryStatus = apiResult.status;
+    if (apiResult.ok) {
+      smitheryReachable = true;
+    } else if (apiResult.status === 401 || apiResult.status === 403) {
+      // Auth-gated endpoint still indicates the listing endpoint is live.
+      smitheryReachable = true;
+    } else {
+      const listingResult = await fetchStatus(smitheryListingUrl);
+      smitheryStatus = `${apiResult.status} (api), ${listingResult.status} (listing)`;
+      smitheryReachable = listingResult.ok && listingResult.text.length > 0;
+    }
+  } catch (error) {
+    smitheryError = String(error?.message || error);
+  }
+
+  const parityChecks = [
+    { name: "package.json vs server.json", ok: localVersion === localServerVersion },
+    { name: "package.json vs server.json package", ok: localVersion === localServerPkgVersion },
+    { name: "npm latest", ok: npmVersion === localVersion },
+    { name: "MCP registry latest", ok: mcpRegistryVersion === localVersion },
+  ];
+
+  const externalMismatches = parityChecks
+    .filter((check) => !check.ok && (check.name === "npm latest" || check.name === "MCP registry latest"));
+  const hardFailures = parityChecks
+    .filter((check) => !check.ok && check.name !== "npm latest" && check.name !== "MCP registry latest");
+
+  const now = new Date().toISOString();
+  const lines = [
+    "# Version Parity Report",
+    "",
+    `- Generated: ${now}`,
+    `- Local target version: ${localVersion}`,
+    "",
+    "## Surface Matrix",
+    "",
+    "| Surface | Version | Status | Notes |",
+    "|---|---|---|---|",
+    row(
+      "package.json",
+      localVersion,
+      "ok"
+    ),
+    row(
+      "server.json (root)",
+      localServerVersion,
+      localServerVersion === localVersion ? "ok" : "mismatch"
+    ),
+    row(
+      "server.json (package entry)",
+      localServerPkgVersion,
+      localServerPkgVersion === localVersion ? "ok" : "mismatch"
+    ),
+    row(
+      "npm dist-tag latest",
+      npmVersion,
+      npmVersion === localVersion ? "ok" : "mismatch",
+      npmError ? `fetch_error: ${npmError}` : ""
+    ),
+    row(
+      "MCP Registry latest",
+      mcpRegistryVersion,
+      mcpRegistryVersion === localVersion ? "ok" : "mismatch",
+      mcpError ? `fetch_error: ${mcpError}` : ""
+    ),
+    row(
+      "Smithery endpoint",
+      "n/a",
+      smitheryReachable ? "reachable" : "unreachable",
+      smitheryError
+        ? `check_error: ${smitheryError}`
+        : `status: ${smitheryStatus ?? "unknown"}; version check is manual.`
+    ),
+    "",
+    "## Interpretation",
+    "",
+    hardFailures.length === 0
+      ? "- Local metadata parity: pass."
+      : `- Local metadata parity: fail (${hardFailures.map((f) => f.name).join(", ")}).`,
+    externalMismatches.length === 0
+      ? "- External parity: pass."
+      : `- External parity mismatch: ${externalMismatches.map((f) => f.name).join(", ")}.`,
+    externalMismatches.length === 0
+      ? "- Propagation mode: not needed (external parity is already aligned)."
+      : (allowPropagation
+          ? "- Propagation mode enabled: external mismatch accepted temporarily."
+          : "- Propagation mode disabled: external mismatch is a release gate failure."),
+  ];
+
+  const outPath = join(repoRoot, outputArg);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, `${lines.join("\n")}\n`, "utf8");
+  console.log(`Wrote ${outputArg}`);
+
+  if (hardFailures.length > 0) {
+    process.exit(1);
+  }
+  if (!allowPropagation && externalMismatches.length > 0) {
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/cloudflare-browser-tool.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
+const API_TOKEN = process.env.CLOUDFLARE_API_TOKEN || process.env.CF_TERRAFORM_TOKEN;
+
+const ENDPOINTS = new Map([
+  ["content", "content"],
+  ["markdown", "markdown"],
+  ["links", "links"],
+  ["snapshot", "snapshot"],
+  ["scrape", "scrape"],
+  ["json", "json"],
+  ["screenshot", "screenshot"],
+  ["pdf", "pdf"],
+]);
+
+function usage() {
+  console.error(`Usage:
+  node scripts/cloudflare-browser-tool.js verify
+  node scripts/cloudflare-browser-tool.js <mode> <url> [options]
+
+Modes:
+  content     Rendered HTML
+  markdown    Rendered markdown
+  links       Extract links
+  snapshot    HTML with inlined resources
+  scrape      Extract CSS selectors (use --selectors "h1,.card")
+  json        AI-structured extraction (use --schema '{"title":"string"}')
+  screenshot  Capture PNG/JPEG (use --out ./page.png)
+  pdf         Capture PDF (use --out ./page.pdf)
+
+Options:
+  --wait-until <value>   load|domcontentloaded|networkidle0|networkidle2
+  --selectors <csv>      CSS selectors for scrape mode
+  --schema <json>        JSON schema object for json mode
+  --out <path>           Output path for screenshot/pdf
+  --full-page            fullPage screenshot (default true)
+  --type <png|jpeg>      screenshot type (default png)
+`);
+}
+
+function getOption(args, name) {
+  const idx = args.indexOf(name);
+  if (idx === -1 || idx + 1 >= args.length) return null;
+  return args[idx + 1];
+}
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+async function verifyToken() {
+  if (!API_TOKEN) {
+    throw new Error("Missing API token. Set CLOUDFLARE_API_TOKEN or CF_TERRAFORM_TOKEN.");
+  }
+
+  const checks = [];
+  if (ACCOUNT_ID) {
+    checks.push({
+      source: "account",
+      url: `https://api.cloudflare.com/client/v4/accounts/${ACCOUNT_ID}/tokens/verify`,
+    });
+  }
+  checks.push({
+    source: "user",
+    url: "https://api.cloudflare.com/client/v4/user/tokens/verify",
+  });
+
+  const failures = [];
+  for (const check of checks) {
+    const res = await fetch(check.url, {
+      headers: {
+        Authorization: `Bearer ${API_TOKEN}`,
+        "Content-Type": "application/json",
+      },
+    });
+
+    const raw = await res.text();
+    let data = null;
+    try {
+      data = raw ? JSON.parse(raw) : null;
+    } catch {
+      failures.push({
+        source: check.source,
+        status: res.status,
+        message: `Non-JSON response: ${raw.slice(0, 200)}`,
+      });
+      continue;
+    }
+
+    if (res.ok && data?.success) {
+      return {
+        source: check.source,
+        result: data.result,
+      };
+    }
+
+    failures.push({
+      source: check.source,
+      status: res.status,
+      message: JSON.stringify(data?.errors || data || raw),
+    });
+  }
+
+  throw new Error(`Token verify failed: ${JSON.stringify(failures)}`);
+}
+
+async function callBrowserApi(mode, url, options) {
+  if (!ACCOUNT_ID) {
+    throw new Error("Missing CLOUDFLARE_ACCOUNT_ID.");
+  }
+  if (!API_TOKEN) {
+    throw new Error("Missing API token. Set CLOUDFLARE_API_TOKEN or CF_TERRAFORM_TOKEN.");
+  }
+
+  const endpoint = ENDPOINTS.get(mode);
+  if (!endpoint) {
+    throw new Error(`Unsupported mode: ${mode}`);
+  }
+
+  const body = {
+    url,
+  };
+
+  if (options.waitUntil) {
+    body.waitUntil = options.waitUntil;
+  }
+  if (mode === "scrape" && options.selectors?.length) {
+    body.selectors = options.selectors;
+  }
+  if (mode === "json" && options.schema) {
+    body.schema = options.schema;
+  }
+  if (mode === "screenshot") {
+    body.screenshotOptions = {
+      type: options.type || "png",
+      fullPage: options.fullPage,
+    };
+  }
+  if (mode === "pdf") {
+    body.pdfOptions = {
+      printBackground: true,
+      format: "A4",
+    };
+  }
+
+  const res = await fetch(
+    `https://api.cloudflare.com/client/v4/accounts/${ACCOUNT_ID}/browser-rendering/${endpoint}`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${API_TOKEN}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    }
+  );
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Browser Rendering API failed (${res.status}): ${text || res.statusText}`);
+  }
+
+  return res;
+}
+
+async function main() {
+  const [, , mode, url, ...rest] = process.argv;
+
+  if (!mode) {
+    usage();
+    process.exit(1);
+  }
+
+  if (mode === "verify") {
+    const tokenInfo = await verifyToken();
+    console.log(
+      JSON.stringify(
+        {
+          status: "ok",
+          verify_source: tokenInfo.source,
+          token_status: tokenInfo.result?.status || "unknown",
+          token_id: tokenInfo.result?.id || null,
+          account_id_present: Boolean(ACCOUNT_ID),
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  if (!url) {
+    usage();
+    process.exit(1);
+  }
+
+  const options = {
+    waitUntil: getOption(rest, "--wait-until") || undefined,
+    selectors: (getOption(rest, "--selectors") || "")
+      .split(",")
+      .map((v) => v.trim())
+      .filter(Boolean),
+    schema: getOption(rest, "--schema") ? JSON.parse(getOption(rest, "--schema")) : undefined,
+    out: getOption(rest, "--out") || undefined,
+    type: getOption(rest, "--type") || "png",
+    fullPage: !hasFlag(rest, "--no-full-page"),
+  };
+
+  const res = await callBrowserApi(mode, url, options);
+
+  if (mode === "screenshot" || mode === "pdf") {
+    const outputPath = resolve(options.out || (mode === "pdf" ? "./cloudflare-page.pdf" : "./cloudflare-page.png"));
+    const buffer = Buffer.from(await res.arrayBuffer());
+    writeFileSync(outputPath, buffer);
+    console.log(JSON.stringify({ status: "ok", mode, output: outputPath, bytes: buffer.length }, null, 2));
+    return;
+  }
+
+  const contentType = res.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    const json = await res.json();
+    console.log(JSON.stringify(json, null, 2));
+    return;
+  }
+
+  const text = await res.text();
+  console.log(text);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/scripts/collect-release-health.js

@@ -70,7 +70,7 @@ function buildMarkdown(data) {
   lines.push(`- deployment-intake submissions (all-time): ${data.github.deploymentIntakeCount ?? "n/a"}`);
   lines.push("");
 
-  lines.push("## 14-Day Reliability Targets (v1.2.4 Cycle)");
+  lines.push("## 14-Day Reliability Targets (v3.0.0 Cycle)");
   lines.push("");
   lines.push("- weekly downloads: >= 180");
   lines.push("- qualified deployment-intake submissions: >= 2");

package/scripts/record-demo.js

@@ -10,11 +10,17 @@
 import { chromium } from 'playwright';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { mkdirSync, existsSync } from 'fs';
+import { mkdirSync, existsSync, copyFileSync } from 'fs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const projectRoot = join(__dirname, '..');
+const argv = process.argv.slice(2);
+const hasArg = (flag) => argv.includes(flag);
+const argValue = (flag) => {
+  const idx = argv.indexOf(flag);
+  return idx >= 0 && idx + 1 < argv.length ? argv[idx + 1] : null;
+};
 
 // Configuration
 const CONFIG = {
@@ -34,6 +40,9 @@ const CONFIG = {
   }
 };
 
+const canonicalOutput = argValue('--out') || join(projectRoot, 'docs', 'videos', 'demo-claude.webm');
+const archiveOutput = hasArg('--archive');
+
 async function recordDemo() {
   console.log('╔════════════════════════════════════════════════════════════╗');
   console.log('║  Slack MCP Server - Demo Video Recording                   ║');
@@ -47,13 +56,12 @@ async function recordDemo() {
     console.log(`📁 Created directory: ${videosDir}`);
   }
 
-  // Generate timestamped filename
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-  const videoFilename = `demo-claude-${timestamp}.webm`;
+  const timestampedOutput = join(videosDir, `demo-claude-${timestamp}.webm`);
 
   console.log('🚀 Launching browser...');
   const browser = await chromium.launch({
-    headless: false, // Need visible browser for recording
+    headless: true,
   });
 
   const context = await browser.newContext({
@@ -134,13 +142,18 @@ async function recordDemo() {
   console.log('║  ✅ Recording Complete!                                     ║');
   console.log('╚════════════════════════════════════════════════════════════╝');
   console.log();
-  console.log(`📹 Video saved: ${videoPath}`);
+  copyFileSync(videoPath, canonicalOutput);
+  console.log(`📹 Canonical video: ${canonicalOutput}`);
+  if (archiveOutput) {
+    copyFileSync(videoPath, timestampedOutput);
+    console.log(`🗂️  Archived copy: ${timestampedOutput}`);
+  }
   console.log();
   console.log('Next steps:');
-  console.log('  1. Review the video in a media player');
-  console.log('  2. Convert to GIF: npm run gif (requires gifski)');
-  console.log('  3. Or with FFmpeg:');
-  console.log(`     ffmpeg -i "${videoPath}" -vf "fps=15,scale=800:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" docs/images/demo-claude.gif`);
+  console.log('  1. Review the canonical video in a media player');
+  console.log('  2. Convert to GIF with FFmpeg:');
+  console.log(`     ffmpeg -i "${canonicalOutput}" -vf "fps=15,scale=800:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" docs/images/demo-claude.gif`);
+  console.log('  3. Re-run with --archive to keep timestamped historical outputs');
 }
 
 recordDemo().catch(err => {