@dbx-tools/teams 0.3.44 → 0.4.1

package/lib/index.d.ts

@@ -0,0 +1,28 @@
+export * as auth from "./src/auth.js";
+export * as builder from "./src/builder.js";
+export * as config from "./src/config.js";
+export * as connector from "./src/connector.js";
+export * as conversation from "./src/conversation.js";
+export * as defaults from "./src/defaults.js";
+export * as messaging from "./src/messaging.js";
+export * as plugin from "./src/plugin.js";
+export * as runtime from "./src/runtime.js";
+export * as tool from "./src/tool.js";
+export { BOT_OPENID_METADATA, resetTeamsAuth, verifyBotToken, connectorToken, isAllowedServiceUrl } from "./src/auth.js";
+export type { VerifiedBotToken, VerifyOptions } from "./src/auth.js";
+export { buildAdaptiveCard, buildCardResult } from "./src/builder.js";
+export { CARD_VERSION_ENV, WEBHOOK_URL_ENV, AGENT_PLUGIN_ENV, APP_ID_ENVS, APP_PASSWORD_ENVS, APP_TENANT_ENVS, ALLOW_UNAUTHENTICATED_ENV, DEFAULT_AGENT_PLUGIN, TEAMS_CONFIG_SCHEMA, resolveTeamsConfig } from "./src/config.js";
+export type { TeamsPluginConfig, ResolvedTeamsConfig } from "./src/config.js";
+export { sendActivity, sendTyping } from "./src/connector.js";
+export type { ConnectorTarget } from "./src/connector.js";
+export { BOT_ACCOUNT, CARD_FORMAT_INSTRUCTIONS, CARD_ANSWER_INSTRUCTIONS, resolveCardAgent, resolveCardContextFactory, promptOf, toReplyActivity, documentCardSpec, rejectedCardSpec, runCardTurn } from "./src/conversation.js";
+export type { CardAgentLike, AgentResult, AgentProviderLike, CardTurnOptions, CardContextFactory } from "./src/conversation.js";
+export { BUILD_TIMEOUT_MS, POST_TIMEOUT_MS, POST_ATTEMPTS, TEAMS_BUILD_SETTINGS, TURN_TIMEOUT_MS, TEAMS_TURN_SETTINGS, TEAMS_POST_SETTINGS } from "./src/defaults.js";
+export type { TeamsExecuteConfig, TeamsExecutionSettings } from "./src/defaults.js";
+export { resolveServiceUrl, deliverTurn } from "./src/messaging.js";
+export type { BotCredentials, DeliverTurnOptions } from "./src/messaging.js";
+export { TeamsPlugin, teams } from "./src/plugin.js";
+export { getTeamsRuntime, setTeamsExecutor, resetTeamsRuntime, buildCard, postCard } from "./src/runtime.js";
+export type { TeamsExecutor, TeamsRuntime } from "./src/runtime.js";
+export { CREATE_CARD_DESCRIPTION, teamsCardTool } from "./src/tool.js";
+export type { TeamsCardToolOptions } from "./src/tool.js";

package/lib/index.js

