@dbx-tools/teams 0.6.72 → 0.6.74

package/README.md

@@ -167,7 +167,7 @@ environment variable.
   builder targets. Defaults to `1.5` (what Teams supports).
 - `webhookUrl` / `TEAMS_WEBHOOK_URL` - optional Teams incoming-webhook URL. When
   unset, posting is disabled and the plugin only builds cards for a UI to
-  render. A value that is not an absolute URL fails config resolution.
+  render. A value that is not an absolute HTTPS URL fails config resolution.
 - `agentPlugin` / `TEAMS_AGENT_PLUGIN` - registered name of the sibling plugin
   whose agents answer a conversation turn. Defaults to `mastra`; set it when the
   Mastra plugin is mounted under a `config.name` override.

package/lib/src/auth.js

@@ -78,7 +78,7 @@ export const resetTeamsAuth = () => {
     keySet = undefined;
     jwksUri = undefined;
     keySetSource = undefined;
-    tokenCache = undefined;
+    tokenCache.clear();
 };
 /**
  * Discover the signing JWKS URI from the Bot Framework OpenID metadata.
@@ -157,29 +157,30 @@ const bearerToken = (authorization) => {
         return null;
     return value.trim() || null;
 };
-let tokenCache;
-/**
- * Fetch (or reuse) a Connector API access token for the bot's own app
- * registration.
- *
- * Cached until shortly before expiry: a Connector token is valid for ~1h, and
- * re-fetching per reply would add a round trip to every turn.
- */
-export const connectorToken = async (options) => {
-    const now = Date.now();
-    if (tokenCache && tokenCache.expiresAt > now)
-        return tokenCache.token;
+const tokenCache = new Map();
+/** Wait for a shared refresh while preserving per-caller cancellation. */
+function waitForToken(refresh, signal) {
+    if (!signal)
+        return refresh;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason ?? new Error("Connector token request aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+        refresh.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+    });
+}
+/** Fetch one Connector token without binding the shared refresh to one caller's signal. */
+async function refreshConnectorToken(options, tenant, now) {
     const body = new URLSearchParams({
         grant_type: "client_credentials",
         client_id: options.appId,
         client_secret: options.appPassword,
         scope: CONNECTOR_SCOPE,
     });
-    const response = await fetch(LOGIN_TOKEN_URL(options.appTenantId ?? MULTI_TENANT), {
+    const response = await fetch(LOGIN_TOKEN_URL(tenant), {
         method: "POST",
         headers: { "content-type": "application/x-www-form-urlencoded" },
         body,
-        ...(options.signal ? { signal: options.signal } : {}),
     });
     if (!response.ok) {
         const detail = await response.text().catch(() => "");
@@ -190,9 +191,36 @@ export const connectorToken = async (options) => {
     if (!token)
         throw new Error("teams: token response carried no access_token");
     const expiresIn = typeof payload.expires_in === "number" ? payload.expires_in : 3600;
-    tokenCache = { token, expiresAt: now + expiresIn * 1000 - TOKEN_SKEW_MS };
     logger.debug("connector token refreshed", { expiresIn });
-    return token;
+    return { token, expiresAt: now + expiresIn * 1000 - TOKEN_SKEW_MS };
+}
+/**
+ * Fetch (or reuse) a Connector API access token for the bot's own app
+ * registration.
+ *
+ * Cached until shortly before expiry: a Connector token is valid for ~1h, and
+ * re-fetching per reply would add a round trip to every turn.
+ */
+export const connectorToken = async (options) => {
+    const tenant = options.appTenantId ?? MULTI_TENANT;
+    const cacheKey = `${tenant}\0${options.appId}`;
+    const now = Date.now();
+    let entry = tokenCache.get(cacheKey);
+    if (!entry) {
+        entry = {};
+        tokenCache.set(cacheKey, entry);
+    }
+    if (entry.value && entry.value.expiresAt > now)
+        return entry.value.token;
+    entry.refresh ??= refreshConnectorToken(options, tenant, now)
+        .then((value) => {
+        entry.value = value;
+        return value;
+    })
+        .finally(() => {
+        entry.refresh = undefined;
+    });
+    return (await waitForToken(entry.refresh, options.signal)).token;
 };
 /**
  * Host suffixes replies may be sent to when the token pins no `serviceUrl`.
@@ -229,4 +257,4 @@ export const isAllowedServiceUrl = (serviceUrl, tokenServiceUrl) => {
         return false;
     }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Inbound and outbound authentication for the Teams messaging endpoint.\n *\n * `POST /api/teams/messages` is a PUBLIC URL - Azure Bot Service calls it from\n * the internet, so it cannot sit behind AppKit's OBO headers or a workspace\n * login. Its only trust boundary is the JWT the Bot Service signs each request\n * with, which is what this module verifies:\n *\n *   1. fetch the Bot Framework OpenID metadata to discover the signing JWKS;\n *   2. verify the token's signature against that key set;\n *   3. check `issuer` is a known Bot Service issuer and `audience` is exactly\n *      this bot's app id.\n *\n * All three matter. Skipping (3) is the classic bot vulnerability: a token the\n * Bot Service legitimately issued for a DIFFERENT bot still verifies against the\n * same JWKS, so without an audience check anyone with their own bot could drive\n * this agent.\n *\n * The outbound half is the reverse: replies go to the Connector API, which needs\n * a client-credentials token for the bot's own app registration. Both key sets\n * and tokens are cached, since a busy channel would otherwise re-fetch metadata\n * on every turn.\n *\n * @module\n */\n\nimport { error, log } from \"@dbx-tools/shared-core\";\nimport { createRemoteJWKSet, jwtVerify, type JWTPayload } from \"jose\";\n\n/**\n * OpenID metadata document for tokens the Bot Service sends a bot in the public\n * cloud. The JWKS URI is read from this document rather than hard-coded so a key\n * rotation on Microsoft's side needs no release here.\n *\n * Overridable per call ({@link VerifyOptions.metadataUrl}) because a sovereign\n * cloud (GCC High / DoD) publishes its own metadata endpoint - and because it\n * makes the verifier testable against a local key set.\n */\nexport const BOT_OPENID_METADATA =\n  \"https://login.botframework.com/v1/.well-known/openidconfiguration\";\n\n/**\n * Accepted `iss` values on an inbound token.\n *\n * The Bot Service has issued tokens under several issuers across channel and\n * tenant configurations, and a single-tenant bot receives the v2 Entra issuer\n * with its own tenant id spliced in (handled by {@link isTrustedIssuer}). The\n * fixed set covers the channel-issued cases.\n */\nconst TRUSTED_ISSUERS = [\n  \"https://api.botframework.com\",\n  \"https://sts.windows.net/d6d49420-f39b-4df7-a1dc-d59a935871db/\",\n  \"https://login.microsoftonline.com/d6d49420-f39b-4df7-a1dc-d59a935871db/v2.0\",\n] as const;\n\n/** Token endpoint issuing the Connector credentials an outbound reply uses. */\nconst LOGIN_TOKEN_URL = (tenant: string) =>\n  `https://login.microsoftonline.com/${tenant}/oauth2/v2.0/token`;\n\n/**\n * Scope requested for a Connector token. `.default` asks for the app's\n * statically configured permissions, which is what a bot registration grants.\n */\nconst CONNECTOR_SCOPE = \"https://api.botframework.com/.default\";\n\n/** Tenant used for a multi-tenant bot, which has no tenant of its own. */\nconst MULTI_TENANT = \"botframework.com\";\n\n/**\n * Refresh an access token this many milliseconds BEFORE it actually expires, so\n * a token never expires mid-flight between the check and the Connector call.\n */\nconst TOKEN_SKEW_MS = 60_000;\n\nconst logger = log.logger(\"teams:auth\");\n\n/**\n * Lazily-created, cached remote key set. `createRemoteJWKSet` handles its own\n * key caching and rotation (re-fetching only on an unknown `kid`), so this is\n * created once per process rather than per request.\n */\nlet keySet: ReturnType<typeof createRemoteJWKSet> | undefined;\n\n/** Cached JWKS URI discovered from the OpenID metadata document, keyed by metadata URL. */\nlet jwksUri: string | undefined;\n\n/** Metadata URL the cached key set was built from, so an override busts the cache. */\nlet keySetSource: string | undefined;\n\n/** Reset cached auth state. Test seam; not part of the public contract. */\nexport const resetTeamsAuth = (): void => {\n  keySet = undefined;\n  jwksUri = undefined;\n  keySetSource = undefined;\n  tokenCache = undefined;\n};\n\n/**\n * Discover the signing JWKS URI from the Bot Framework OpenID metadata.\n *\n * Cached for the life of the process: it is a stable pointer, and the key\n * rotation that actually matters happens inside the key set it names.\n */\nconst discoverJwksUri = async (metadataUrl: string, signal?: AbortSignal): Promise<string> => {\n  if (jwksUri && keySetSource === metadataUrl) return jwksUri;\n  const response = await fetch(metadataUrl, { ...(signal ? { signal } : {}) });\n  if (!response.ok) {\n    throw new Error(`teams: could not fetch Bot Framework OpenID metadata (${response.status})`);\n  }\n  const metadata = (await response.json()) as { jwks_uri?: unknown };\n  const uri = typeof metadata.jwks_uri === \"string\" ? metadata.jwks_uri : null;\n  if (!uri) throw new Error(\"teams: Bot Framework OpenID metadata carried no jwks_uri\");\n  jwksUri = uri;\n  keySetSource = metadataUrl;\n  return uri;\n};\n\n/** The key set for the discovered JWKS URI, created once and reused. */\nconst signingKeys = async (\n  metadataUrl: string,\n  signal?: AbortSignal,\n): Promise<ReturnType<typeof createRemoteJWKSet>> => {\n  if (keySet && keySetSource === metadataUrl) return keySet;\n  const uri = await discoverJwksUri(metadataUrl, signal);\n  keySet = createRemoteJWKSet(new URL(uri));\n  return keySet;\n};\n\n/**\n * Whether `issuer` is one this bot accepts.\n *\n * A single-tenant bot receives tokens issued by its OWN tenant, so the\n * configured tenant's v2 issuer is accepted in addition to the fixed channel\n * issuers.\n */\nconst isTrustedIssuer = (issuer: string | undefined, tenantId?: string): boolean => {\n  if (!issuer) return false;\n  if ((TRUSTED_ISSUERS as readonly string[]).includes(issuer)) return true;\n  if (!tenantId) return false;\n  return (\n    issuer === `https://login.microsoftonline.com/${tenantId}/v2.0` ||\n    issuer === `https://sts.windows.net/${tenantId}/`\n  );\n};\n\n/** A verified inbound Bot Framework token. */\nexport interface VerifiedBotToken {\n  /** The token's claims, after signature / issuer / audience validation. */\n  claims: JWTPayload;\n  /**\n   * The `serviceUrl` the token was issued for, when it carries one. Bot Service\n   * tokens include this claim; comparing it to the activity's `serviceUrl` is\n   * what stops a valid token being replayed to redirect replies elsewhere.\n   */\n  serviceUrl?: string;\n}\n\n/** Options for {@link verifyBotToken}. */\nexport interface VerifyOptions {\n  /** The bot's app id; the ONLY audience an inbound token may carry. */\n  appId: string;\n  /** Tenant of a single-tenant bot, whose own issuer is then also accepted. */\n  appTenantId?: string;\n  /**\n   * OpenID metadata document naming the signing key set. Defaults to\n   * {@link BOT_OPENID_METADATA}; override for a sovereign cloud.\n   */\n  metadataUrl?: string;\n  /** Cancels the metadata / JWKS fetch with the request. */\n  signal?: AbortSignal;\n}\n\n/**\n * Verify the `Authorization` header on an inbound Bot Service request.\n *\n * Rejects (by throwing) a missing / malformed header, a bad signature, an\n * untrusted issuer, or an audience that is not this bot's `appId`. The caller\n * turns a throw into a 401 - never into a processed activity.\n */\nexport const verifyBotToken = async (\n  authorization: string | undefined,\n  options: VerifyOptions,\n): Promise<VerifiedBotToken> => {\n  const token = bearerToken(authorization);\n  if (!token) throw new Error(\"teams: request carried no bearer token\");\n\n  const keys = await signingKeys(options.metadataUrl ?? BOT_OPENID_METADATA, options.signal);\n  // `audience` is enforced by the verifier itself: a token the Bot Service\n  // issued for someone else's bot verifies against this same JWKS, so the\n  // audience check - not the signature - is what binds a request to THIS bot.\n  const { payload } = await jwtVerify(token, keys, { audience: options.appId });\n\n  if (!isTrustedIssuer(payload.iss, options.appTenantId)) {\n    throw new Error(`teams: untrusted token issuer '${payload.iss ?? \"none\"}'`);\n  }\n\n  const serviceUrl = typeof payload.serviceurl === \"string\" ? payload.serviceurl : undefined;\n  return { claims: payload, ...(serviceUrl ? { serviceUrl } : {}) };\n};\n\n/** Read the bearer value out of an `Authorization` header. */\nconst bearerToken = (authorization: string | undefined): string | null => {\n  if (!authorization) return null;\n  const [scheme, value] = authorization.split(/\\s+/, 2);\n  if (!value || scheme?.toLowerCase() !== \"bearer\") return null;\n  return value.trim() || null;\n};\n\n/** A cached Connector access token and the moment it stops being usable. */\ninterface CachedToken {\n  token: string;\n  expiresAt: number;\n}\n\nlet tokenCache: CachedToken | undefined;\n\n/**\n * Fetch (or reuse) a Connector API access token for the bot's own app\n * registration.\n *\n * Cached until shortly before expiry: a Connector token is valid for ~1h, and\n * re-fetching per reply would add a round trip to every turn.\n */\nexport const connectorToken = async (options: {\n  appId: string;\n  appPassword: string;\n  appTenantId?: string;\n  signal?: AbortSignal;\n}): Promise<string> => {\n  const now = Date.now();\n  if (tokenCache && tokenCache.expiresAt > now) return tokenCache.token;\n\n  const body = new URLSearchParams({\n    grant_type: \"client_credentials\",\n    client_id: options.appId,\n    client_secret: options.appPassword,\n    scope: CONNECTOR_SCOPE,\n  });\n  const response = await fetch(LOGIN_TOKEN_URL(options.appTenantId ?? MULTI_TENANT), {\n    method: \"POST\",\n    headers: { \"content-type\": \"application/x-www-form-urlencoded\" },\n    body,\n    ...(options.signal ? { signal: options.signal } : {}),\n  });\n  if (!response.ok) {\n    const detail = await response.text().catch(() => \"\");\n    throw new Error(\n      `teams: could not obtain a Connector token (${response.status}) ${detail}`.trim(),\n    );\n  }\n  const payload = (await response.json()) as { access_token?: unknown; expires_in?: unknown };\n  const token = typeof payload.access_token === \"string\" ? payload.access_token : null;\n  if (!token) throw new Error(\"teams: token response carried no access_token\");\n  const expiresIn = typeof payload.expires_in === \"number\" ? payload.expires_in : 3600;\n  tokenCache = { token, expiresAt: now + expiresIn * 1000 - TOKEN_SKEW_MS };\n  logger.debug(\"connector token refreshed\", { expiresIn });\n  return token;\n};\n\n/**\n * Host suffixes replies may be sent to when the token pins no `serviceUrl`.\n *\n * `smba.trafficmanager.net` is the one that matters in practice: that is where\n * Teams itself serves the Connector API from (per-region, e.g.\n * `https://smba.trafficmanager.net/amer/`), so omitting it would reject every\n * real Teams reply. Compared as dot-prefixed suffixes (or exact matches) so a\n * lookalike host like `botframework.com.attacker.example` cannot pass.\n */\nconst ALLOWED_SERVICE_HOSTS = [\"botframework.com\", \"trafficmanager.net\", \"microsoft.com\"] as const;\n\n/**\n * Whether `serviceUrl` is one replies may be sent to.\n *\n * Only ever the host the verified token was issued for. A Bot Service token is a\n * bearer credential, so honoring the `serviceUrl` from the request BODY would\n * let a replayed token point the bot's authenticated replies (and its token) at\n * an attacker-controlled host. When the token carries no `serviceurl` claim the\n * body value is accepted but restricted to Microsoft's own domains.\n */\nexport const isAllowedServiceUrl = (serviceUrl: string, tokenServiceUrl?: string): boolean => {\n  const normalize = (value: string) => value.replace(/\\/+$/, \"\").toLowerCase();\n  if (tokenServiceUrl) return normalize(serviceUrl) === normalize(tokenServiceUrl);\n  try {\n    const { protocol, hostname } = new URL(serviceUrl);\n    if (protocol !== \"https:\") return false;\n    const host = hostname.toLowerCase();\n    return ALLOWED_SERVICE_HOSTS.some(\n      (allowed) => host === allowed || host.endsWith(`.${allowed}`),\n    );\n  } catch (err) {\n    logger.debug(\"rejecting unparseable serviceUrl\", { error: error.errorMessage(err) });\n    return false;\n  }\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Inbound and outbound authentication for the Teams messaging endpoint.\n *\n * `POST /api/teams/messages` is a PUBLIC URL - Azure Bot Service calls it from\n * the internet, so it cannot sit behind AppKit's OBO headers or a workspace\n * login. Its only trust boundary is the JWT the Bot Service signs each request\n * with, which is what this module verifies:\n *\n *   1. fetch the Bot Framework OpenID metadata to discover the signing JWKS;\n *   2. verify the token's signature against that key set;\n *   3. check `issuer` is a known Bot Service issuer and `audience` is exactly\n *      this bot's app id.\n *\n * All three matter. Skipping (3) is the classic bot vulnerability: a token the\n * Bot Service legitimately issued for a DIFFERENT bot still verifies against the\n * same JWKS, so without an audience check anyone with their own bot could drive\n * this agent.\n *\n * The outbound half is the reverse: replies go to the Connector API, which needs\n * a client-credentials token for the bot's own app registration. Both key sets\n * and tokens are cached, since a busy channel would otherwise re-fetch metadata\n * on every turn.\n *\n * @module\n */\n\nimport { error, log } from \"@dbx-tools/shared-core\";\nimport { createRemoteJWKSet, jwtVerify, type JWTPayload } from \"jose\";\n\n/**\n * OpenID metadata document for tokens the Bot Service sends a bot in the public\n * cloud. The JWKS URI is read from this document rather than hard-coded so a key\n * rotation on Microsoft's side needs no release here.\n *\n * Overridable per call ({@link VerifyOptions.metadataUrl}) because a sovereign\n * cloud (GCC High / DoD) publishes its own metadata endpoint - and because it\n * makes the verifier testable against a local key set.\n */\nexport const BOT_OPENID_METADATA =\n  \"https://login.botframework.com/v1/.well-known/openidconfiguration\";\n\n/**\n * Accepted `iss` values on an inbound token.\n *\n * The Bot Service has issued tokens under several issuers across channel and\n * tenant configurations, and a single-tenant bot receives the v2 Entra issuer\n * with its own tenant id spliced in (handled by {@link isTrustedIssuer}). The\n * fixed set covers the channel-issued cases.\n */\nconst TRUSTED_ISSUERS = [\n  \"https://api.botframework.com\",\n  \"https://sts.windows.net/d6d49420-f39b-4df7-a1dc-d59a935871db/\",\n  \"https://login.microsoftonline.com/d6d49420-f39b-4df7-a1dc-d59a935871db/v2.0\",\n] as const;\n\n/** Token endpoint issuing the Connector credentials an outbound reply uses. */\nconst LOGIN_TOKEN_URL = (tenant: string) =>\n  `https://login.microsoftonline.com/${tenant}/oauth2/v2.0/token`;\n\n/**\n * Scope requested for a Connector token. `.default` asks for the app's\n * statically configured permissions, which is what a bot registration grants.\n */\nconst CONNECTOR_SCOPE = \"https://api.botframework.com/.default\";\n\n/** Tenant used for a multi-tenant bot, which has no tenant of its own. */\nconst MULTI_TENANT = \"botframework.com\";\n\n/**\n * Refresh an access token this many milliseconds BEFORE it actually expires, so\n * a token never expires mid-flight between the check and the Connector call.\n */\nconst TOKEN_SKEW_MS = 60_000;\n\nconst logger = log.logger(\"teams:auth\");\n\n/**\n * Lazily-created, cached remote key set. `createRemoteJWKSet` handles its own\n * key caching and rotation (re-fetching only on an unknown `kid`), so this is\n * created once per process rather than per request.\n */\nlet keySet: ReturnType<typeof createRemoteJWKSet> | undefined;\n\n/** Cached JWKS URI discovered from the OpenID metadata document, keyed by metadata URL. */\nlet jwksUri: string | undefined;\n\n/** Metadata URL the cached key set was built from, so an override busts the cache. */\nlet keySetSource: string | undefined;\n\n/** Reset cached auth state. Test seam; not part of the public contract. */\nexport const resetTeamsAuth = (): void => {\n  keySet = undefined;\n  jwksUri = undefined;\n  keySetSource = undefined;\n  tokenCache.clear();\n};\n\n/**\n * Discover the signing JWKS URI from the Bot Framework OpenID metadata.\n *\n * Cached for the life of the process: it is a stable pointer, and the key\n * rotation that actually matters happens inside the key set it names.\n */\nconst discoverJwksUri = async (metadataUrl: string, signal?: AbortSignal): Promise<string> => {\n  if (jwksUri && keySetSource === metadataUrl) return jwksUri;\n  const response = await fetch(metadataUrl, { ...(signal ? { signal } : {}) });\n  if (!response.ok) {\n    throw new Error(`teams: could not fetch Bot Framework OpenID metadata (${response.status})`);\n  }\n  const metadata = (await response.json()) as { jwks_uri?: unknown };\n  const uri = typeof metadata.jwks_uri === \"string\" ? metadata.jwks_uri : null;\n  if (!uri) throw new Error(\"teams: Bot Framework OpenID metadata carried no jwks_uri\");\n  jwksUri = uri;\n  keySetSource = metadataUrl;\n  return uri;\n};\n\n/** The key set for the discovered JWKS URI, created once and reused. */\nconst signingKeys = async (\n  metadataUrl: string,\n  signal?: AbortSignal,\n): Promise<ReturnType<typeof createRemoteJWKSet>> => {\n  if (keySet && keySetSource === metadataUrl) return keySet;\n  const uri = await discoverJwksUri(metadataUrl, signal);\n  keySet = createRemoteJWKSet(new URL(uri));\n  return keySet;\n};\n\n/**\n * Whether `issuer` is one this bot accepts.\n *\n * A single-tenant bot receives tokens issued by its OWN tenant, so the\n * configured tenant's v2 issuer is accepted in addition to the fixed channel\n * issuers.\n */\nconst isTrustedIssuer = (issuer: string | undefined, tenantId?: string): boolean => {\n  if (!issuer) return false;\n  if ((TRUSTED_ISSUERS as readonly string[]).includes(issuer)) return true;\n  if (!tenantId) return false;\n  return (\n    issuer === `https://login.microsoftonline.com/${tenantId}/v2.0` ||\n    issuer === `https://sts.windows.net/${tenantId}/`\n  );\n};\n\n/** A verified inbound Bot Framework token. */\nexport interface VerifiedBotToken {\n  /** The token's claims, after signature / issuer / audience validation. */\n  claims: JWTPayload;\n  /**\n   * The `serviceUrl` the token was issued for, when it carries one. Bot Service\n   * tokens include this claim; comparing it to the activity's `serviceUrl` is\n   * what stops a valid token being replayed to redirect replies elsewhere.\n   */\n  serviceUrl?: string;\n}\n\n/** Options for {@link verifyBotToken}. */\nexport interface VerifyOptions {\n  /** The bot's app id; the ONLY audience an inbound token may carry. */\n  appId: string;\n  /** Tenant of a single-tenant bot, whose own issuer is then also accepted. */\n  appTenantId?: string;\n  /**\n   * OpenID metadata document naming the signing key set. Defaults to\n   * {@link BOT_OPENID_METADATA}; override for a sovereign cloud.\n   */\n  metadataUrl?: string;\n  /** Cancels the metadata / JWKS fetch with the request. */\n  signal?: AbortSignal;\n}\n\n/**\n * Verify the `Authorization` header on an inbound Bot Service request.\n *\n * Rejects (by throwing) a missing / malformed header, a bad signature, an\n * untrusted issuer, or an audience that is not this bot's `appId`. The caller\n * turns a throw into a 401 - never into a processed activity.\n */\nexport const verifyBotToken = async (\n  authorization: string | undefined,\n  options: VerifyOptions,\n): Promise<VerifiedBotToken> => {\n  const token = bearerToken(authorization);\n  if (!token) throw new Error(\"teams: request carried no bearer token\");\n\n  const keys = await signingKeys(options.metadataUrl ?? BOT_OPENID_METADATA, options.signal);\n  // `audience` is enforced by the verifier itself: a token the Bot Service\n  // issued for someone else's bot verifies against this same JWKS, so the\n  // audience check - not the signature - is what binds a request to THIS bot.\n  const { payload } = await jwtVerify(token, keys, { audience: options.appId });\n\n  if (!isTrustedIssuer(payload.iss, options.appTenantId)) {\n    throw new Error(`teams: untrusted token issuer '${payload.iss ?? \"none\"}'`);\n  }\n\n  const serviceUrl = typeof payload.serviceurl === \"string\" ? payload.serviceurl : undefined;\n  return { claims: payload, ...(serviceUrl ? { serviceUrl } : {}) };\n};\n\n/** Read the bearer value out of an `Authorization` header. */\nconst bearerToken = (authorization: string | undefined): string | null => {\n  if (!authorization) return null;\n  const [scheme, value] = authorization.split(/\\s+/, 2);\n  if (!value || scheme?.toLowerCase() !== \"bearer\") return null;\n  return value.trim() || null;\n};\n\n/** A cached Connector access token and the moment it stops being usable. */\ninterface CachedToken {\n  token: string;\n  expiresAt: number;\n}\n\n/** Per-bot cached value plus a shared in-flight refresh. */\ninterface TokenCacheEntry {\n  value?: CachedToken;\n  refresh?: Promise<CachedToken>;\n}\n\nconst tokenCache = new Map<string, TokenCacheEntry>();\n\n/** Wait for a shared refresh while preserving per-caller cancellation. */\nfunction waitForToken(refresh: Promise<CachedToken>, signal?: AbortSignal): Promise<CachedToken> {\n  if (!signal) return refresh;\n  signal.throwIfAborted();\n  return new Promise((resolve, reject) => {\n    const onAbort = () => reject(signal.reason ?? new Error(\"Connector token request aborted\"));\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    refresh.then(resolve, reject).finally(() => signal.removeEventListener(\"abort\", onAbort));\n  });\n}\n\n/** Fetch one Connector token without binding the shared refresh to one caller's signal. */\nasync function refreshConnectorToken(\n  options: { appId: string; appPassword: string },\n  tenant: string,\n  now: number,\n): Promise<CachedToken> {\n  const body = new URLSearchParams({\n    grant_type: \"client_credentials\",\n    client_id: options.appId,\n    client_secret: options.appPassword,\n    scope: CONNECTOR_SCOPE,\n  });\n  const response = await fetch(LOGIN_TOKEN_URL(tenant), {\n    method: \"POST\",\n    headers: { \"content-type\": \"application/x-www-form-urlencoded\" },\n    body,\n  });\n  if (!response.ok) {\n    const detail = await response.text().catch(() => \"\");\n    throw new Error(\n      `teams: could not obtain a Connector token (${response.status}) ${detail}`.trim(),\n    );\n  }\n  const payload = (await response.json()) as { access_token?: unknown; expires_in?: unknown };\n  const token = typeof payload.access_token === \"string\" ? payload.access_token : null;\n  if (!token) throw new Error(\"teams: token response carried no access_token\");\n  const expiresIn = typeof payload.expires_in === \"number\" ? payload.expires_in : 3600;\n  logger.debug(\"connector token refreshed\", { expiresIn });\n  return { token, expiresAt: now + expiresIn * 1000 - TOKEN_SKEW_MS };\n}\n\n/**\n * Fetch (or reuse) a Connector API access token for the bot's own app\n * registration.\n *\n * Cached until shortly before expiry: a Connector token is valid for ~1h, and\n * re-fetching per reply would add a round trip to every turn.\n */\nexport const connectorToken = async (options: {\n  appId: string;\n  appPassword: string;\n  appTenantId?: string;\n  signal?: AbortSignal;\n}): Promise<string> => {\n  const tenant = options.appTenantId ?? MULTI_TENANT;\n  const cacheKey = `${tenant}\\0${options.appId}`;\n  const now = Date.now();\n  let entry = tokenCache.get(cacheKey);\n  if (!entry) {\n    entry = {};\n    tokenCache.set(cacheKey, entry);\n  }\n  if (entry.value && entry.value.expiresAt > now) return entry.value.token;\n  entry.refresh ??= refreshConnectorToken(options, tenant, now)\n    .then((value) => {\n      entry.value = value;\n      return value;\n    })\n    .finally(() => {\n      entry.refresh = undefined;\n    });\n  return (await waitForToken(entry.refresh, options.signal)).token;\n};\n\n/**\n * Host suffixes replies may be sent to when the token pins no `serviceUrl`.\n *\n * `smba.trafficmanager.net` is the one that matters in practice: that is where\n * Teams itself serves the Connector API from (per-region, e.g.\n * `https://smba.trafficmanager.net/amer/`), so omitting it would reject every\n * real Teams reply. Compared as dot-prefixed suffixes (or exact matches) so a\n * lookalike host like `botframework.com.attacker.example` cannot pass.\n */\nconst ALLOWED_SERVICE_HOSTS = [\"botframework.com\", \"trafficmanager.net\", \"microsoft.com\"] as const;\n\n/**\n * Whether `serviceUrl` is one replies may be sent to.\n *\n * Only ever the host the verified token was issued for. A Bot Service token is a\n * bearer credential, so honoring the `serviceUrl` from the request BODY would\n * let a replayed token point the bot's authenticated replies (and its token) at\n * an attacker-controlled host. When the token carries no `serviceurl` claim the\n * body value is accepted but restricted to Microsoft's own domains.\n */\nexport const isAllowedServiceUrl = (serviceUrl: string, tokenServiceUrl?: string): boolean => {\n  const normalize = (value: string) => value.replace(/\\/+$/, \"\").toLowerCase();\n  if (tokenServiceUrl) return normalize(serviceUrl) === normalize(tokenServiceUrl);\n  try {\n    const { protocol, hostname } = new URL(serviceUrl);\n    if (protocol !== \"https:\") return false;\n    const host = hostname.toLowerCase();\n    return ALLOWED_SERVICE_HOSTS.some(\n      (allowed) => host === allowed || host.endsWith(`.${allowed}`),\n    );\n  } catch (err) {\n    logger.debug(\"rejecting unparseable serviceUrl\", { error: error.errorMessage(err) });\n    return false;\n  }\n};\n"]}

package/lib/src/builder.js

@@ -70,12 +70,13 @@ function actionElements(spec) {
  * the `adaptivecards` package or post to a Teams incoming webhook.
  */
 export function buildAdaptiveCard(spec) {
+    const validated = card.cardSpecSchema.parse(spec);
     const body = [
-        ...headingElements(spec),
-        ...textElements(spec),
-        ...factElements(spec),
+        ...headingElements(validated),
+        ...textElements(validated),
+        ...factElements(validated),
     ];
-    const actions = actionElements(spec);
+    const actions = actionElements(validated);
     const document = {
         type: "AdaptiveCard",
         $schema: card.ADAPTIVE_CARD_SCHEMA_URL,
@@ -93,4 +94,4 @@ export function buildAdaptiveCard(spec) {
 export function buildCardResult(spec) {
     return { title: spec.title, card: buildAdaptiveCard(spec) };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/config.js

@@ -105,7 +105,7 @@ export const TEAMS_CONFIG_SCHEMA = {
 export function resolveTeamsConfig(overrides) {
     const cardVersion = env.string(overrides?.cardVersion, CARD_VERSION_ENV) ?? card.ADAPTIVE_CARD_VERSION;
     const webhookUrl = env.string(overrides?.webhookUrl, WEBHOOK_URL_ENV);
-    if (webhookUrl !== null && !isAbsoluteUrl(webhookUrl)) {
+    if (webhookUrl !== null && !isHttpsUrl(webhookUrl)) {
         throw ValidationError.invalidValue(WEBHOOK_URL_ENV, webhookUrl, "an absolute https URL for the Teams webhook");
     }
     const agentPlugin = env.string(overrides?.agentPlugin, AGENT_PLUGIN_ENV) ?? DEFAULT_AGENT_PLUGIN;
@@ -124,15 +124,13 @@ export function resolveTeamsConfig(overrides) {
         ...object.optional("appTenantId", env.string(overrides?.appTenantId, APP_TENANT_ENVS)),
     };
 }
-/** Whether `value` parses as an absolute URL. */
-function isAbsoluteUrl(value) {
+/** Whether `value` parses as an absolute HTTPS URL. */
+function isHttpsUrl(value) {
     try {
-        // eslint-disable-next-line no-new
-        new URL(value);
-        return true;
+        return new URL(value).protocol === "https:";
     }
     catch {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration for the Teams plugin: the typed {@link TeamsPluginConfig}\n * (the plugin's slice of AppKit config), the JSON Schema the manifest\n * publishes for it, and {@link resolveTeamsConfig} which layers that config\n * over environment defaults into the concrete {@link ResolvedTeamsConfig} the\n * runtime + tools read.\n *\n * Building a card is a pure transform, so the config is deliberately small:\n * the Adaptive Card version the builder targets, an optional Teams\n * incoming-webhook URL a deployment can wire up to actually POST cards to a\n * channel, and which sibling plugin owns the agents the conversation endpoint\n * answers with.\n *\n * The remaining fields are the Azure Bot registration a real Teams channel\n * needs: `appId` / `appPassword` (the bot's Entra application credentials, used\n * both to validate the inbound JWT audience and to fetch the outbound Connector\n * token) and `appTenantId` (set only for a single-tenant bot). When no `appId`\n * is configured the `/messages` endpoint stays MOUNTED but refuses every\n * request, so an unconfigured deployment cannot accidentally expose an\n * unauthenticated bot endpoint.\n *\n * Env fallbacks: `TEAMS_CARD_VERSION`, `TEAMS_WEBHOOK_URL`,\n * `TEAMS_AGENT_PLUGIN`, `TEAMS_APP_ID`, `TEAMS_APP_PASSWORD`,\n * `TEAMS_APP_TENANT_ID`. The `MICROSOFT_APP_*` spellings the Bot Framework SDK\n * uses are accepted as aliases so an existing bot's environment drops in\n * unchanged.\n *\n * @module\n */\n\nimport { ValidationError, type BasePluginConfig } from \"@databricks/appkit\";\nimport { env, object } from \"@dbx-tools/shared-core\";\nimport { card } from \"@dbx-tools/shared-teams\";\nimport type { JSONSchema7 } from \"json-schema\";\n\n/** Dedicated override for the Adaptive Card schema version the builder targets. */\nexport const CARD_VERSION_ENV = \"TEAMS_CARD_VERSION\";\n\n/** Environment name for an optional Teams incoming-webhook URL. */\nexport const WEBHOOK_URL_ENV = \"TEAMS_WEBHOOK_URL\";\n\n/** Environment name overriding which sibling plugin provides the agents. */\nexport const AGENT_PLUGIN_ENV = \"TEAMS_AGENT_PLUGIN\";\n\n/**\n * Environment names for the bot's Entra app id, in precedence order. The\n * `MICROSOFT_APP_ID` alias is what the Bot Framework SDK and the Azure portal's\n * generated settings use, so an existing bot deployment needs no new variable.\n */\nexport const APP_ID_ENVS = [\"TEAMS_APP_ID\", \"MICROSOFT_APP_ID\"] as const;\n\n/** Environment names for the bot's client secret, in precedence order. */\nexport const APP_PASSWORD_ENVS = [\"TEAMS_APP_PASSWORD\", \"MICROSOFT_APP_PASSWORD\"] as const;\n\n/**\n * Environment names for the bot's tenant, in precedence order. Set only for a\n * single-tenant bot; a multi-tenant bot leaves it unset.\n */\nexport const APP_TENANT_ENVS = [\"TEAMS_APP_TENANT_ID\", \"MICROSOFT_APP_TENANT_ID\"] as const;\n\n/**\n * Environment name for the unauthenticated-messaging escape hatch. Named\n * `TEAMS_ALLOW_UNAUTHENTICATED` (rather than something softer like `TEAMS_DEV`)\n * so what it disables is unmistakable in a shell history or deploy manifest.\n */\nexport const ALLOW_UNAUTHENTICATED_ENV = \"TEAMS_ALLOW_UNAUTHENTICATED\";\n\n/**\n * Default registered name of the plugin the conversation endpoint asks for an\n * agent. `mastra` is the name `@dbx-tools/appkit-mastra` registers under.\n */\nexport const DEFAULT_AGENT_PLUGIN = \"mastra\";\n\n/** AppKit config accepted by the Teams plugin. */\nexport interface TeamsPluginConfig extends BasePluginConfig {\n  /**\n   * Adaptive Card schema version the builder targets. Defaults to\n   * {@link card.ADAPTIVE_CARD_VERSION} (`\"1.5\"`, what Teams supports). Falls\n   * back to `TEAMS_CARD_VERSION`.\n   */\n  cardVersion?: string;\n  /**\n   * Optional Teams incoming-webhook URL. When set, the plugin's `postCard`\n   * export / route posts the compiled card to this channel; when unset,\n   * posting is disabled and the plugin only builds cards for the UI to render.\n   * Falls back to `TEAMS_WEBHOOK_URL`.\n   */\n  webhookUrl?: string;\n  /**\n   * Registered name of the sibling plugin whose agents answer a conversation\n   * turn. Defaults to {@link DEFAULT_AGENT_PLUGIN} (`\"mastra\"`); set it when the\n   * Mastra plugin is mounted under a `config.name` override. Falls back to\n   * `TEAMS_AGENT_PLUGIN`.\n   */\n  agentPlugin?: string;\n  /**\n   * The bot's Entra application (client) id from its Azure Bot registration.\n   * Required before `POST /api/teams/messages` will accept a request: it is the\n   * audience an inbound Bot Framework token must carry, and the client id used\n   * to fetch an outbound Connector token. Falls back to `TEAMS_APP_ID` /\n   * `MICROSOFT_APP_ID`.\n   */\n  appId?: string;\n  /**\n   * Client secret for {@link appId}. Needed to send replies through the\n   * Connector API; without it inbound activities still validate but the bot\n   * cannot answer. Falls back to `TEAMS_APP_PASSWORD` /\n   * `MICROSOFT_APP_PASSWORD`.\n   */\n  appPassword?: string;\n  /**\n   * Tenant id for a SINGLE-tenant bot registration. Leave unset for a\n   * multi-tenant bot. Falls back to `TEAMS_APP_TENANT_ID` /\n   * `MICROSOFT_APP_TENANT_ID`.\n   */\n  appTenantId?: string;\n  /**\n   * Serve `POST /messages` with NO inbound token validation, and reply in the\n   * HTTP response instead of through the Connector API.\n   *\n   * This exists so the messaging endpoint can be exercised locally - by the\n   * in-repo preview chat, a `curl`, or the Bot Framework Emulator - without an\n   * Azure Bot registration. It removes the endpoint's ONLY trust boundary: any\n   * caller that can reach the route can drive the agent and read its answers.\n   *\n   * Never enable it on a deployment reachable from the internet. It is ignored\n   * unless `NODE_ENV` is `development` (see {@link resolveTeamsConfig}), so a\n   * production build cannot be talked into it by an environment variable alone.\n   * Falls back to `TEAMS_ALLOW_UNAUTHENTICATED`.\n   */\n  allowUnauthenticated?: boolean;\n}\n\n/** The concrete config the runtime reads, after config + env resolution. */\nexport interface ResolvedTeamsConfig {\n  /** Adaptive Card schema version the builder stamps onto every document. */\n  cardVersion: string;\n  /** Teams incoming-webhook URL, or `undefined` when posting is disabled. */\n  webhookUrl?: string;\n  /** Registered name of the plugin the conversation endpoint resolves agents from. */\n  agentPlugin: string;\n  /** Bot app (client) id, or `undefined` when no bot registration is configured. */\n  appId?: string;\n  /** Bot client secret, or `undefined` when replies cannot be sent. */\n  appPassword?: string;\n  /** Tenant id for a single-tenant bot, or `undefined` for a multi-tenant one. */\n  appTenantId?: string;\n  /**\n   * Whether `POST /messages` serves turns with NO token validation. See\n   * {@link TeamsPluginConfig.allowUnauthenticated}.\n   */\n  allowUnauthenticated: boolean;\n}\n\n/** JSON Schema published in the plugin manifest for {@link TeamsPluginConfig}. */\nexport const TEAMS_CONFIG_SCHEMA: JSONSchema7 = {\n  type: \"object\",\n  additionalProperties: false,\n  properties: {\n    cardVersion: {\n      type: \"string\",\n      description: `Adaptive Card schema version the builder targets. ${CARD_VERSION_ENV} overrides it.`,\n    },\n    webhookUrl: {\n      type: \"string\",\n      description: `Optional Teams incoming-webhook URL used to post cards. ${WEBHOOK_URL_ENV} overrides it.`,\n    },\n    agentPlugin: {\n      type: \"string\",\n      description: `Registered name of the sibling plugin whose agents answer a conversation turn. ${AGENT_PLUGIN_ENV} overrides it.`,\n    },\n    appId: {\n      type: \"string\",\n      description: `Entra app (client) id of the Azure Bot registration. Required for the Teams messaging endpoint. ${APP_ID_ENVS[0]} overrides it.`,\n    },\n    appPassword: {\n      type: \"string\",\n      description: `Client secret for the bot app id, used to fetch an outbound Connector token. ${APP_PASSWORD_ENVS[0]} overrides it.`,\n    },\n    appTenantId: {\n      type: \"string\",\n      description: `Tenant id for a single-tenant bot registration; unset for multi-tenant. ${APP_TENANT_ENVS[0]} overrides it.`,\n    },\n    allowUnauthenticated: {\n      type: \"boolean\",\n      description:\n        \"Serve the Teams messaging endpoint with NO token validation, replying in \" +\n        \"the HTTP response. Local development only; ignored unless NODE_ENV is \" +\n        `development. ${ALLOW_UNAUTHENTICATED_ENV} overrides it.`,\n    },\n  },\n};\n\n/**\n * Layer the plugin config over environment defaults into the concrete config\n * the runtime uses. Fails loudly on a webhook URL that is present but not a\n * valid absolute URL, since that is a deploy-time mistake.\n */\nexport function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeamsConfig {\n  const cardVersion =\n    env.string(overrides?.cardVersion, CARD_VERSION_ENV) ?? card.ADAPTIVE_CARD_VERSION;\n  const webhookUrl = env.string(overrides?.webhookUrl, WEBHOOK_URL_ENV);\n  if (webhookUrl !== null && !isAbsoluteUrl(webhookUrl)) {\n    throw ValidationError.invalidValue(\n      WEBHOOK_URL_ENV,\n      webhookUrl,\n      \"an absolute https URL for the Teams webhook\",\n    );\n  }\n  const agentPlugin = env.string(overrides?.agentPlugin, AGENT_PLUGIN_ENV) ?? DEFAULT_AGENT_PLUGIN;\n  // Two independent conditions must BOTH hold: the operator asked for it, and\n  // this is a development build. Gating on `NODE_ENV` as well means a stray\n  // variable in a production environment cannot silently expose the endpoint.\n  const requested = env.boolean(overrides?.allowUnauthenticated, ALLOW_UNAUTHENTICATED_ENV);\n  const allowUnauthenticated = requested === true && process.env.NODE_ENV === \"development\";\n  return {\n    cardVersion,\n    agentPlugin,\n    allowUnauthenticated,\n    ...object.optional(\"webhookUrl\", webhookUrl),\n    ...object.optional(\"appId\", env.string(overrides?.appId, APP_ID_ENVS)),\n    ...object.optional(\"appPassword\", env.string(overrides?.appPassword, APP_PASSWORD_ENVS)),\n    ...object.optional(\"appTenantId\", env.string(overrides?.appTenantId, APP_TENANT_ENVS)),\n  };\n}\n\n/** Whether `value` parses as an absolute URL. */\nfunction isAbsoluteUrl(value: string): boolean {\n  try {\n    // eslint-disable-next-line no-new\n    new URL(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration for the Teams plugin: the typed {@link TeamsPluginConfig}\n * (the plugin's slice of AppKit config), the JSON Schema the manifest\n * publishes for it, and {@link resolveTeamsConfig} which layers that config\n * over environment defaults into the concrete {@link ResolvedTeamsConfig} the\n * runtime + tools read.\n *\n * Building a card is a pure transform, so the config is deliberately small:\n * the Adaptive Card version the builder targets, an optional Teams\n * incoming-webhook URL a deployment can wire up to actually POST cards to a\n * channel, and which sibling plugin owns the agents the conversation endpoint\n * answers with.\n *\n * The remaining fields are the Azure Bot registration a real Teams channel\n * needs: `appId` / `appPassword` (the bot's Entra application credentials, used\n * both to validate the inbound JWT audience and to fetch the outbound Connector\n * token) and `appTenantId` (set only for a single-tenant bot). When no `appId`\n * is configured the `/messages` endpoint stays MOUNTED but refuses every\n * request, so an unconfigured deployment cannot accidentally expose an\n * unauthenticated bot endpoint.\n *\n * Env fallbacks: `TEAMS_CARD_VERSION`, `TEAMS_WEBHOOK_URL`,\n * `TEAMS_AGENT_PLUGIN`, `TEAMS_APP_ID`, `TEAMS_APP_PASSWORD`,\n * `TEAMS_APP_TENANT_ID`. The `MICROSOFT_APP_*` spellings the Bot Framework SDK\n * uses are accepted as aliases so an existing bot's environment drops in\n * unchanged.\n *\n * @module\n */\n\nimport { ValidationError, type BasePluginConfig } from \"@databricks/appkit\";\nimport { env, object } from \"@dbx-tools/shared-core\";\nimport { card } from \"@dbx-tools/shared-teams\";\nimport type { JSONSchema7 } from \"json-schema\";\n\n/** Dedicated override for the Adaptive Card schema version the builder targets. */\nexport const CARD_VERSION_ENV = \"TEAMS_CARD_VERSION\";\n\n/** Environment name for an optional Teams incoming-webhook URL. */\nexport const WEBHOOK_URL_ENV = \"TEAMS_WEBHOOK_URL\";\n\n/** Environment name overriding which sibling plugin provides the agents. */\nexport const AGENT_PLUGIN_ENV = \"TEAMS_AGENT_PLUGIN\";\n\n/**\n * Environment names for the bot's Entra app id, in precedence order. The\n * `MICROSOFT_APP_ID` alias is what the Bot Framework SDK and the Azure portal's\n * generated settings use, so an existing bot deployment needs no new variable.\n */\nexport const APP_ID_ENVS = [\"TEAMS_APP_ID\", \"MICROSOFT_APP_ID\"] as const;\n\n/** Environment names for the bot's client secret, in precedence order. */\nexport const APP_PASSWORD_ENVS = [\"TEAMS_APP_PASSWORD\", \"MICROSOFT_APP_PASSWORD\"] as const;\n\n/**\n * Environment names for the bot's tenant, in precedence order. Set only for a\n * single-tenant bot; a multi-tenant bot leaves it unset.\n */\nexport const APP_TENANT_ENVS = [\"TEAMS_APP_TENANT_ID\", \"MICROSOFT_APP_TENANT_ID\"] as const;\n\n/**\n * Environment name for the unauthenticated-messaging escape hatch. Named\n * `TEAMS_ALLOW_UNAUTHENTICATED` (rather than something softer like `TEAMS_DEV`)\n * so what it disables is unmistakable in a shell history or deploy manifest.\n */\nexport const ALLOW_UNAUTHENTICATED_ENV = \"TEAMS_ALLOW_UNAUTHENTICATED\";\n\n/**\n * Default registered name of the plugin the conversation endpoint asks for an\n * agent. `mastra` is the name `@dbx-tools/appkit-mastra` registers under.\n */\nexport const DEFAULT_AGENT_PLUGIN = \"mastra\";\n\n/** AppKit config accepted by the Teams plugin. */\nexport interface TeamsPluginConfig extends BasePluginConfig {\n  /**\n   * Adaptive Card schema version the builder targets. Defaults to\n   * {@link card.ADAPTIVE_CARD_VERSION} (`\"1.5\"`, what Teams supports). Falls\n   * back to `TEAMS_CARD_VERSION`.\n   */\n  cardVersion?: string;\n  /**\n   * Optional Teams incoming-webhook URL. When set, the plugin's `postCard`\n   * export / route posts the compiled card to this channel; when unset,\n   * posting is disabled and the plugin only builds cards for the UI to render.\n   * Falls back to `TEAMS_WEBHOOK_URL`.\n   */\n  webhookUrl?: string;\n  /**\n   * Registered name of the sibling plugin whose agents answer a conversation\n   * turn. Defaults to {@link DEFAULT_AGENT_PLUGIN} (`\"mastra\"`); set it when the\n   * Mastra plugin is mounted under a `config.name` override. Falls back to\n   * `TEAMS_AGENT_PLUGIN`.\n   */\n  agentPlugin?: string;\n  /**\n   * The bot's Entra application (client) id from its Azure Bot registration.\n   * Required before `POST /api/teams/messages` will accept a request: it is the\n   * audience an inbound Bot Framework token must carry, and the client id used\n   * to fetch an outbound Connector token. Falls back to `TEAMS_APP_ID` /\n   * `MICROSOFT_APP_ID`.\n   */\n  appId?: string;\n  /**\n   * Client secret for {@link appId}. Needed to send replies through the\n   * Connector API; without it inbound activities still validate but the bot\n   * cannot answer. Falls back to `TEAMS_APP_PASSWORD` /\n   * `MICROSOFT_APP_PASSWORD`.\n   */\n  appPassword?: string;\n  /**\n   * Tenant id for a SINGLE-tenant bot registration. Leave unset for a\n   * multi-tenant bot. Falls back to `TEAMS_APP_TENANT_ID` /\n   * `MICROSOFT_APP_TENANT_ID`.\n   */\n  appTenantId?: string;\n  /**\n   * Serve `POST /messages` with NO inbound token validation, and reply in the\n   * HTTP response instead of through the Connector API.\n   *\n   * This exists so the messaging endpoint can be exercised locally - by the\n   * in-repo preview chat, a `curl`, or the Bot Framework Emulator - without an\n   * Azure Bot registration. It removes the endpoint's ONLY trust boundary: any\n   * caller that can reach the route can drive the agent and read its answers.\n   *\n   * Never enable it on a deployment reachable from the internet. It is ignored\n   * unless `NODE_ENV` is `development` (see {@link resolveTeamsConfig}), so a\n   * production build cannot be talked into it by an environment variable alone.\n   * Falls back to `TEAMS_ALLOW_UNAUTHENTICATED`.\n   */\n  allowUnauthenticated?: boolean;\n}\n\n/** The concrete config the runtime reads, after config + env resolution. */\nexport interface ResolvedTeamsConfig {\n  /** Adaptive Card schema version the builder stamps onto every document. */\n  cardVersion: string;\n  /** Teams incoming-webhook URL, or `undefined` when posting is disabled. */\n  webhookUrl?: string;\n  /** Registered name of the plugin the conversation endpoint resolves agents from. */\n  agentPlugin: string;\n  /** Bot app (client) id, or `undefined` when no bot registration is configured. */\n  appId?: string;\n  /** Bot client secret, or `undefined` when replies cannot be sent. */\n  appPassword?: string;\n  /** Tenant id for a single-tenant bot, or `undefined` for a multi-tenant one. */\n  appTenantId?: string;\n  /**\n   * Whether `POST /messages` serves turns with NO token validation. See\n   * {@link TeamsPluginConfig.allowUnauthenticated}.\n   */\n  allowUnauthenticated: boolean;\n}\n\n/** JSON Schema published in the plugin manifest for {@link TeamsPluginConfig}. */\nexport const TEAMS_CONFIG_SCHEMA: JSONSchema7 = {\n  type: \"object\",\n  additionalProperties: false,\n  properties: {\n    cardVersion: {\n      type: \"string\",\n      description: `Adaptive Card schema version the builder targets. ${CARD_VERSION_ENV} overrides it.`,\n    },\n    webhookUrl: {\n      type: \"string\",\n      description: `Optional Teams incoming-webhook URL used to post cards. ${WEBHOOK_URL_ENV} overrides it.`,\n    },\n    agentPlugin: {\n      type: \"string\",\n      description: `Registered name of the sibling plugin whose agents answer a conversation turn. ${AGENT_PLUGIN_ENV} overrides it.`,\n    },\n    appId: {\n      type: \"string\",\n      description: `Entra app (client) id of the Azure Bot registration. Required for the Teams messaging endpoint. ${APP_ID_ENVS[0]} overrides it.`,\n    },\n    appPassword: {\n      type: \"string\",\n      description: `Client secret for the bot app id, used to fetch an outbound Connector token. ${APP_PASSWORD_ENVS[0]} overrides it.`,\n    },\n    appTenantId: {\n      type: \"string\",\n      description: `Tenant id for a single-tenant bot registration; unset for multi-tenant. ${APP_TENANT_ENVS[0]} overrides it.`,\n    },\n    allowUnauthenticated: {\n      type: \"boolean\",\n      description:\n        \"Serve the Teams messaging endpoint with NO token validation, replying in \" +\n        \"the HTTP response. Local development only; ignored unless NODE_ENV is \" +\n        `development. ${ALLOW_UNAUTHENTICATED_ENV} overrides it.`,\n    },\n  },\n};\n\n/**\n * Layer the plugin config over environment defaults into the concrete config\n * the runtime uses. Fails loudly on a webhook URL that is present but not a\n * valid absolute URL, since that is a deploy-time mistake.\n */\nexport function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeamsConfig {\n  const cardVersion =\n    env.string(overrides?.cardVersion, CARD_VERSION_ENV) ?? card.ADAPTIVE_CARD_VERSION;\n  const webhookUrl = env.string(overrides?.webhookUrl, WEBHOOK_URL_ENV);\n  if (webhookUrl !== null && !isHttpsUrl(webhookUrl)) {\n    throw ValidationError.invalidValue(\n      WEBHOOK_URL_ENV,\n      webhookUrl,\n      \"an absolute https URL for the Teams webhook\",\n    );\n  }\n  const agentPlugin = env.string(overrides?.agentPlugin, AGENT_PLUGIN_ENV) ?? DEFAULT_AGENT_PLUGIN;\n  // Two independent conditions must BOTH hold: the operator asked for it, and\n  // this is a development build. Gating on `NODE_ENV` as well means a stray\n  // variable in a production environment cannot silently expose the endpoint.\n  const requested = env.boolean(overrides?.allowUnauthenticated, ALLOW_UNAUTHENTICATED_ENV);\n  const allowUnauthenticated = requested === true && process.env.NODE_ENV === \"development\";\n  return {\n    cardVersion,\n    agentPlugin,\n    allowUnauthenticated,\n    ...object.optional(\"webhookUrl\", webhookUrl),\n    ...object.optional(\"appId\", env.string(overrides?.appId, APP_ID_ENVS)),\n    ...object.optional(\"appPassword\", env.string(overrides?.appPassword, APP_PASSWORD_ENVS)),\n    ...object.optional(\"appTenantId\", env.string(overrides?.appTenantId, APP_TENANT_ENVS)),\n  };\n}\n\n/** Whether `value` parses as an absolute HTTPS URL. */\nfunction isHttpsUrl(value: string): boolean {\n  try {\n    return new URL(value).protocol === \"https:\";\n  } catch {\n    return false;\n  }\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reggie-db/dbx-tools.git",
-    "directory": "packages/node/teams"
+    "directory": "js-packages/node/teams"
   },
   "scripts": {
     "build": "projen build",
@@ -26,8 +26,8 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/shared-core": "0.6.72",
-    "@dbx-tools/shared-teams": "0.6.72",
+    "@dbx-tools/shared-core": "0.6.74",
+    "@dbx-tools/shared-teams": "0.6.74",
     "@mastra/core": "^1.47.0",
     "jose": "^6.2.3",
     "zod": "4.3.6"
@@ -46,7 +46,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.72",
+  "version": "0.6.74",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/auth.ts

@@ -92,7 +92,7 @@ export const resetTeamsAuth = (): void => {
   keySet = undefined;
   jwksUri = undefined;
   keySetSource = undefined;
-  tokenCache = undefined;
+  tokenCache.clear();
 };
 
 /**
@@ -212,35 +212,41 @@ interface CachedToken {
   expiresAt: number;
 }
 
-let tokenCache: CachedToken | undefined;
+/** Per-bot cached value plus a shared in-flight refresh. */
+interface TokenCacheEntry {
+  value?: CachedToken;
+  refresh?: Promise<CachedToken>;
+}
 
-/**
- * Fetch (or reuse) a Connector API access token for the bot's own app
- * registration.
- *
- * Cached until shortly before expiry: a Connector token is valid for ~1h, and
- * re-fetching per reply would add a round trip to every turn.
- */
-export const connectorToken = async (options: {
-  appId: string;
-  appPassword: string;
-  appTenantId?: string;
-  signal?: AbortSignal;
-}): Promise<string> => {
-  const now = Date.now();
-  if (tokenCache && tokenCache.expiresAt > now) return tokenCache.token;
+const tokenCache = new Map<string, TokenCacheEntry>();
+
+/** Wait for a shared refresh while preserving per-caller cancellation. */
+function waitForToken(refresh: Promise<CachedToken>, signal?: AbortSignal): Promise<CachedToken> {
+  if (!signal) return refresh;
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new Error("Connector token request aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    refresh.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
 
+/** Fetch one Connector token without binding the shared refresh to one caller's signal. */
+async function refreshConnectorToken(
+  options: { appId: string; appPassword: string },
+  tenant: string,
+  now: number,
+): Promise<CachedToken> {
   const body = new URLSearchParams({
     grant_type: "client_credentials",
     client_id: options.appId,
     client_secret: options.appPassword,
     scope: CONNECTOR_SCOPE,
   });
-  const response = await fetch(LOGIN_TOKEN_URL(options.appTenantId ?? MULTI_TENANT), {
+  const response = await fetch(LOGIN_TOKEN_URL(tenant), {
     method: "POST",
     headers: { "content-type": "application/x-www-form-urlencoded" },
     body,
-    ...(options.signal ? { signal: options.signal } : {}),
   });
   if (!response.ok) {
     const detail = await response.text().catch(() => "");
@@ -252,9 +258,41 @@ export const connectorToken = async (options: {
   const token = typeof payload.access_token === "string" ? payload.access_token : null;
   if (!token) throw new Error("teams: token response carried no access_token");
   const expiresIn = typeof payload.expires_in === "number" ? payload.expires_in : 3600;
-  tokenCache = { token, expiresAt: now + expiresIn * 1000 - TOKEN_SKEW_MS };
   logger.debug("connector token refreshed", { expiresIn });
-  return token;
+  return { token, expiresAt: now + expiresIn * 1000 - TOKEN_SKEW_MS };
+}
+
+/**
+ * Fetch (or reuse) a Connector API access token for the bot's own app
+ * registration.
+ *
+ * Cached until shortly before expiry: a Connector token is valid for ~1h, and
+ * re-fetching per reply would add a round trip to every turn.
+ */
+export const connectorToken = async (options: {
+  appId: string;
+  appPassword: string;
+  appTenantId?: string;
+  signal?: AbortSignal;
+}): Promise<string> => {
+  const tenant = options.appTenantId ?? MULTI_TENANT;
+  const cacheKey = `${tenant}\0${options.appId}`;
+  const now = Date.now();
+  let entry = tokenCache.get(cacheKey);
+  if (!entry) {
+    entry = {};
+    tokenCache.set(cacheKey, entry);
+  }
+  if (entry.value && entry.value.expiresAt > now) return entry.value.token;
+  entry.refresh ??= refreshConnectorToken(options, tenant, now)
+    .then((value) => {
+      entry.value = value;
+      return value;
+    })
+    .finally(() => {
+      entry.refresh = undefined;
+    });
+  return (await waitForToken(entry.refresh, options.signal)).token;
 };
 
 /**

package/src/builder.ts

@@ -76,12 +76,13 @@ function actionElements(spec: card.CardSpec): CardElement[] {
  * the `adaptivecards` package or post to a Teams incoming webhook.
  */
 export function buildAdaptiveCard(spec: card.CardSpec): card.AdaptiveCard {
+  const validated = card.cardSpecSchema.parse(spec);
   const body: CardElement[] = [
-    ...headingElements(spec),
-    ...textElements(spec),
-    ...factElements(spec),
+    ...headingElements(validated),
+    ...textElements(validated),
+    ...factElements(validated),
   ];
-  const actions = actionElements(spec);
+  const actions = actionElements(validated);
   const document: card.AdaptiveCard = {
     type: "AdaptiveCard",
     $schema: card.ADAPTIVE_CARD_SCHEMA_URL,

package/src/config.ts

@@ -200,7 +200,7 @@ export function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeams
   const cardVersion =
     env.string(overrides?.cardVersion, CARD_VERSION_ENV) ?? card.ADAPTIVE_CARD_VERSION;
   const webhookUrl = env.string(overrides?.webhookUrl, WEBHOOK_URL_ENV);
-  if (webhookUrl !== null && !isAbsoluteUrl(webhookUrl)) {
+  if (webhookUrl !== null && !isHttpsUrl(webhookUrl)) {
     throw ValidationError.invalidValue(
       WEBHOOK_URL_ENV,
       webhookUrl,
@@ -224,12 +224,10 @@ export function resolveTeamsConfig(overrides?: TeamsPluginConfig): ResolvedTeams
   };
 }
 
-/** Whether `value` parses as an absolute URL. */
-function isAbsoluteUrl(value: string): boolean {
+/** Whether `value` parses as an absolute HTTPS URL. */
+function isHttpsUrl(value: string): boolean {
   try {
-    // eslint-disable-next-line no-new
-    new URL(value);
-    return true;
+    return new URL(value).protocol === "https:";
   } catch {
     return false;
   }