@jtalk22/slack-mcp 1.2.3 → 2.0.0

package/scripts/check-version-parity.js

@@ -0,0 +1,162 @@
+#!/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";
+
+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 fetchText(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} for ${url}`);
+  }
+  return res.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 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 html = await fetchText(smitheryEndpoint);
+    smitheryReachable = html.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}` : "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(", ")}.`,
+    allowPropagation && externalMismatches.length > 0
+      ? "- 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/collect-release-health.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+import { execSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const REPO =
+  process.env.RELEASE_HEALTH_REPO ||
+  process.env.GROWTH_REPO ||
+  "jtalk22/slack-mcp-server";
+const NPM_PACKAGE =
+  process.env.RELEASE_HEALTH_NPM_PACKAGE ||
+  process.env.GROWTH_NPM_PACKAGE ||
+  "@jtalk22/slack-mcp";
+
+function safeGhApi(path) {
+  try {
+    const out = execSync(`gh api ${path}`, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+    return JSON.parse(out);
+  } catch {
+    return null;
+  }
+}
+
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Request failed: ${url} (${response.status})`);
+  }
+  return response.json();
+}
+
+function toDateSlug(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+function countNonPrIssues(items) {
+  if (!Array.isArray(items)) return 0;
+  return items.filter((item) => item && !item.pull_request).length;
+}
+
+function buildMarkdown(data) {
+  const lines = [];
+  lines.push("# Release Health Snapshot");
+  lines.push("");
+  lines.push(`- Generated: ${data.generatedAt}`);
+  lines.push(`- Repo: \`${REPO}\``);
+  lines.push(`- Package: \`${NPM_PACKAGE}\``);
+  lines.push("");
+
+  lines.push("## Install Signals");
+  lines.push("");
+  lines.push(`- npm downloads (last week): ${data.npm.lastWeek ?? "n/a"}`);
+  lines.push(`- npm downloads (last month): ${data.npm.lastMonth ?? "n/a"}`);
+  lines.push(`- npm latest version: ${data.npm.latestVersion ?? "n/a"}`);
+  lines.push("");
+
+  lines.push("## GitHub Reach");
+  lines.push("");
+  lines.push(`- stars: ${data.github.stars ?? "n/a"}`);
+  lines.push(`- forks: ${data.github.forks ?? "n/a"}`);
+  lines.push(`- open issues: ${data.github.openIssues ?? "n/a"}`);
+  lines.push(`- 14d views: ${data.github.viewsCount ?? "n/a"}`);
+  lines.push(`- 14d unique visitors: ${data.github.viewsUniques ?? "n/a"}`);
+  lines.push(`- 14d clones: ${data.github.clonesCount ?? "n/a"}`);
+  lines.push(`- 14d unique cloners: ${data.github.clonesUniques ?? "n/a"}`);
+  lines.push(`- deployment-intake submissions (all-time): ${data.github.deploymentIntakeCount ?? "n/a"}`);
+  lines.push("");
+
+  lines.push("## 14-Day Reliability Targets (v2.0.0 Cycle)");
+  lines.push("");
+  lines.push("- weekly downloads: >= 180");
+  lines.push("- qualified deployment-intake submissions: >= 2");
+  lines.push("- maintainer support load: <= 2 hours/week");
+  lines.push("");
+
+  lines.push("## Notes");
+  lines.push("");
+  lines.push("- Update this snapshot daily during active release windows, then weekly.");
+  lines.push("- Track deployment-intake quality and support load manually in issue notes.");
+
+  return `${lines.join("\n")}\n`;
+}
+
+async function main() {
+  const now = new Date();
+  const generatedAt = now.toISOString();
+  const dateSlug = toDateSlug(now);
+
+  let npmWeek = null;
+  let npmMonth = null;
+  let npmMeta = null;
+
+  try {
+    npmWeek = await fetchJson(`https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(NPM_PACKAGE)}`);
+  } catch {}
+
+  try {
+    npmMonth = await fetchJson(`https://api.npmjs.org/downloads/point/last-month/${encodeURIComponent(NPM_PACKAGE)}`);
+  } catch {}
+
+  try {
+    npmMeta = await fetchJson(`https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE)}`);
+  } catch {}
+
+  const repoInfo = safeGhApi(`repos/${REPO}`) || {};
+  const views = safeGhApi(`repos/${REPO}/traffic/views`) || {};
+  const clones = safeGhApi(`repos/${REPO}/traffic/clones`) || {};
+  const intakeIssues = safeGhApi(`repos/${REPO}/issues?state=all&labels=deployment-intake&per_page=100`) || [];
+
+  const data = {
+    generatedAt,
+    npm: {
+      lastWeek: npmWeek?.downloads ?? null,
+      lastMonth: npmMonth?.downloads ?? null,
+      latestVersion: npmMeta?.["dist-tags"]?.latest ?? null,
+    },
+    github: {
+      stars: repoInfo.stargazers_count ?? null,
+      forks: repoInfo.forks_count ?? null,
+      openIssues: repoInfo.open_issues_count ?? null,
+      viewsCount: views.count ?? null,
+      viewsUniques: views.uniques ?? null,
+      clonesCount: clones.count ?? null,
+      clonesUniques: clones.uniques ?? null,
+      deploymentIntakeCount: countNonPrIssues(intakeIssues),
+    },
+  };
+
+  const markdown = buildMarkdown(data);
+
+  const metricsDir = resolve("docs", "release-health");
+  const datedPath = join(metricsDir, `${dateSlug}.md`);
+  const latestPath = join(metricsDir, "latest.md");
+
+  mkdirSync(metricsDir, { recursive: true });
+  writeFileSync(datedPath, markdown);
+  writeFileSync(latestPath, markdown);
+
+  console.log(`Wrote ${datedPath}`);
+  console.log(`Wrote ${latestPath}`);
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/scripts/setup-wizard.js

@@ -13,9 +13,9 @@
 import { platform } from "os";
 import * as readline from "readline";
 import {
-  loadTokens,
   saveTokens,
   extractFromChrome,
+  getLastExtractionError,
   isAutoRefreshAvailable,
   TOKEN_FILE,
   getFromFile,
@@ -23,8 +23,9 @@ import {
 } from "../lib/token-store.js";
 
 const IS_MACOS = platform() === 'darwin';
-const VERSION = "1.2.3";
+const VERSION = "2.0.0";
 const MIN_NODE_MAJOR = 20;
+const AUTH_TEST_URL = process.env.SLACK_MCP_AUTH_TEST_URL || "https://slack.com/api/auth.test";
 
 // ANSI colors
 const colors = {
@@ -78,7 +79,7 @@ async function pressEnterToContinue(rl) {
 
 async function validateTokens(token, cookie) {
   try {
-    const response = await fetch("https://slack.com/api/auth.test", {
+    const response = await fetch(AUTH_TEST_URL, {
       method: "POST",
       headers: {
         "Authorization": `Bearer ${token}`,
@@ -118,13 +119,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): ");
@@ -233,17 +248,21 @@ async function runManualSetup(rl) {
 }
 
 async function showStatus() {
-  const creds = loadTokens();
+  const creds = getDoctorCredentials();
 
   if (!creds) {
     error("No tokens found");
+    print("Code: missing_credentials");
+    print("Message: No credentials available from environment, file, or keychain.");
     print();
     print("Run setup wizard: npx -y @jtalk22/slack-mcp --setup");
     process.exit(1);
   }
 
   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}`);
   }
@@ -252,6 +271,7 @@ async function showStatus() {
   const result = await validateTokens(creds.token, creds.cookie);
   if (!result.valid) {
     error("Status: INVALID");
+    print("Code: auth_failed");
     print(`Error: ${result.error}`);
     print();
     print("Run setup wizard to refresh: npx -y @jtalk22/slack-mcp --setup");
@@ -259,6 +279,8 @@ async function showStatus() {
   }
 
   success("Status: VALID");
+  print("Code: ok");
+  print("Message: Slack auth valid.");
   print(`User: ${result.user}`);
   print(`Team: ${result.team}`);
   print(`User ID: ${result.userId}`);
@@ -315,6 +337,7 @@ async function runDoctor() {
   const nodeMajor = parseNodeMajor();
   if (Number.isNaN(nodeMajor) || nodeMajor < MIN_NODE_MAJOR) {
     error(`Node.js ${process.versions.node} detected (requires Node ${MIN_NODE_MAJOR}+)`);
+    print("Code: runtime_node_unsupported");
     print();
     print("Next action:");
     print(`  npx -y @jtalk22/slack-mcp --doctor  # rerun after upgrading Node ${MIN_NODE_MAJOR}+`);
@@ -325,6 +348,7 @@ async function runDoctor() {
   const creds = getDoctorCredentials();
   if (!creds) {
     error("Credentials: not found");
+    print("Code: missing_credentials");
     print();
     print("Next action:");
     print("  npx -y @jtalk22/slack-mcp --setup");
@@ -345,6 +369,7 @@ async function runDoctor() {
   if (!validation.valid) {
     const exitCode = classifyAuthError(validation.error);
     error(`Slack auth failed: ${validation.error}`);
+    print(`Code: ${exitCode === 2 ? "auth_invalid" : "runtime_auth_check_failed"}`);
     print();
     print("Next action:");
     if (exitCode === 2) {
@@ -357,6 +382,7 @@ async function runDoctor() {
   }
 
   success(`Slack auth valid for ${validation.user} @ ${validation.team}`);
+  print("Code: ok");
   print();
   print("Ready. Next command:");
   print("  npx -y @jtalk22/slack-mcp");

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

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 
 import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 
 const PKG = "@jtalk22/slack-mcp";
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const strictPublished = process.argv.includes("--strict-published");
+const localVersion = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8")).version;
 
 function runNpx(args, options = {}) {
   const cmdArgs = ["-y", PKG, ...args];
@@ -45,6 +49,40 @@ function printResult(label, result) {
   }
 }
 
+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-"));
 
@@ -61,6 +99,18 @@ function main() {
       "Expected --version to exit 0",
       versionResult.stderr || versionResult.stdout,
     );
+    const publishedMatchesLocal = versionResult.stdout.includes(localVersion);
+    if (strictPublished) {
+      assert(
+        publishedMatchesLocal,
+        `Expected published npx version to match local ${localVersion}`,
+        versionResult.stdout,
+      );
+    } else if (!publishedMatchesLocal) {
+      console.log(
+        `warning: npx resolved ${versionResult.stdout || "unknown"} while local version is ${localVersion}; strict published checks are deferred until publish.`
+      );
+    }
 
     const helpResult = runNpx(["--help"], { cwd: testHome, env });
     printResult("help", helpResult);
@@ -77,6 +127,61 @@ function main() {
       "Expected --status to exit non-zero when credentials are missing",
       statusResult.stderr || statusResult.stdout,
     );
+    if (strictPublished) {
+      assert(
+        !statusResult.stderr.includes("Attempting Chrome auto-extraction"),
+        "Expected npx --status to be read-only without auto-extraction side effects",
+        statusResult.stderr,
+      );
+    } else if (statusResult.stderr.includes("Attempting Chrome auto-extraction")) {
+      console.log("warning: published npx --status still has extraction side effects; re-run with --strict-published after publish.");
+    }
+
+    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,
+    );
+
+    const runtimeEnv = {
+      ...invalidEnv,
+      SLACK_MCP_AUTH_TEST_URL: "http://127.0.0.1:9/auth.test"
+    };
+    const localDoctorRuntimeResult = runLocalDoctor({ env: runtimeEnv });
+    printResult("local-doctor-runtime", localDoctorRuntimeResult);
+    assert(
+      localDoctorRuntimeResult.status === 3,
+      "Expected local --doctor to exit 3 when runtime connectivity fails",
+      localDoctorRuntimeResult.stderr || localDoctorRuntimeResult.stdout,
+    );
 
     console.log("\nInstall flow verification passed.");
   } finally {

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.3";
+const SERVER_VERSION = "2.0.0";
 const PORT = process.env.PORT || 3000;
 
 // Create MCP server
@@ -74,13 +74,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleListUsers(args);
       default:
         return {
-          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status: "error",
+              code: "unknown_tool",
+              message: `Unknown tool: ${name}`,
+              next_action: "Call tools/list to inspect available tool names."
+            }, null, 2)
+          }],
           isError: true
         };
     }
   } catch (error) {
     return {
-      content: [{ type: "text", text: `Error: ${error.message}` }],
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          status: "error",
+          code: "tool_call_failed",
+          message: String(error?.message || error),
+          next_action: "Retry with validated input payload."
+        }, null, 2)
+      }],
       isError: true
     };
   }
@@ -110,7 +126,13 @@ const httpServer = http.createServer(async (req, res) => {
   // Health check endpoint
   if (req.url === '/health') {
     res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ status: 'ok', server: SERVER_NAME, version: SERVER_VERSION }));
+    res.end(JSON.stringify({
+      status: 'ok',
+      code: 'ok',
+      message: 'HTTP transport healthy',
+      server: SERVER_NAME,
+      version: SERVER_VERSION
+    }));
     return;
   }