@@ -0,0 +1,24 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as auth from "./src/auth.js";
+export * as builder from "./src/builder.js";
+export * as config from "./src/config.js";
+export * as connector from "./src/connector.js";
+export * as conversation from "./src/conversation.js";
+export * as defaults from "./src/defaults.js";
+export * as messaging from "./src/messaging.js";
+export * as plugin from "./src/plugin.js";
+export * as runtime from "./src/runtime.js";
+export * as tool from "./src/tool.js";
+export { BOT_OPENID_METADATA, resetTeamsAuth, verifyBotToken, connectorToken, isAllowedServiceUrl } from "./src/auth.js";
+export { buildAdaptiveCard, buildCardResult } from "./src/builder.js";
+export { CARD_VERSION_ENV, WEBHOOK_URL_ENV, AGENT_PLUGIN_ENV, APP_ID_ENVS, APP_PASSWORD_ENVS, APP_TENANT_ENVS, ALLOW_UNAUTHENTICATED_ENV, DEFAULT_AGENT_PLUGIN, TEAMS_CONFIG_SCHEMA, resolveTeamsConfig } from "./src/config.js";
+export { sendActivity, sendTyping } from "./src/connector.js";
+export { BOT_ACCOUNT, CARD_FORMAT_INSTRUCTIONS, CARD_ANSWER_INSTRUCTIONS, resolveCardAgent, resolveCardContextFactory, promptOf, toReplyActivity, documentCardSpec, rejectedCardSpec, runCardTurn } from "./src/conversation.js";
+export { BUILD_TIMEOUT_MS, POST_TIMEOUT_MS, POST_ATTEMPTS, TEAMS_BUILD_SETTINGS, TURN_TIMEOUT_MS, TEAMS_TURN_SETTINGS, TEAMS_POST_SETTINGS } from "./src/defaults.js";
+export { resolveServiceUrl, deliverTurn } from "./src/messaging.js";
+export { TeamsPlugin, teams } from "./src/plugin.js";
+export { getTeamsRuntime, setTeamsExecutor, resetTeamsRuntime, buildCard, postCard } from "./src/runtime.js";
+export { CREATE_CARD_DESCRIPTION, teamsCardTool } from "./src/tool.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/auth.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Inbound and outbound authentication for the Teams messaging endpoint.
+ *
+ * `POST /api/teams/messages` is a PUBLIC URL - Azure Bot Service calls it from
+ * the internet, so it cannot sit behind AppKit's OBO headers or a workspace
+ * login. Its only trust boundary is the JWT the Bot Service signs each request
+ * with, which is what this module verifies:
+ *
+ *   1. fetch the Bot Framework OpenID metadata to discover the signing JWKS;
+ *   2. verify the token's signature against that key set;
+ *   3. check `issuer` is a known Bot Service issuer and `audience` is exactly
+ *      this bot's app id.
+ *
+ * All three matter. Skipping (3) is the classic bot vulnerability: a token the
+ * Bot Service legitimately issued for a DIFFERENT bot still verifies against the
+ * same JWKS, so without an audience check anyone with their own bot could drive
+ * this agent.
+ *
+ * The outbound half is the reverse: replies go to the Connector API, which needs
+ * a client-credentials token for the bot's own app registration. Both key sets
+ * and tokens are cached, since a busy channel would otherwise re-fetch metadata
+ * on every turn.
+ *
+ * @module
+ */
+import { type JWTPayload } from "jose";
+/**
+ * OpenID metadata document for tokens the Bot Service sends a bot in the public
+ * cloud. The JWKS URI is read from this document rather than hard-coded so a key
+ * rotation on Microsoft's side needs no release here.
+ *
+ * Overridable per call ({@link VerifyOptions.metadataUrl}) because a sovereign
+ * cloud (GCC High / DoD) publishes its own metadata endpoint - and because it
+ * makes the verifier testable against a local key set.
+ */
+export declare const BOT_OPENID_METADATA = "https://login.botframework.com/v1/.well-known/openidconfiguration";
+/** Reset cached auth state. Test seam; not part of the public contract. */
+export declare const resetTeamsAuth: () => void;
+/** A verified inbound Bot Framework token. */
+export interface VerifiedBotToken {
+    /** The token's claims, after signature / issuer / audience validation. */
+    claims: JWTPayload;
+    /**
+     * The `serviceUrl` the token was issued for, when it carries one. Bot Service
+     * tokens include this claim; comparing it to the activity's `serviceUrl` is
+     * what stops a valid token being replayed to redirect replies elsewhere.
+     */
+    serviceUrl?: string;
+}
+/** Options for {@link verifyBotToken}. */
+export interface VerifyOptions {
+    /** The bot's app id; the ONLY audience an inbound token may carry. */
+    appId: string;
+    /** Tenant of a single-tenant bot, whose own issuer is then also accepted. */
+    appTenantId?: string;
+    /**
+     * OpenID metadata document naming the signing key set. Defaults to
+     * {@link BOT_OPENID_METADATA}; override for a sovereign cloud.
+     */
+    metadataUrl?: string;
+    /** Cancels the metadata / JWKS fetch with the request. */
+    signal?: AbortSignal;
+}
+/**
+ * Verify the `Authorization` header on an inbound Bot Service request.
+ *
+ * Rejects (by throwing) a missing / malformed header, a bad signature, an
+ * untrusted issuer, or an audience that is not this bot's `appId`. The caller
+ * turns a throw into a 401 - never into a processed activity.
+ */
+export declare const verifyBotToken: (authorization: string | undefined, options: VerifyOptions) => Promise<VerifiedBotToken>;
+/**
+ * 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 declare const connectorToken: (options: {
+    appId: string;
+    appPassword: string;
+    appTenantId?: string;
+    signal?: AbortSignal;
+}) => Promise<string>;
+/**
+ * Whether `serviceUrl` is one replies may be sent to.
+ *
+ * Only ever the host the verified token was issued for. A Bot Service token is a
+ * bearer credential, so honoring the `serviceUrl` from the request BODY would
+ * let a replayed token point the bot's authenticated replies (and its token) at
+ * an attacker-controlled host. When the token carries no `serviceurl` claim the
+ * body value is accepted but restricted to Microsoft's own domains.
+ */
+export declare const isAllowedServiceUrl: (serviceUrl: string, tokenServiceUrl?: string) => boolean;

