@microsoft/teams.apps
Version:
<p> <a href="https://www.npmjs.com/package/@microsoft/teams.apps" target="_blank"> <img src="https://img.shields.io/npm/v/@microsoft/teams.apps/latest" /> </a> <a href="https://www.npmjs.com/package/@microsoft/teams.apps?activeTab=code
424 lines • 38.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.isUnderServiceUrl = isUnderServiceUrl;
exports.isGraphRouteOpen = isGraphRouteOpen;
exports.openFileStream = openFileStream;
exports.collectStream = collectStream;
const stream_1 = require("stream");
const errors_1 = require("./errors");
const graph_share_1 = require("./graph-share");
/** How much of an error body to keep. Enough for a Graph error envelope, small enough to never matter. */
const ERROR_BODY_LIMIT = 2048;
/**
* Pull the human-readable part out of a Graph error envelope, falling back to the raw text.
*
* Graph replies `{ error: { code, message } }`, but a 401 can also come from the edge as HTML, so this must not assume JSON. Truncated because it lands in an exception message.
*/
function extractServiceError(raw) {
if (!raw) {
return undefined;
}
try {
const parsed = JSON.parse(raw);
const error = parsed?.error;
if (error?.code || error?.message) {
return truncate([error.code, error.message].filter(Boolean).join(': '));
}
}
catch {
// Not JSON. The raw text is still better than nothing.
}
return truncate(raw);
}
/** The `error.code` from a JSON error envelope, or `undefined` when the body is not one. */
function extractServiceErrorCode(raw) {
if (!raw) {
return undefined;
}
try {
const code = JSON.parse(raw)?.error?.code;
return typeof code === 'string' && code.trim() ? code.trim() : undefined;
}
catch {
return undefined;
}
}
function truncate(text) {
const collapsed = text.replace(/\s+/g, ' ').trim();
if (!collapsed) {
return undefined;
}
return collapsed.length > ERROR_BODY_LIMIT ? `${collapsed.slice(0, ERROR_BODY_LIMIT)}...` : collapsed;
}
/**
* Read at most one byte past {@link ERROR_BODY_LIMIT} from an error body and decode it as UTF-8.
*
* The bound has to be applied while reading rather than to the result. Appending a whole chunk and checking its size afterwards lets a single large chunk decide the buffer, and the host returning the error is not one the SDK controls. The one byte past the limit is what leaves {@link truncate} able to tell a body that merely reached the limit from one that ran past it.
*/
async function readBoundedUtf8(chunks) {
const kept = [];
let size = 0;
for await (const chunk of chunks) {
const remaining = ERROR_BODY_LIMIT + 1 - size;
kept.push(chunk.length > remaining ? chunk.subarray(0, remaining) : chunk);
size += Math.min(chunk.length, remaining);
if (size > ERROR_BODY_LIMIT) {
break;
}
}
return Buffer.concat(kept).toString('utf8');
}
/** Iterate a web stream so {@link readBoundedUtf8} can stop early, which `Response.text()` gives no opportunity to do. */
async function* streamChunks(stream) {
const reader = stream.getReader();
try {
for (;;) {
const { done, value } = await reader.read();
if (done) {
return;
}
if (value) {
yield value;
}
}
}
finally {
reader.releaseLock();
}
}
/**
* Whether `url` is under `serviceUrl`: both https, the same origin, and a path starting with the service URL's path, compared case-sensitively.
*
* Both are parsed first, so dot segments are resolved before the comparison and cannot climb out of the service URL's path.
*/
function isUnderServiceUrl(url, serviceUrl) {
if (!serviceUrl) {
return false;
}
let target;
let base;
try {
target = new URL(url);
base = new URL(serviceUrl);
}
catch {
return false;
}
if (base.protocol !== 'https:' || target.origin !== base.origin) {
return false;
}
// Paths are case-sensitive, so only the hex digits of percent escapes are normalized, since `%2f` and `%2F` are the same escape.
const normalizeEscapes = (path) => path.replace(/%[0-9a-f]{2}/gi, (escape) => escape.toUpperCase());
// Normalizes to exactly one trailing `/` so a path such as `/amer` cannot match `/americas`.
const basePath = `${base.pathname.replace(/\/+$/, '')}/`;
return normalizeEscapes(target.pathname).startsWith(normalizeEscapes(basePath));
}
/**
* Whether a file that arrived with only a `contentUrl` may be read through Graph in this scope, as this actor.
*
* Shared by the attachment mapper and the download dispatcher so the two cannot drift: a file `list()` surfaces on its `contentUrl` is always one `download()` will open. `personal` is open to every actor. `groupChat` and `channel` are open only to an agentic user, the only identity the platform delivers files to there at this time. Any other scope stays closed.
*/
function isGraphRouteOpen(scope, actor) {
if (scope === 'personal') {
return true;
}
return actor === 'agenticUser' && (scope === 'groupChat' || scope === 'channel');
}
/**
* Open a byte stream for an inbound file, keyed on its conversation scope so every scope's receive path extends this one place rather than branching in callers.
*
* `personal` takes either route. In `groupChat` and `channel` the platform delivers file attachments only to an agentic user, each carrying just a `contentUrl`, so they open only through Graph, as {@link isGraphRouteOpen} decides. Everything else throws {@link FileScopeNotSupportedError}.
*/
async function openFileStream(target, options) {
// Inline images live on the Bot API, so neither file route nor its scope restriction applies.
if (target.attachmentStyle === 'inlineImage') {
return openInlineImageStream(target, options);
}
if (target.scope === 'personal') {
return openPersonalFileStream(target, options);
}
// A `downloadUrl` outside `personal` keeps the scope error: that route is unvalidated there, and Graph is never substituted for a URL the platform supplied.
if (!target.downloadUrl && target.contentUrl && isGraphRouteOpen(target.scope, options?.credential?.actor)) {
return openGraphFileStream(target, target.contentUrl, options);
}
throw new errors_1.FileScopeNotSupportedError(target.scope);
}
async function openPersonalFileStream(target, options) {
const url = target.downloadUrl;
// The Agentic User case: a browsable `contentUrl` arrives in place of a `downloadUrl`, so Graph is the only route to the bytes.
if (!url) {
if (!target.contentUrl) {
throw new Error('cannot download personal file: no download URL is available');
}
return openGraphFileStream(target, target.contentUrl, options);
}
// Unreachable today: the platform's agentic path never sets a download URL, which is the only reason the arm above always fires for an agent. If that ever changes, the bytes still arrive and nothing fails, but they are fetched unauthenticated and attributed to nobody, so the switch away from the agent's own identity would be invisible except in an audit log. Warn rather than reroute: rerouting would ignore a working URL, which is the escalation the automatic-credential rule exists to prevent.
if (options?.credential?.actor === 'agenticUser') {
options.log?.warn('an agentic turn received a file carrying a pre-authorized download URL, which the platform did not previously send to agents. The SDK is using that URL, so these bytes are not attributed to the agentic user.');
}
if (!/^https:\/\//i.test(url)) {
throw new Error('cannot download file: download URL must use https');
}
const response = await requestFile(url, options);
if (response.status === 401 || response.status === 403) {
response.discard();
// Terminal. The URL carried its own credential and that credential has lapsed, and the SDK does not perform a fallback via app identity or user-delegated permissions on the developer's behalf. The file has to be sent again.
throw new errors_1.FileUrlExpiredError(options?.priorFetchSucceeded ? 'reread' : 'firstFetch');
}
if (!response.ok || !response.stream) {
response.discard();
throw new Error(`failed to download file: ${response.status} ${response.statusText}`.trim());
}
const contentType = response.contentType ?? target.contentType ?? 'application/octet-stream';
return { stream: response.stream, sourceUrl: url, contentType };
}
/**
* Fetch bytes by resolving the item through Graph's `/shares` endpoint.
*
* Unlike the pre-authorized path, which strips `Authorization`, this is an ordinary authenticated Graph call and fails without a bearer token.
*/
async function openGraphFileStream(target, sharingUrl, options) {
const actor = options?.credential?.actor;
const { token, failure } = await tryResolveToken(options);
// Detectable before any HTTP call, so a missing consent names itself instead of arriving as an opaque Graph 401.
if (!token || carriesNoGraphPermissions(token)) {
// An acquisition that threw is not the same as an identity with no permissions, and the guidance for one is wrong for the other, so the cause is carried rather than dropped.
throw new errors_1.FileCredentialError(actor, failure);
}
const url = (0, graph_share_1.buildDriveItemContentUrl)(sharingUrl, options?.credential?.baseUrlRoot);
options?.log?.debug(`resolving bytes through Graph /shares as '${actor}'`);
const response = await requestFile(url, options, token);
if (response.status === 401 || response.status === 403) {
// The status is carried rather than collapsed: a 401 means the token itself was rejected and a 403 means the identity lacks the grant, and those have different remedies. Within a 403, an unconsented scope and a file never shared are still indistinguishable, so the service's own text is carried too.
throw new errors_1.FileAccessError(response.status, actor, extractServiceError(await response.readText()));
}
if (!response.ok || !response.stream) {
// Carry Graph's own text and name the identity, as the 401/403 arm does.
// An unexpected status here is often diagnosable only from the service message, so discarding it would leave the caller a bare status code.
const details = extractServiceError(await response.readText());
throw new Error(`failed to download file through Graph as '${actor ?? 'app'}': ${response.status} ${response.statusText}`.trim() +
(details ? ` (${details})` : ''));
}
const contentType = response.contentType ?? target.contentType ?? 'application/octet-stream';
return { stream: response.stream, sourceUrl: url, contentType };
}
/**
* Fetch an inline image's bytes from the Bot API with the turn's Bot API token.
*
* The token is sent only to a URL under {@link BotApiCredential.serviceUrl}.
*/
async function openInlineImageStream(target, options) {
const url = target.contentUrl;
if (!url) {
throw new Error('cannot download inline image: no content URL is available');
}
if (!/^https:\/\//i.test(url)) {
throw new Error('cannot download inline image: content URL must use https');
}
const credential = options?.botApiCredential;
if (!credential) {
throw new Error('cannot download inline image: no Bot API token is available');
}
if (!isUnderServiceUrl(url, credential.serviceUrl)) {
throw new Error('cannot download inline image: content URL is not under the activity\'s service URL');
}
const actor = credential.actor;
const token = await credential.token();
if (!token) {
throw new Error('cannot download inline image: no Bot API token is available');
}
options?.log?.debug(`reading inline image bytes from the Bot API as '${actor}'`);
const response = await requestFile(url, options, token);
if (response.status === 415) {
const body = await response.readText();
throw new errors_1.InlineImageTransformationError(response.status, actor, extractServiceError(body), extractServiceErrorCode(body));
}
if (response.status === 401 || response.status === 403) {
throw new errors_1.InlineImageAccessError(response.status, actor, extractServiceError(await response.readText()));
}
if (!response.ok || !response.stream) {
const details = extractServiceError(await response.readText());
throw new Error(`failed to download inline image as '${actor}': ${response.status} ${response.statusText}`.trim() +
(details ? ` (${details})` : ''));
}
const contentType = response.contentType ?? target.contentType ?? 'application/octet-stream';
return { stream: response.stream, sourceUrl: url, contentType };
}
/**
* Issue the byte request.
*
* `bearer` is a parameter rather than downloader configuration because the two paths need opposite behaviour: the pre-authorized URL must send no `Authorization`, Graph requires one. Hoisting auth into shared setup breaks the first case, which is the dangerous direction: it leaks a bot token to third-party storage for every bot working today, whereas forgetting it on the Graph path fails immediately and only there.
*/
/**
* Resolve a Graph token without throwing.
*
* On the expiry path the caller already holds a more precise error, so an acquisition failure must leave it intact rather than surfacing as an untyped rejection.
*/
async function tryResolveToken(options) {
if (!options?.credential) {
return {};
}
try {
return { token: await options.credential.token() };
}
catch (err) {
const failure = err.message;
options.log?.debug(`could not acquire a Graph token: ${failure}`);
return { failure };
}
}
/**
* The permissions a token carries, as a flat list, or `undefined` when the token is not a decodable JWT.
*
* An app-only token lists application permissions in `roles`; a delegated or agentic-user token lists scopes in `scp`, space-delimited and absent entirely when there are none. `undefined` and `[]` mean different things and both callers depend on the difference: undecodable is "cannot tell", empty is "decoded, and there is nothing there".
*/
function permissionsOf(token) {
try {
const payload = token.split('.')[1];
if (!payload) {
return undefined;
}
const claims = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
const roles = Array.isArray(claims.roles) ? claims.roles.filter((r) => typeof r === 'string') : [];
const scopes = typeof claims.scp === 'string' ? claims.scp.trim().split(/\s+/).filter(Boolean) : [];
return [...roles, ...scopes];
}
catch {
return undefined;
}
}
/**
* Detect a credential that cannot reach a drive item, before spending a request to find out.
*
* Real Graph answers such a token with a `401 generalException` or a `403`, indistinguishable on the wire from a genuine denial but fixed in the identity's consented permissions rather than in file sharing.
*
* The predicate is "carries no file-capable permission", not "carries none at all". Emptiness was sufficient while the app rung was the concern, because an app registration with no Graph permissions really does return `roles: []`. It is not sufficient for an Agentic User under `.default`, where a blueprint consented to unrelated scopes such as `Mail.Send` returns a populated `scp` that passes an emptiness check and then fails late as an ambiguous 403.
*
* Any `Files.*` or `Sites.*` permission is admitted, which is deliberately generous. `Sites.Selected` is a known false positive: it begins with `Sites.` but grants nothing until an admin allowlists specific sites. A false positive here degrades to the previous behaviour of calling Graph and reporting what it says, which is the safe direction to be wrong in.
*
* Fails open on an undecodable token, which proceeds to the call rather than blocking a fetch that might have worked.
*/
function carriesNoGraphPermissions(token) {
const permissions = permissionsOf(token);
if (permissions === undefined) {
return false;
}
return !permissions.some((p) => /^(files|sites)\./i.test(p));
}
async function requestFile(url, options, bearer) {
if (options?.fetch) {
return fromFetchResponse(await options.fetch(url, {
signal: options.signal,
...(bearer ? { headers: { Authorization: `Bearer ${bearer}` } } : {}),
}));
}
if (options?.httpClient) {
return requestViaHttpClient(url, options.httpClient, options.signal, bearer);
}
throw new Error('cannot download file: no HTTP client is available');
}
async function requestViaHttpClient(url, client, signal, bearer) {
const originalHost = new URL(url).host.toLowerCase();
const response = await client.get(url, {
responseType: 'stream',
signal,
// No bearer means the pre-authorized path, whose URL carries its own credential and can be rejected if a bot token rides along. `token` only suppresses the token-derived header, so a client-configured default `Authorization` must be overridden too, or `withConfig` merges it in and sends it to third-party storage.
token: () => bearer,
headers: { Authorization: bearer ? `Bearer ${bearer}` : undefined },
// We map 401/403 onto typed errors ourselves, so keep axios from throwing first.
validateStatus: () => true,
// Storage answers with a 302 to the host actually holding the bytes, so redirects have to be followed. They must not be followed *down* to plaintext: an `https` to `http` hop would put the file's bytes on the wire in the clear.
beforeRedirect: (redirect) => {
if (redirect.protocol !== 'https:') {
throw new Error(`cannot download file: a redirect destination must use https, got "${redirect.protocol}//${redirect.host ?? redirect.hostname}". The file's bytes would cross that hop in the clear.`);
}
// The redirect follower keeps `Authorization` on a hop to a subdomain, so the token is dropped here whenever the host changes.
if (String(redirect.host ?? redirect.hostname ?? '').toLowerCase() !== originalHost) {
for (const name of Object.keys(redirect.headers ?? {})) {
if (name.toLowerCase() === 'authorization') {
delete redirect.headers[name];
}
}
}
},
});
const body = response.data;
const contentTypeHeader = response.headers?.['content-type'];
return {
status: response.status,
statusText: response.statusText ?? '',
ok: response.status >= 200 && response.status < 300,
contentType: typeof contentTypeHeader === 'string' ? contentTypeHeader : undefined,
// `packages/apps` is Node-only, so adapting Node's `Readable` to a web `ReadableStream` is safe here.
stream: body ? stream_1.Readable.toWeb(body) : undefined,
discard: () => body?.destroy(),
readText: async () => {
if (!body) {
return undefined;
}
try {
const text = await readBoundedUtf8(body);
body.destroy();
return truncate(text);
}
catch {
body.destroy();
return undefined;
}
},
};
}
function fromFetchResponse(response) {
return {
status: response.status,
statusText: response.statusText,
ok: response.ok,
contentType: response.headers.get('content-type') ?? undefined,
stream: response.body ?? undefined,
discard: () => {
void response.body?.cancel().catch(() => { });
},
readText: async () => {
if (!response.body) {
return undefined;
}
try {
return truncate(await readBoundedUtf8(streamChunks(response.body)));
}
catch {
return undefined;
}
},
};
}
/**
* Read a byte stream to completion into a single `Uint8Array`.
*/
async function collectStream(stream) {
const reader = stream.getReader();
const chunks = [];
let total = 0;
try {
for (;;) {
const { done, value } = await reader.read();
if (done) {
break;
}
if (value) {
total += value.byteLength;
chunks.push(value);
}
}
}
finally {
reader.releaseLock();
}
const out = new Uint8Array(total);
let offset = 0;
for (const chunk of chunks) {
out.set(chunk, offset);
offset += chunk.byteLength;
}
return out;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"download.js","sourceRoot":"","sources":["../../src/files/download.ts"],"names":[],"mappings":"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"}