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

package/dist/http.cjs

@@ -41,7 +41,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 import_jose.errors.JOSEError) {
           throw new import_server.OAuthError(import_server.OAuthErrorCode.InvalidToken, "The OpenKey access token is invalid.");
@@ -51,6 +53,16 @@ function createOpenKeyTokenVerifier(config) {
     }
   };
 }
+async function requireUsableStatus(checker, token) {
+  const status = await checker.tokenStatus(token);
+  if (status === "active") return;
+  if (status === "inactive") {
+    throw new import_server.OAuthError(import_server.OAuthErrorCode.InvalidToken, "The OpenKey access token is no longer active.");
+  }
+  if (!checker.toleratesUnknown(token)) {
+    throw new import_server.OAuthError(import_server.OAuthErrorCode.ServerError, "The OpenKey access token status is unavailable.");
+  }
+}
 function authInfo(token, payload, config) {
   if (typeof payload.sub !== "string" || payload.sub.length === 0) {
     throw new import_server.OAuthError(import_server.OAuthErrorCode.InvalidToken, "The OpenKey access token does not identify a subject.");
@@ -104,6 +116,150 @@ function firstString(...values) {
   return values.find((value) => typeof value === "string" && value.length > 0);
 }
 
+// src/token-status.ts
+var import_node_crypto = require("crypto");
+var import_jose2 = require("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 = (0, import_node_crypto.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((0, import_node_crypto.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 (0, import_jose2.decodeJwt)(token);
+  } catch {
+    return {};
+  }
+}
+
 // src/logging.ts
 function logToolCall(tool, code, startedAt, replayedGrants) {
   process.stderr.write(`${JSON.stringify({
@@ -116,7 +272,7 @@ function logToolCall(tool, code, startedAt, replayedGrants) {
 }
 
 // src/remote-store.ts
-var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
 var import_node_sdk2 = require("@tinycloud/node-sdk");
@@ -708,7 +864,7 @@ var RemoteTenantStore = class {
       { tenantId, approvalEpoch: tenant.approvalEpoch, kind, requestId, permissions, ownerDids }
     );
     if (reusable !== void 0) return reusable;
-    const nonce = (0, import_node_crypto.randomBytes)(24).toString("base64url");
+    const nonce = (0, import_node_crypto2.randomBytes)(24).toString("base64url");
     const created = Date.now();
     const pending = {
       version: 1,
@@ -733,7 +889,7 @@ var RemoteTenantStore = class {
     const expected = this.#signState(tenantId, nonce);
     const supplied = Buffer.from(signature, "base64url");
     const expectedBytes = Buffer.from(expected, "base64url");
-    if (supplied.length !== expectedBytes.length || !(0, import_node_crypto.timingSafeEqual)(supplied, expectedBytes)) {
+    if (supplied.length !== expectedBytes.length || !(0, import_node_crypto2.timingSafeEqual)(supplied, expectedBytes)) {
       throw new ApprovalRequestError("state_invalid", "Approval state is invalid.");
     }
     const stateRoot = (0, import_node_path.join)(this.#config.stateDir, "tenants", tenantId);
@@ -785,10 +941,10 @@ var RemoteTenantStore = class {
     return url.toString();
   }
   #tenantId(subject) {
-    return (0, import_node_crypto.createHmac)("sha256", this.#config.stateSecret).update(`tenant:${subject}`).digest("hex");
+    return (0, import_node_crypto2.createHmac)("sha256", this.#config.stateSecret).update(`tenant:${subject}`).digest("hex");
   }
   #signState(tenantId, nonce) {
-    return (0, import_node_crypto.createHmac)("sha256", this.#config.stateSecret).update(`approval:${tenantId}:${nonce}`).digest("base64url");
+    return (0, import_node_crypto2.createHmac)("sha256", this.#config.stateSecret).update(`approval:${tenantId}:${nonce}`).digest("base64url");
   }
   #profilePath(stateRoot) {
     return (0, import_node_path.join)(stateRoot, ".tinycloud", "profiles", PROFILE, "profile.json");
@@ -890,7 +1046,7 @@ async function secureDirectory(path) {
 async function secureWrite(path, value) {
   const directory = (0, import_node_path.dirname)(path);
   await secureDirectory(directory);
-  const temporary = `${path}.${process.pid}.${(0, import_node_crypto.randomBytes)(8).toString("hex")}.tmp`;
+  const temporary = `${path}.${process.pid}.${(0, import_node_crypto2.randomBytes)(8).toString("hex")}.tmp`;
   await (0, import_promises.writeFile)(temporary, `${JSON.stringify(value, jsonReplacer, 2)}
 `, { mode: 384 });
   await (0, import_promises.rename)(temporary, path);
@@ -1382,7 +1538,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",
@@ -1453,9 +1609,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: {
@@ -1482,12 +1638,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: (0, import_node_path3.join)(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,
@@ -1501,7 +1658,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);
@@ -1510,7 +1667,8 @@ function createHostedSurface(config, resourceUrl, surface) {
     issuer,
     audience: resourceUrl.toString(),
     jwksUri,
-    requiredScope: REQUIRED_SCOPE
+    requiredScope: REQUIRED_SCOPE,
+    ...tokenStatus === void 0 ? {} : { tokenStatus }
   });
   const resourceMetadataUrl = (0, import_server4.getOAuthProtectedResourceMetadataUrl)(resourceUrl);
   const authenticate = (0, import_server4.requireBearerAuth)({