package/lib/src/auth.js

@@ -0,0 +1,232 @@
+/**
+ * Inbound and outbound authentication for the Teams messaging endpoint.
+ *
+ * `POST /api/teams/messages` is a PUBLIC URL - Azure Bot Service calls it from
+ * the internet, so it cannot sit behind AppKit's OBO headers or a workspace
+ * login. Its only trust boundary is the JWT the Bot Service signs each request
+ * with, which is what this module verifies:
+ *
+ *   1. fetch the Bot Framework OpenID metadata to discover the signing JWKS;
+ *   2. verify the token's signature against that key set;
+ *   3. check `issuer` is a known Bot Service issuer and `audience` is exactly
+ *      this bot's app id.
+ *
+ * All three matter. Skipping (3) is the classic bot vulnerability: a token the
+ * Bot Service legitimately issued for a DIFFERENT bot still verifies against the
+ * same JWKS, so without an audience check anyone with their own bot could drive
+ * this agent.
+ *
+ * The outbound half is the reverse: replies go to the Connector API, which needs
+ * a client-credentials token for the bot's own app registration. Both key sets
+ * and tokens are cached, since a busy channel would otherwise re-fetch metadata
+ * on every turn.
+ *
+ * @module
+ */
+import { error, log } from "@dbx-tools/shared-core";
+import { createRemoteJWKSet, jwtVerify } from "jose";
+/**
+ * OpenID metadata document for tokens the Bot Service sends a bot in the public
+ * cloud. The JWKS URI is read from this document rather than hard-coded so a key
+ * rotation on Microsoft's side needs no release here.
+ *
+ * Overridable per call ({@link VerifyOptions.metadataUrl}) because a sovereign
+ * cloud (GCC High / DoD) publishes its own metadata endpoint - and because it
+ * makes the verifier testable against a local key set.
+ */
+export const BOT_OPENID_METADATA = "https://login.botframework.com/v1/.well-known/openidconfiguration";
+/**
+ * Accepted `iss` values on an inbound token.
+ *
+ * The Bot Service has issued tokens under several issuers across channel and
+ * tenant configurations, and a single-tenant bot receives the v2 Entra issuer
+ * with its own tenant id spliced in (handled by {@link isTrustedIssuer}). The
+ * fixed set covers the channel-issued cases.
+ */
+const TRUSTED_ISSUERS = [
+    "https://api.botframework.com",
+    "https://sts.windows.net/d6d49420-f39b-4df7-a1dc-d59a935871db/",
+    "https://login.microsoftonline.com/d6d49420-f39b-4df7-a1dc-d59a935871db/v2.0",
+];
+/** Token endpoint issuing the Connector credentials an outbound reply uses. */
+const LOGIN_TOKEN_URL = (tenant) => `https://login.microsoftonline.com/${tenant}/oauth2/v2.0/token`;
+/**
+ * Scope requested for a Connector token. `.default` asks for the app's
+ * statically configured permissions, which is what a bot registration grants.
+ */
+const CONNECTOR_SCOPE = "https://api.botframework.com/.default";
+/** Tenant used for a multi-tenant bot, which has no tenant of its own. */
+const MULTI_TENANT = "botframework.com";
+/**
+ * Refresh an access token this many milliseconds BEFORE it actually expires, so
+ * a token never expires mid-flight between the check and the Connector call.
+ */
+const TOKEN_SKEW_MS = 60_000;
+const logger = log.logger("teams:auth");
+/**
+ * Lazily-created, cached remote key set. `createRemoteJWKSet` handles its own
+ * key caching and rotation (re-fetching only on an unknown `kid`), so this is
+ * created once per process rather than per request.
+ */
+let keySet;
+/** Cached JWKS URI discovered from the OpenID metadata document, keyed by metadata URL. */
+let jwksUri;
+/** Metadata URL the cached key set was built from, so an override busts the cache. */
+let keySetSource;
+/** Reset cached auth state. Test seam; not part of the public contract. */
+export const resetTeamsAuth = () => {
+    keySet = undefined;
+    jwksUri = undefined;
+    keySetSource = undefined;
+    tokenCache = undefined;
+};
+/**
+ * Discover the signing JWKS URI from the Bot Framework OpenID metadata.
+ *
+ * Cached for the life of the process: it is a stable pointer, and the key
+ * rotation that actually matters happens inside the key set it names.
+ */
+const discoverJwksUri = async (metadataUrl, signal) => {
+    if (jwksUri && keySetSource === metadataUrl)
+        return jwksUri;
+    const response = await fetch(metadataUrl, { ...(signal ? { signal } : {}) });
+    if (!response.ok) {
+        throw new Error(`teams: could not fetch Bot Framework OpenID metadata (${response.status})`);
+    }
+    const metadata = (await response.json());
+    const uri = typeof metadata.jwks_uri === "string" ? metadata.jwks_uri : null;
+    if (!uri)
+        throw new Error("teams: Bot Framework OpenID metadata carried no jwks_uri");
+    jwksUri = uri;
+    keySetSource = metadataUrl;
+    return uri;
+};
+/** The key set for the discovered JWKS URI, created once and reused. */
+const signingKeys = async (metadataUrl, signal) => {
+    if (keySet && keySetSource === metadataUrl)
+        return keySet;
+    const uri = await discoverJwksUri(metadataUrl, signal);
+    keySet = createRemoteJWKSet(new URL(uri));
+    return keySet;
+};
+/**
+ * Whether `issuer` is one this bot accepts.
+ *
+ * A single-tenant bot receives tokens issued by its OWN tenant, so the
+ * configured tenant's v2 issuer is accepted in addition to the fixed channel
+ * issuers.
+ */
+const isTrustedIssuer = (issuer, tenantId) => {
+    if (!issuer)
+        return false;
+    if (TRUSTED_ISSUERS.includes(issuer))
+        return true;
+    if (!tenantId)
+        return false;
+    return (issuer === `https://login.microsoftonline.com/${tenantId}/v2.0` ||
+        issuer === `https://sts.windows.net/${tenantId}/`);
+};
+/**
+ * Verify the `Authorization` header on an inbound Bot Service request.
+ *
+ * Rejects (by throwing) a missing / malformed header, a bad signature, an
+ * untrusted issuer, or an audience that is not this bot's `appId`. The caller
+ * turns a throw into a 401 - never into a processed activity.
+ */
+export const verifyBotToken = async (authorization, options) => {
+    const token = bearerToken(authorization);
+    if (!token)
+        throw new Error("teams: request carried no bearer token");
+    const keys = await signingKeys(options.metadataUrl ?? BOT_OPENID_METADATA, options.signal);
+    // `audience` is enforced by the verifier itself: a token the Bot Service
+    // issued for someone else's bot verifies against this same JWKS, so the
+    // audience check - not the signature - is what binds a request to THIS bot.
+    const { payload } = await jwtVerify(token, keys, { audience: options.appId });
+    if (!isTrustedIssuer(payload.iss, options.appTenantId)) {
+        throw new Error(`teams: untrusted token issuer '${payload.iss ?? "none"}'`);
+    }
+    const serviceUrl = typeof payload.serviceurl === "string" ? payload.serviceurl : undefined;
+    return { claims: payload, ...(serviceUrl ? { serviceUrl } : {}) };
+};
+/** Read the bearer value out of an `Authorization` header. */
+const bearerToken = (authorization) => {
+    if (!authorization)
+        return null;
+    const [scheme, value] = authorization.split(/\s+/, 2);
+    if (!value || scheme?.toLowerCase() !== "bearer")
+        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 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), {
+        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(() => "");
+        throw new Error(`teams: could not obtain a Connector token (${response.status}) ${detail}`.trim());
+    }
+    const payload = (await response.json());
+    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;
+};
+/**
+ * Host suffixes replies may be sent to when the token pins no `serviceUrl`.
+ *
+ * `smba.trafficmanager.net` is the one that matters in practice: that is where
+ * Teams itself serves the Connector API from (per-region, e.g.
+ * `https://smba.trafficmanager.net/amer/`), so omitting it would reject every
+ * real Teams reply. Compared as dot-prefixed suffixes (or exact matches) so a
+ * lookalike host like `botframework.com.attacker.example` cannot pass.
+ */
+const ALLOWED_SERVICE_HOSTS = ["botframework.com", "trafficmanager.net", "microsoft.com"];
+/**
+ * Whether `serviceUrl` is one replies may be sent to.
+ *
+ * Only ever the host the verified token was issued for. A Bot Service token is a
+ * bearer credential, so honoring the `serviceUrl` from the request BODY would
+ * let a replayed token point the bot's authenticated replies (and its token) at
+ * an attacker-controlled host. When the token carries no `serviceurl` claim the
+ * body value is accepted but restricted to Microsoft's own domains.
+ */
+export const isAllowedServiceUrl = (serviceUrl, tokenServiceUrl) => {
+    const normalize = (value) => value.replace(/\/+$/, "").toLowerCase();
+    if (tokenServiceUrl)
+        return normalize(serviceUrl) === normalize(tokenServiceUrl);
+    try {
+        const { protocol, hostname } = new URL(serviceUrl);
+        if (protocol !== "https:")
+            return false;
+        const host = hostname.toLowerCase();
+        return ALLOWED_SERVICE_HOSTS.some((allowed) => host === allowed || host.endsWith(`.${allowed}`));
+    }
+    catch (err) {
+        logger.debug("rejecting unparseable serviceUrl", { error: error.errorMessage(err) });
+        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"]}

package/lib/src/builder.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Compile a high-level {@link card.CardSpec} into a valid Adaptive Card 1.5
+ * document. The model drafts the small semantic spec; this is the single place
+ * that turns it into the element tree the `adaptivecards` renderer consumes and
+ * Teams accepts, so a card is well-formed by construction rather than by hoping
+ * the model produced correct schema.
+ *
+ * Element choices are deliberate and conservative:
+ * - the title is a bold, large `TextBlock`; the subtitle a lighter one;
+ * - body text is a wrapping `TextBlock` (Teams renders its Markdown subset);
+ * - facts become a single `FactSet` (the right control for key/value detail);
+ * - each action becomes an `Action.OpenUrl` - the one action safe to render in
+ *   any host with no back end wired up.
+ *
+ * @module
+ */
+import { card } from "@dbx-tools/shared-teams";
+/**
+ * Compile a semantic card spec into a full Adaptive Card document. The result
+ * validates against {@link card.adaptiveCardSchema} and is ready to render with
+ * the `adaptivecards` package or post to a Teams incoming webhook.
+ */
+export declare function buildAdaptiveCard(spec: card.CardSpec): card.AdaptiveCard;
+/**
+ * Compile a spec into the tool/route result shape: the validated Adaptive Card
+ * document plus the title echoed back for a caller that wants a label without
+ * re-reading the document.
+ */
+export declare function buildCardResult(spec: card.CardSpec): card.CardResult;

package/lib/src/builder.js

@@ -0,0 +1,96 @@
+/**
+ * Compile a high-level {@link card.CardSpec} into a valid Adaptive Card 1.5
+ * document. The model drafts the small semantic spec; this is the single place
+ * that turns it into the element tree the `adaptivecards` renderer consumes and
+ * Teams accepts, so a card is well-formed by construction rather than by hoping
+ * the model produced correct schema.
+ *
+ * Element choices are deliberate and conservative:
+ * - the title is a bold, large `TextBlock`; the subtitle a lighter one;
+ * - body text is a wrapping `TextBlock` (Teams renders its Markdown subset);
+ * - facts become a single `FactSet` (the right control for key/value detail);
+ * - each action becomes an `Action.OpenUrl` - the one action safe to render in
+ *   any host with no back end wired up.
+ *
+ * @module
+ */
+import { card } from "@dbx-tools/shared-teams";
+/** Build the title / subtitle heading block(s). */
+function headingElements(spec) {
+    const elements = [
+        {
+            type: "TextBlock",
+            text: spec.title,
+            size: "Large",
+            weight: "Bolder",
+            wrap: true,
+        },
+    ];
+    if (spec.subtitle) {
+        elements.push({
+            type: "TextBlock",
+            text: spec.subtitle,
+            isSubtle: true,
+            spacing: "None",
+            wrap: true,
+        });
+    }
+    return elements;
+}
+/** Build the optional body `TextBlock`. */
+function textElements(spec) {
+    if (!spec.text)
+        return [];
+    return [{ type: "TextBlock", text: spec.text, wrap: true }];
+}
+/** Build the optional `FactSet` from the spec's facts. */
+function factElements(spec) {
+    if (!spec.facts || spec.facts.length === 0)
+        return [];
+    return [
+        {
+            type: "FactSet",
+            facts: spec.facts.map((fact) => ({ title: fact.title, value: fact.value })),
+        },
+    ];
+}
+/** Build the `Action.OpenUrl` actions from the spec's link buttons. */
+function actionElements(spec) {
+    if (!spec.actions || spec.actions.length === 0)
+        return [];
+    return spec.actions.map((action) => ({
+        type: "Action.OpenUrl",
+        title: action.title,
+        url: action.url,
+    }));
+}
+/**
+ * Compile a semantic card spec into a full Adaptive Card document. The result
+ * validates against {@link card.adaptiveCardSchema} and is ready to render with
+ * the `adaptivecards` package or post to a Teams incoming webhook.
+ */
+export function buildAdaptiveCard(spec) {
+    const body = [
+        ...headingElements(spec),
+        ...textElements(spec),
+        ...factElements(spec),
+    ];
+    const actions = actionElements(spec);
+    const document = {
+        type: "AdaptiveCard",
+        $schema: card.ADAPTIVE_CARD_SCHEMA_URL,
+        version: card.ADAPTIVE_CARD_VERSION,
+        body,
+        ...(actions.length > 0 ? { actions } : {}),
+    };
+    return document;
+}
+/**
+ * Compile a spec into the tool/route result shape: the validated Adaptive Card
+ * document plus the title echoed back for a caller that wants a label without
+ * re-reading the document.
+ */
+export function buildCardResult(spec) {
+    return { title: spec.title, card: buildAdaptiveCard(spec) };
+}
+//# sourceMappingURL=data:application/json;base64,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