@tinycloud/mcp 0.8.3-beta.6 → 0.8.3-beta.8

package/dist/http-cli.js

@@ -33,7 +33,9 @@ function createOpenKeyTokenVerifier(config) {
           issuer: config.issuer,
           audience: config.audience
         });
-        return authInfo(token, payload, config);
+        const info = authInfo(token, payload, config);
+        if (config.tokenStatus !== void 0) await requireUsableStatus(config.tokenStatus, token);
+        return info;
       } catch (error) {
         if (error instanceof errors.JOSEError) {
           throw new OAuthError(OAuthErrorCode.InvalidToken, "The OpenKey access token is invalid.");
@@ -43,6 +45,16 @@ function createOpenKeyTokenVerifier(config) {
     }
   };
 }
+async function requireUsableStatus(checker, token) {
+  const status = await checker.tokenStatus(token);
+  if (status === "active") return;
+  if (status === "inactive") {
+    throw new OAuthError(OAuthErrorCode.InvalidToken, "The OpenKey access token is no longer active.");
+  }
+  if (!checker.toleratesUnknown(token)) {
+    throw new OAuthError(OAuthErrorCode.ServerError, "The OpenKey access token status is unavailable.");
+  }
+}
 async function loadOAuthMetadata(metadataUrl) {
   const response = await fetch(metadataUrl, {
     headers: { accept: "application/json" },
@@ -108,6 +120,150 @@ function firstString(...values) {
   return values.find((value) => typeof value === "string" && value.length > 0);
 }
 
+// src/token-status.ts
+import { createHash } from "crypto";
+import { decodeJwt } from "jose";
+var ACTIVE_CACHE_MS = 3e4;
+var DEFAULT_TOKEN_LIFETIME_SECONDS = 300;
+var DEFAULT_TIMEOUT_MS = 3e3;
+var MAX_CACHED_TOKENS = 1e4;
+function createTokenStatusChecker(config) {
+  const doFetch = config.fetch ?? fetch;
+  const clock = config.now ?? Date.now;
+  const log = config.log ?? ((message) => void process.stderr.write(`[tinycloud-mcp-http] ${message}
+`));
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const inactive = /* @__PURE__ */ new Map();
+  const active = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  const confirmedActive = /* @__PURE__ */ new Map();
+  let credentialsRefused = false;
+  async function introspect(token) {
+    const headers = {
+      accept: "application/json",
+      "content-type": "application/x-www-form-urlencoded"
+    };
+    const body = new URLSearchParams({ token, token_type_hint: "access_token" });
+    if (config.authMethod === "basic") {
+      const encode = (value) => encodeURIComponent(value).replace(/%20/g, "+");
+      const credentials = `${encode(config.clientId)}:${encode(config.clientSecret)}`;
+      headers.authorization = `Basic ${Buffer.from(credentials).toString("base64")}`;
+    } else {
+      body.set("client_id", config.clientId);
+      body.set("client_secret", config.clientSecret);
+    }
+    try {
+      const response = await doFetch(config.endpoint, {
+        method: "POST",
+        headers,
+        body,
+        redirect: "error",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (response.status === 401) return "credentials";
+      if (response.status !== 200) return "unknown";
+      const result = await response.json();
+      if (typeof result !== "object" || result === null || !("active" in result)) return "unknown";
+      if (result.active === false) return "inactive";
+      if (result.active !== true) return "unknown";
+      return answerMatchesToken(Object.fromEntries(Object.entries(result)), token, config.resourceUrl) ? "active" : "mismatch";
+    } catch {
+      return "unknown";
+    }
+  }
+  async function query(key, token) {
+    const outcome = await introspect(token);
+    if (outcome === "credentials") {
+      if (!credentialsRefused) {
+        log("OpenKey token introspection refused the MCP client credentials (401); token checks fail closed until it accepts them.");
+      }
+      credentialsRefused = true;
+      return "unknown";
+    }
+    if (outcome === "unknown") return outcome;
+    const now = clock();
+    prune(now);
+    if (outcome === "mismatch") {
+      inactive.set(key, tokenExpiryMs(token, now));
+      confirmedActive.delete(key);
+      return "inactive";
+    }
+    credentialsRefused = false;
+    if (outcome === "inactive") {
+      inactive.set(key, tokenExpiryMs(token, now));
+      confirmedActive.delete(key);
+    } else {
+      active.set(key, now + ACTIVE_CACHE_MS);
+      confirmedActive.delete(key);
+      confirmedActive.set(key, { at: now, expiresAt: tokenExpiryMs(token, now) });
+    }
+    return outcome;
+  }
+  function prune(now) {
+    for (const [key, until] of active) if (until <= now) active.delete(key);
+    for (const [key, until] of inactive) if (until <= now) inactive.delete(key);
+    for (const [key, entry] of confirmedActive) if (entry.expiresAt <= now) confirmedActive.delete(key);
+    for (const cache of [active, inactive, confirmedActive]) {
+      while (cache.size >= MAX_CACHED_TOKENS) {
+        const oldest = cache.keys().next().value;
+        if (oldest === void 0) break;
+        cache.delete(oldest);
+      }
+    }
+  }
+  return {
+    async tokenStatus(token) {
+      const key = createHash("sha256").update(token).digest("hex");
+      const now = clock();
+      const inactiveUntil = inactive.get(key);
+      if (inactiveUntil !== void 0 && inactiveUntil > now) return "inactive";
+      const activeUntil = active.get(key);
+      if (activeUntil !== void 0 && activeUntil > now) return "active";
+      const pending = inFlight.get(key);
+      if (pending !== void 0) return pending;
+      const asking = query(key, token).finally(() => inFlight.delete(key));
+      inFlight.set(key, asking);
+      return asking;
+    },
+    toleratesUnknown(token) {
+      if (credentialsRefused) return false;
+      const confirmed = confirmedActive.get(createHash("sha256").update(token).digest("hex"));
+      if (confirmed === void 0) return false;
+      const now = clock();
+      return confirmed.expiresAt > now && now - confirmed.at < tokenLifetimeSeconds(token) * 1e3;
+    }
+  };
+}
+function answerMatchesToken(answer, token, resourceUrl) {
+  const jwt = claims(token);
+  if (typeof jwt.sub === "string" && answer.sub !== jwt.sub) return false;
+  const jwtClient = [jwt.azp, jwt.client_id].find((value) => typeof value === "string" && value.length > 0);
+  if (jwtClient !== void 0 && answer.client_id !== jwtClient) return false;
+  if (jwt.aud === void 0) return true;
+  const answered = audienceList(answer.aud);
+  const signed = audienceList(jwt.aud);
+  return answered.length > 0 && answered.includes(resourceUrl) && answered.every((entry) => signed.includes(entry));
+}
+function audienceList(value) {
+  const list = typeof value === "string" ? [value] : value;
+  return Array.isArray(list) && list.every((entry) => typeof entry === "string") ? list : [];
+}
+function tokenExpiryMs(token, now) {
+  const exp = claims(token).exp;
+  return typeof exp === "number" ? exp * 1e3 : now + DEFAULT_TOKEN_LIFETIME_SECONDS * 1e3;
+}
+function tokenLifetimeSeconds(token) {
+  const { exp, iat } = claims(token);
+  return typeof exp === "number" && typeof iat === "number" && exp > iat ? exp - iat : DEFAULT_TOKEN_LIFETIME_SECONDS;
+}
+function claims(token) {
+  try {
+    return decodeJwt(token);
+  } catch {
+    return {};
+  }
+}
+
 // src/logging.ts
 function logToolCall(tool, code, startedAt, replayedGrants) {
   process.stderr.write(`${JSON.stringify({
@@ -1394,7 +1550,7 @@ function outcomeCode(result) {
 // package.json
 var package_default = {
   name: "@tinycloud/mcp",
-  version: "0.8.3-beta.6",
+  version: "0.8.3-beta.8",
   description: "TinyCloud delegated operations MCP server",
   keywords: [
     "tinycloud",
@@ -1465,9 +1621,9 @@ var package_default = {
   dependencies: {
     "@modelcontextprotocol/node": "2.0.0-beta.5",
     "@modelcontextprotocol/server": "2.0.0-beta.5",
-    "@tinycloud/node-sdk": "3.8.0-beta.5",
+    "@tinycloud/node-sdk": "3.8.0-beta.6",
     "@tinycloud/node-sdk-wasm": "1.7.8",
-    "@tinycloud/operations": "0.7.7-beta.6",
+    "@tinycloud/operations": "0.7.7-beta.7",
     jose: "6.2.4"
   },
   devDependencies: {
@@ -1494,12 +1650,13 @@ var REQUIRED_SCOPE = "tinycloud:mcp";
 function createHostedMcpApp(config) {
   const resourceUrl = canonicalResourceUrl(config.publicUrl);
   const pluginUrl = new URL("./chatgpt/mcp", resourceUrl);
-  const hosted = createHostedSurface(config, resourceUrl, "hosted");
+  const statusFor = (resource) => config.introspection === void 0 ? void 0 : createTokenStatusChecker({ ...config.introspection, resourceUrl: resource.toString() });
+  const hosted = createHostedSurface(config, resourceUrl, "hosted", statusFor(resourceUrl));
   const plugin = createHostedSurface({
     ...config,
     stateDir: join3(config.stateDir, "chatgpt"),
     approvalPath: new URL("./connect", pluginUrl).pathname
-  }, pluginUrl, "public");
+  }, pluginUrl, "public", statusFor(pluginUrl));
   const pluginPaths = {
     [pluginUrl.pathname]: true,
     [new URL("./connect", pluginUrl).pathname]: true,
@@ -1513,7 +1670,7 @@ function createHostedMcpApp(config) {
     }
   };
 }
-function createHostedSurface(config, resourceUrl, surface) {
+function createHostedSurface(config, resourceUrl, surface, tokenStatus) {
   const connectPath = config.approvalPath ?? "/connect";
   const callbackPath = `${connectPath}/callback`;
   const issuer = String(config.oauthMetadata.issuer);
@@ -1522,7 +1679,8 @@ function createHostedSurface(config, resourceUrl, surface) {
     issuer,
     audience: resourceUrl.toString(),
     jwksUri,
-    requiredScope: REQUIRED_SCOPE
+    requiredScope: REQUIRED_SCOPE,
+    ...tokenStatus === void 0 ? {} : { tokenStatus }
   });
   const resourceMetadataUrl = getOAuthProtectedResourceMetadataUrl(resourceUrl);
   const authenticate = requireBearerAuth({
@@ -1774,7 +1932,13 @@ async function main() {
     approvalTtlSeconds: positiveInteger(process.env.TC_MCP_APPROVAL_TTL_SECONDS, 300),
     delegationExpiry: process.env.TC_MCP_DELEGATION_EXPIRY ?? "1h",
     allowedOrigins: commaList(process.env.TC_MCP_ALLOWED_ORIGINS),
-    oauthMetadata
+    oauthMetadata,
+    introspection: {
+      endpoint: requiredUrl("TC_MCP_INTROSPECTION_URL").toString(),
+      clientId: requiredString("TC_MCP_INTROSPECTION_CLIENT_ID"),
+      clientSecret: requiredString("TC_MCP_INTROSPECTION_CLIENT_SECRET"),
+      authMethod: introspectionAuthMethod(process.env.TC_MCP_INTROSPECTION_AUTH_METHOD)
+    }
   });
   const nodeHandler = toNodeHandler(app);
   const server = createServer(nodeHandler);
@@ -1807,6 +1971,11 @@ function requiredAbsolutePath(name) {
   if (!isAbsolute(value)) throw new Error(`${name} must be an absolute path.`);
   return resolve(value);
 }
+function introspectionAuthMethod(value) {
+  if (value === void 0 || value === "basic") return "basic";
+  if (value === "post") return "post";
+  throw new Error("TC_MCP_INTROSPECTION_AUTH_METHOD must be basic or post.");
+}
 function positiveInteger(value, fallback) {
   if (value === void 0) return fallback;
   const parsed = Number(value);