@ateam-ai/mcp 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "mcpName": "io.github.ariekogan/ateam-mcp",
   "description": "A-Team MCP Server — build, validate, and deploy multi-agent solutions from any AI environment",
   "type": "module",

package/src/api.js

@@ -17,6 +17,12 @@ const REQUEST_TIMEOUT_MS = 30_000;
 // Per-session credential store (sessionId → { tenant, apiKey })
 const sessions = new Map();
 
+// Per-tenant credential fallback — for MCP clients that don't persist sessions
+// (e.g., ChatGPT's bridge creates a new session per tool call).
+// Keyed by tenant to prevent cross-user credential leaks in shared MCP servers.
+const tenantFallbacks = new Map(); // tenant → { tenant, apiKey, createdAt }
+const FALLBACK_TTL = 60 * 60 * 1000; // 60 minutes
+
 /**
  * Parse a tenant-embedded API key.
  * Format: adas_<tenant>_<32hex>
@@ -35,6 +41,7 @@ export function parseApiKey(key) {
 /**
  * Set credentials for a session (called by ateam_auth tool).
  * If tenant is not provided, it's auto-extracted from the key.
+ * Also updates the global fallback so new sessions inherit credentials.
  */
 export function setSessionCredentials(sessionId, { tenant, apiKey }) {
   let resolvedTenant = tenant;
@@ -42,18 +49,32 @@ export function setSessionCredentials(sessionId, { tenant, apiKey }) {
     const parsed = parseApiKey(apiKey);
     if (parsed.tenant) resolvedTenant = parsed.tenant;
   }
-  sessions.set(sessionId, { tenant: resolvedTenant || "main", apiKey });
+  const creds = { tenant: resolvedTenant || "main", apiKey };
+  sessions.set(sessionId, creds);
+
+  // Update per-tenant fallback — only sessions for the SAME tenant will inherit this
+  tenantFallbacks.set(creds.tenant, { ...creds, createdAt: Date.now() });
+  console.log(`[Auth] Credentials set for session ${sessionId}, tenant fallback updated (tenant: ${creds.tenant})`);
 }
 
 /**
  * Get credentials for a session, falling back to env vars.
- * If using env var key with embedded tenant and no explicit ADAS_TENANT, auto-extract.
+ * Resolution order:
+ *   1. Per-session (from ateam_auth or seedCredentials)
+ *   2. Environment variables (ADAS_API_KEY, ADAS_TENANT)
+ *
+ * Note: tenantFallbacks are NOT used in getCredentials() to prevent
+ * cross-user credential leaks. They are only used in seedFromFallback()
+ * which requires explicit tenant matching.
  */
 export function getCredentials(sessionId) {
+  // 1. Per-session credentials
   const session = sessionId ? sessions.get(sessionId) : null;
   if (session) {
     return { tenant: session.tenant, apiKey: session.apiKey };
   }
+
+  // 2. Environment variables
   const apiKey = ENV_API_KEY || "";
   let tenant = ENV_TENANT;
   if (!tenant && apiKey) {
@@ -63,6 +84,21 @@ export function getCredentials(sessionId) {
   return { tenant: tenant || "main", apiKey };
 }
 
+/**
+ * Seed a session's credentials from a matching tenant fallback.
+ * Called by HTTP transport when a new session is created with a known tenant
+ * (e.g., from OAuth token). Only inherits from the SAME tenant.
+ */
+export function seedFromFallback(sessionId, tenant) {
+  const fallback = tenantFallbacks.get(tenant);
+  if (fallback && (Date.now() - fallback.createdAt < FALLBACK_TTL)) {
+    sessions.set(sessionId, { tenant: fallback.tenant, apiKey: fallback.apiKey });
+    console.log(`[Auth] Seeded session ${sessionId} from tenant fallback (tenant: ${tenant})`);
+    return true;
+  }
+  return false;
+}
+
 /**
  * Check if a session is authenticated (has an API key from any source).
  */
@@ -91,6 +127,7 @@ function headers(sessionId) {
  */
 function formatError(method, path, status, body) {
   const hints = {
+    400: "Bad request — see the error details above for what to fix.",
     401: "Your API key may be invalid or expired. Get a valid key at https://mcp.ateam-ai.com/get-api-key then call ateam_auth(api_key: \"your_key\").",
     403: "You don't have permission for this operation. Check your tenant and API key. Get a key at https://mcp.ateam-ai.com/get-api-key",
     404: "Resource not found. Check the solution_id or skill_id you're using. Use ateam_list_solutions to see available solutions.",
@@ -103,7 +140,7 @@ function formatError(method, path, status, body) {
   };
 
   const hint = hints[status] || "";
-  const detail = typeof body === "string" && body.length > 0 && body.length < 500 ? body : "";
+  const detail = typeof body === "string" && body.length > 0 && body.length < 2000 ? body : "";
 
   let msg = `A-Team API error: ${method} ${path} returned ${status}`;
   if (detail) msg += ` — ${detail}`;
@@ -114,22 +151,28 @@ function formatError(method, path, status, body) {
 
 /**
  * Core fetch wrapper with timeout and error formatting.
+ * @param {string} method
+ * @param {string} path
+ * @param {*} body
+ * @param {string} sessionId
+ * @param {{ timeoutMs?: number }} [opts]
  */
-async function request(method, path, body, sessionId) {
+async function request(method, path, body, sessionId, opts = {}) {
+  const timeoutMs = opts.timeoutMs || REQUEST_TIMEOUT_MS;
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
 
   try {
-    const opts = {
+    const fetchOpts = {
       method,
       headers: headers(sessionId),
       signal: controller.signal,
     };
     if (body !== undefined) {
-      opts.body = JSON.stringify(body);
+      fetchOpts.body = JSON.stringify(body);
     }
 
-    const res = await fetch(`${BASE_URL}${path}`, opts);
+    const res = await fetch(`${BASE_URL}${path}`, fetchOpts);
 
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -140,7 +183,7 @@ async function request(method, path, body, sessionId) {
   } catch (err) {
     if (err.name === "AbortError") {
       throw new Error(
-        `A-Team API timeout: ${method} ${path} did not respond within ${REQUEST_TIMEOUT_MS / 1000}s.\n` +
+        `A-Team API timeout: ${method} ${path} did not respond within ${timeoutMs / 1000}s.\n` +
         `Hint: The A-Team API at ${BASE_URL} may be down. Check https://api.ateam-ai.com/health`
       );
     }
@@ -162,18 +205,18 @@ async function request(method, path, body, sessionId) {
   }
 }
 
-export async function get(path, sessionId) {
-  return request("GET", path, undefined, sessionId);
+export async function get(path, sessionId, opts) {
+  return request("GET", path, undefined, sessionId, opts);
 }
 
-export async function post(path, body, sessionId) {
-  return request("POST", path, body, sessionId);
+export async function post(path, body, sessionId, opts) {
+  return request("POST", path, body, sessionId, opts);
 }
 
-export async function patch(path, body, sessionId) {
-  return request("PATCH", path, body, sessionId);
+export async function patch(path, body, sessionId, opts) {
+  return request("PATCH", path, body, sessionId, opts);
 }
 
-export async function del(path, sessionId) {
-  return request("DELETE", path, undefined, sessionId);
+export async function del(path, sessionId, opts) {
+  return request("DELETE", path, undefined, sessionId, opts);
 }

package/src/http.js

@@ -1,6 +1,21 @@
 /**
  * Streamable HTTP transport for ateam-mcp.
  * Enables ChatGPT and remote MCP clients to connect via HTTPS.
+ *
+ * MCP endpoint is served at BOTH "/" and "/mcp" because:
+ *   - Claude.ai sends requests to the connector URL (root "/")
+ *   - Claude Code and other clients may use "/mcp"
+ *
+ * OAuth2 (enabled by default):
+ *   Serves /.well-known/*, /authorize, /token, /register endpoints.
+ *   MCP routes require a Bearer token — triggers OAuth discovery in Claude.ai.
+ *   Set ATEAM_OAUTH_DISABLED=1 to bypass (for ChatGPT or legacy clients).
+ *
+ * Token Auto-Injection:
+ *   Claude.ai's OAuth client and MCP client don't share Bearer tokens.
+ *   After a successful token exchange, we cache the token server-side and
+ *   inject it into subsequent unauthenticated MCP requests. This is a
+ *   simple cache lookup — no request holding, no polling, no flags.
  */
 
 import { randomUUID } from "node:crypto";
@@ -8,15 +23,150 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import express from "express";
 import { createServer } from "./server.js";
-import { clearSession } from "./api.js";
+import { clearSession, setSessionCredentials, parseApiKey } from "./api.js";
+import { mountOAuth } from "./oauth.js";
 
 // Active sessions
 const transports = {};
 
+// MCP paths — Claude.ai uses "/" (connector URL), others may use "/mcp"
+const MCP_PATHS = ["/", "/mcp"];
+
+// Recently exchanged tokens — for auto-injection into MCP requests.
+// Key: token string, Value: { token, createdAt }
+const recentTokens = new Map();
+const TOKEN_TTL = 60 * 60 * 1000; // 60 minutes
+
 export function startHttpServer(port = 3100) {
   const app = express();
+  app.set("trust proxy", 1); // behind Cloudflare tunnel
+
+  // ─── Request logging ────────────────────────────────────────────
+  app.use((req, res, next) => {
+    const url = req.originalUrl || req.url;
+    const start = Date.now();
+    const auth = req.headers.authorization;
+    console.log(`[HTTP] >>> ${req.method} ${url}${auth ? ` Auth: ${auth.substring(0, 30)}...` : ""}${MCP_PATHS.includes(url.split("?")[0]) ? ` Accept: ${req.headers.accept || "(none)"}` : ""}`);
+    res.on("finish", () => {
+      console.log(`[HTTP] <<< ${req.method} ${url} → ${res.statusCode} (${Date.now() - start}ms)`);
+    });
+    next();
+  });
+
   app.use(express.json());
 
+  // ─── Fix Accept header for MCP endpoints ──────────────────────────
+  // Claude.ai may not send the required Accept header with text/event-stream.
+  // The MCP SDK requires it per spec, so we inject it if missing.
+  // Must patch both parsed headers AND rawHeaders since @hono/node-server
+  // reads from rawHeaders when converting to Web Standard Request.
+  for (const path of MCP_PATHS) {
+    app.use(path, (req, _res, next) => {
+      const accept = req.headers.accept || "";
+      if (req.method === "POST" && !accept.includes("text/event-stream")) {
+        const fixed = "application/json, text/event-stream";
+        req.headers.accept = fixed;
+        const idx = req.rawHeaders.findIndex((h) => h.toLowerCase() === "accept");
+        if (idx !== -1) {
+          req.rawHeaders[idx + 1] = fixed;
+        } else {
+          req.rawHeaders.push("Accept", fixed);
+        }
+      }
+      next();
+    });
+  }
+
+  // ─── OAuth setup ────────────────────────────────────────────────
+  const oauthDisabled = process.env.ATEAM_OAUTH_DISABLED === "1";
+  const baseUrl = process.env.ATEAM_BASE_URL || "https://mcp.ateam-ai.com";
+
+  let bearerMiddleware = null;
+  if (!oauthDisabled) {
+    // ─── Token capture middleware — MUST be BEFORE mcpAuthRouter ───
+    // Intercepts POST /token responses to cache access_tokens for
+    // auto-injection. Placed before mountOAuth so it can monkey-patch
+    // res.json() before the SDK's token handler sends the response.
+    app.use("/token", (req, res, next) => {
+      if (req.method !== "POST") return next();
+      const origJson = res.json.bind(res);
+      res.json = (data) => {
+        if (data && data.access_token && res.statusCode >= 200 && res.statusCode < 300) {
+          recentTokens.set(data.access_token, {
+            token: data.access_token,
+            createdAt: Date.now(),
+          });
+          console.log(`[Auth] Cached token from /token response (${recentTokens.size} active)`);
+          // Prune expired
+          for (const [k, v] of recentTokens) {
+            if (Date.now() - v.createdAt > TOKEN_TTL) recentTokens.delete(k);
+          }
+        }
+        return origJson(data);
+      };
+      next();
+    });
+
+    const oauth = mountOAuth(app, baseUrl);
+    bearerMiddleware = oauth.bearerMiddleware;
+
+    console.log(`  OAuth: enabled (issuer: ${baseUrl})`);
+  } else {
+    console.log("  OAuth: disabled (ATEAM_OAUTH_DISABLED=1)");
+  }
+
+  // ─── Token auto-injection middleware ────────────────────────────
+  // If a request has no Authorization header but we have a recently
+  // exchanged token, inject it. Simple cache lookup — never blocks.
+  const autoInjectToken = (req, _res, next) => {
+    if (req.headers.authorization) return next();
+    const token = getNewestToken();
+    if (token) {
+      req.headers.authorization = `Bearer ${token}`;
+      const idx = req.rawHeaders.findIndex((h) => h.toLowerCase() === "authorization");
+      if (idx !== -1) {
+        req.rawHeaders[idx + 1] = `Bearer ${token}`;
+      } else {
+        req.rawHeaders.push("Authorization", `Bearer ${token}`);
+      }
+      console.log(`[Auth] Auto-injected token into ${req.method} ${req.originalUrl || req.url}`);
+    }
+    next();
+  };
+
+  // Bearer auth middleware chains for MCP routes:
+  // - "/" (Claude.ai): strict OAuth — Bearer token required
+  // - "/mcp" (ChatGPT): optional OAuth — validate Bearer if present, pass through if not
+  const mcpAuthStrict = bearerMiddleware
+    ? [autoInjectToken, bearerMiddleware]
+    : [];
+
+  // Optional auth: if Bearer token present, validate it (sets req.auth for seedCredentials).
+  // If no token, let the request through — user can authenticate via ateam_auth tool.
+  const optionalBearerAuth = bearerMiddleware
+    ? (req, res, next) => {
+        if (!req.headers.authorization) return next();
+        bearerMiddleware(req, res, next);
+      }
+    : (_req, _res, next) => next();
+
+  const mcpAuthOptional = [autoInjectToken, optionalBearerAuth];
+
+  // ─── CORS — required for browser-based MCP clients ──────────────
+  for (const path of MCP_PATHS) {
+    app.use(path, (req, res, next) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "POST, GET, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "content-type, mcp-session-id, authorization");
+      res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+      if (req.method === "OPTIONS") {
+        res.status(204).end();
+        return;
+      }
+      next();
+    });
+  }
+
   // ─── Health check ─────────────────────────────────────────────
   app.get("/health", (_req, res) => {
     res.json({ ok: true, service: "ateam-mcp", transport: "http" });
@@ -28,21 +178,27 @@ export function startHttpServer(port = 3100) {
   });
 
   // ─── MCP POST — handle tool calls + initialize ───────────────
-  app.post("/mcp", async (req, res) => {
+  // Mounted at both "/" and "/mcp" for Claude.ai compatibility
+  const mcpPost = async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
 
     try {
       let transport;
 
       if (sessionId && transports[sessionId]) {
-        // Reuse existing session
+        // Reuse existing session — seed credentials if Bearer token present
         transport = transports[sessionId];
+        seedCredentials(req, sessionId);
       } else if (!sessionId && isInitializeRequest(req.body)) {
         // New session — generate ID upfront so we can bind it to the server
         const newSessionId = randomUUID();
 
+        // Seed credentials from OAuth Bearer token before server starts
+        seedCredentials(req, newSessionId);
+
         transport = new StreamableHTTPServerTransport({
           sessionIdGenerator: () => newSessionId,
+          enableJsonResponse: true,
           onsessioninitialized: (sid) => {
             transports[sid] = transport;
           },
@@ -80,32 +236,57 @@ export function startHttpServer(port = 3100) {
         });
       }
     }
-  });
+  };
 
   // ─── MCP GET — SSE stream for notifications ──────────────────
-  app.get("/mcp", async (req, res) => {
+  const mcpGet = async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     if (!sessionId || !transports[sessionId]) {
-      res.status(400).send("Invalid or missing session ID");
+      // No session: return health-check JSON (for ChatGPT connector validation)
+      res.json({ ok: true, service: "ateam-mcp", transport: "http" });
       return;
     }
     await transports[sessionId].handleRequest(req, res);
-  });
+  };
 
   // ─── MCP DELETE — session termination ────────────────────────
-  app.delete("/mcp", async (req, res) => {
+  const mcpDelete = async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     if (!sessionId || !transports[sessionId]) {
       res.status(400).send("Invalid or missing session ID");
       return;
     }
     await transports[sessionId].handleRequest(req, res);
+  };
+
+  // Mount MCP handlers at both "/" and "/mcp"
+  // "/" (Claude.ai): strict OAuth — requires Bearer token
+  // "/mcp" (ChatGPT): optional auth — accepts OAuth OR ateam_auth tool
+  for (const path of MCP_PATHS) {
+    const auth = path === "/" ? mcpAuthStrict : mcpAuthOptional;
+    app.post(path, ...auth, mcpPost);
+    app.get(path, ...auth, mcpGet);
+    app.delete(path, ...auth, mcpDelete);
+  }
+
+  // ─── Catch-all: log unhandled requests ──────────────────────────
+  app.use((req, res, next) => {
+    console.log(`[HTTP] UNMATCHED: ${req.method} ${req.originalUrl || req.url}`);
+    if (!res.headersSent) res.status(404).json({ error: "Not found" });
+  });
+
+  // ─── Error handler ──────────────────────────────────────────────
+  app.use((err, req, res, next) => {
+    console.error(`[HTTP] ERROR in ${req.method} ${req.originalUrl}:`, err.message || err);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Internal server error" });
+    }
   });
 
   // ─── Start ────────────────────────────────────────────────────
   app.listen(port, "0.0.0.0", () => {
     console.log(`ateam-mcp HTTP server listening on port ${port}`);
-    console.log(`  MCP endpoint: http://localhost:${port}/mcp`);
+    console.log(`  MCP endpoint: http://localhost:${port}/mcp (also at /)`);
     console.log(`  Health check: http://localhost:${port}/health`);
   });
 
@@ -121,3 +302,27 @@ export function startHttpServer(port = 3100) {
     process.exit(0);
   });
 }
+
+/** Returns the most recently issued non-expired token, or null. */
+function getNewestToken() {
+  let newest = null;
+  for (const [, entry] of recentTokens) {
+    if (Date.now() - entry.createdAt > TOKEN_TTL) continue;
+    if (!newest || entry.createdAt > newest.createdAt) newest = entry;
+  }
+  return newest?.token || null;
+}
+
+/**
+ * If the request has a validated Bearer token (set by requireBearerAuth),
+ * auto-seed session credentials so the user doesn't need to call ateam_auth.
+ */
+function seedCredentials(req, sessionId) {
+  const token = req.auth?.token;
+  if (!token) return;
+
+  const parsed = parseApiKey(token);
+  if (parsed.isValid) {
+    setSessionCredentials(sessionId, { tenant: parsed.tenant, apiKey: token });
+  }
+}

package/src/index.js

@@ -17,7 +17,7 @@ if (httpFlag) {
   // ─── HTTP transport (for ChatGPT, remote clients) ─────────────
   const { startHttpServer } = await import("./http.js");
   const portArg = process.argv[process.argv.indexOf("--http") + 1];
-  const port = portArg && !portArg.startsWith("-") ? parseInt(portArg, 10) : 3100;
+  const port = portArg && !portArg.startsWith("-") ? parseInt(portArg, 10) : parseInt(process.env.PORT, 10) || 3100;
   startHttpServer(port);
 } else {
   // ─── Stdio transport (for Claude Code, Cursor, Windsurf, VS Code) ──