@oneuptime/common 11.7.0 → 11.7.2

package/build/dist/Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams.js

@@ -28,8 +28,9 @@ import UserService from "../../../Services/UserService";
 // Import database utilities
 import QueryHelper from "../../../Types/Database/QueryHelper";
 import SortOrder from "../../../../Types/BaseDatabase/SortOrder";
+import LIMIT_MAX from "../../../../Types/Database/LimitMax";
 // Bot Framework SDK imports
-import { CloudAdapter, ConfigurationBotFrameworkAuthentication, TeamsActivityHandler, MessageFactory, } from "botbuilder";
+import { CloudAdapter, ConfigurationBotFrameworkAuthentication, TeamsActivityHandler, TeamsInfo, MessageFactory, } from "botbuilder";
 // Teams action handlers and types
 import MicrosoftTeamsAuthAction from "./Actions/Auth";
 import MicrosoftTeamsIncidentActions from "./Actions/Incident";
@@ -227,8 +228,28 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             const now = OneUptimeDate.getCurrentDate();
             const expiryDate = OneUptimeDate.addRemoveSeconds(now, expiresIn - 300); // Subtrutes buffer
             logger.debug(`Token expiry calculated: ${OneUptimeDate.toString(expiryDate)}`);
-            // Update the miscData with new token and expiry
-            const updatedMiscData = Object.assign(Object.assign({}, data.miscData), { appAccessToken: newAccessToken, appAccessTokenExpiresAt: OneUptimeDate.toString(expiryDate), lastAppTokenIssuedAt: OneUptimeDate.toString(now), tenantId: data.tenantId });
+            /*
+             * Merge the token fields into a FRESH read of miscData instead of the
+             * snapshot taken before the OAuth round-trip. The snapshot can be
+             * seconds old, and writing it back verbatim would erase concurrent
+             * miscData updates — in particular chats captured into availableChats
+             * by bot install events, which cannot be re-derived from Graph.
+             */
+            let latestMiscData = data.miscData;
+            try {
+                const latestProjectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+                    projectId: data.projectId,
+                    workspaceType: WorkspaceType.MicrosoftTeams,
+                });
+                if (latestProjectAuth === null || latestProjectAuth === void 0 ? void 0 : latestProjectAuth.miscData) {
+                    latestMiscData = latestProjectAuth.miscData;
+                }
+            }
+            catch (err) {
+                logger.debug("Could not re-read miscData before token refresh write");
+                logger.debug(err);
+            }
+            const updatedMiscData = Object.assign(Object.assign({}, latestMiscData), { appAccessToken: newAccessToken, appAccessTokenExpiresAt: OneUptimeDate.toString(expiryDate), lastAppTokenIssuedAt: OneUptimeDate.toString(now), tenantId: data.tenantId });
             logger.debug("Saving updated token to database");
             // Save the updated token to the database
             await WorkspaceProjectAuthTokenService.refreshAuthToken({
@@ -685,6 +706,7 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
         return null;
     }
     static async sendMessage(data) {
+        var _a;
         logger.debug("=== MicrosoftTeamsUtil.sendMessage called ===", {
             projectId: data.projectId.toString(),
         });
@@ -803,6 +825,46 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
                 });
             }
         }
+        // Send to Teams chats (group / personal chats the OneUptime app was added to).
+        const chatIdsToPostTo = data.workspaceMessagePayload.chatIds || [];
+        if (chatIdsToPostTo.length > 0) {
+            logger.debug(`Processing ${chatIdsToPostTo.length} chat ids`);
+            const availableChats = await this.getChatsForProject({
+                projectId: data.projectId,
+            });
+            for (const chatId of chatIdsToPostTo) {
+                const chatAsChannel = {
+                    id: chatId,
+                    name: ((_a = availableChats[chatId]) === null || _a === void 0 ? void 0 : _a.name) || chatId,
+                    workspaceType: WorkspaceType.MicrosoftTeams,
+                };
+                try {
+                    let lastThread;
+                    for (const adaptiveCard of adaptiveCards) {
+                        lastThread = await this.sendAdaptiveCardToChat({
+                            chatId: chatId,
+                            adaptiveCard: adaptiveCard,
+                            projectId: data.projectId,
+                        });
+                    }
+                    if (lastThread) {
+                        logger.debug(`Message sent successfully to chat ${chatAsChannel.name}, thread: ${JSON.stringify(lastThread)}`);
+                        workspaceMessageResponse.threads.push(lastThread);
+                    }
+                }
+                catch (e) {
+                    logger.error(`Error sending message to chat ID ${chatId}:`, {
+                        projectId: data.projectId.toString(),
+                        chatId: chatId,
+                    });
+                    logger.error(e);
+                    workspaceMessageResponse.errors.push({
+                        channel: chatAsChannel,
+                        error: e instanceof Error ? e.message : String(e),
+                    });
+                }
+            }
+        }
         logger.debug("=== Message sending completed ===");
         logger.debug(`Final thread count: ${workspaceMessageResponse.threads.length}`);
         logger.debug(`Final response: ${JSON.stringify(workspaceMessageResponse)}`);
@@ -902,6 +964,92 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             throw error;
         }
     }
+    /*
+     * Sends an adaptive card to a Teams group chat or personal (1:1) chat via a
+     * proactive Bot Framework message. The OneUptime app must have been added to
+     * the chat — Graph has no app-only permission for posting to chats, so the
+     * bot conversation is the only supported transport.
+     */
+    static async sendAdaptiveCardToChat(data) {
+        var _a;
+        logger.debug("sendAdaptiveCardToChat called with data:");
+        logger.debug(`Chat ID: ${data.chatId}`);
+        logger.debug(`Project ID: ${data.projectId.toString()}`);
+        try {
+            const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+                projectId: data.projectId,
+                workspaceType: WorkspaceType.MicrosoftTeams,
+            });
+            if (!projectAuth || !projectAuth.miscData) {
+                throw new BadDataException("Microsoft Teams integration not found for this project");
+            }
+            const miscData = projectAuth.miscData;
+            if (!miscData.botId) {
+                throw new BadDataException("Bot ID not found in Microsoft Teams integration");
+            }
+            const tenantId = projectAuth.workspaceProjectId;
+            if (!tenantId) {
+                throw new BadDataException("Tenant ID not found in Microsoft Teams integration");
+            }
+            if (!MicrosoftTeamsAppClientId) {
+                throw new BadDataException("Microsoft Teams App Client ID not configured");
+            }
+            const chat = (_a = miscData.availableChats) === null || _a === void 0 ? void 0 : _a[data.chatId];
+            if (!chat) {
+                throw new BadDataException("This chat is not connected to OneUptime. Please add the OneUptime app to the chat in Microsoft Teams and try again.");
+            }
+            const adapter = this.getBotAdapter();
+            const conversationReference = {
+                bot: {
+                    id: MicrosoftTeamsAppClientId,
+                    name: "OneUptime Bot",
+                },
+                conversation: {
+                    id: chat.id,
+                    name: chat.name,
+                    isGroup: chat.chatType === "groupChat",
+                    conversationType: chat.chatType,
+                    tenantId: tenantId,
+                },
+                channelId: "msteams",
+                /*
+                 * Fallback is the commercial-cloud global endpoint; the serviceUrl
+                 * captured from bot activities is preferred (required for GCC/DoD).
+                 */
+                serviceUrl: chat.serviceUrl || "https://smba.trafficmanager.net/teams/",
+            };
+            logger.debug(`Chat conversation reference: ${JSON.stringify(conversationReference)}`);
+            let messageId = "";
+            await adapter.continueConversationAsync(MicrosoftTeamsAppClientId, conversationReference, async (context) => {
+                logger.debug("Sending adaptive card to chat as proactive message");
+                const message = MessageFactory.attachment({
+                    contentType: "application/vnd.microsoft.card.adaptive",
+                    content: data.adaptiveCard,
+                });
+                const response = await context.sendActivity(message);
+                messageId = (response === null || response === void 0 ? void 0 : response.id) || "";
+                logger.debug(`Chat message sent with ID: ${messageId}`);
+            });
+            const thread = {
+                channel: {
+                    id: chat.id,
+                    name: chat.name,
+                    workspaceType: WorkspaceType.MicrosoftTeams,
+                },
+                threadId: messageId,
+            };
+            logger.debug(`Sent message to chat via Bot Framework: ${JSON.stringify(thread)}`);
+            return thread;
+        }
+        catch (error) {
+            logger.error("Error sending adaptive card to chat via Bot Framework:", {
+                projectId: data.projectId.toString(),
+                chatId: data.chatId,
+            });
+            logger.error(error);
+            throw error;
+        }
+    }
     static async getWorkspaceChannelFromChannelId(data) {
         var _a;
         logger.debug("=== getWorkspaceChannelFromChannelId called ===", {
@@ -1243,6 +1391,25 @@ class MicrosoftTeamsUtil extends WorkspaceBase {
             logger.debug("Message activity originates from the bot itself; ignoring to prevent a loop");
             return;
         }
+        /*
+         * Backfill chat capture from inbound messages. Chats where the app was
+         * installed before chat capture shipped never fire install events — per
+         * Microsoft docs, app upgrades only send installationUpdate when the
+         * manifest's bot is added or removed, so a version bump alone re-fires
+         * nothing. Messaging the bot in a chat is the documented recovery path,
+         * and this also keeps the stored serviceUrl fresh (docs: verify the
+         * stored serviceUrl when a new message arrives). Cheap when the chat is
+         * already captured (single read, no roster fetch, no write).
+         */
+        const messageConversationType = conversation["conversationType"] || "";
+        if (messageConversationType === "personal" ||
+            messageConversationType === "groupChat") {
+            await this.captureChatFromBotActivity({
+                activity: data.activity,
+                turnContext: data.turnContext,
+                onlyIfMissingOrStale: true,
+            });
+        }
         // If this is actually an Adaptive Card submit wrapped as a message, route to invoke handler
         if (possibleActionValue["action"] ||
             ((_b = possibleActionValue["data"]) === null || _b === void 0 ? void 0 : _b["action"])) {
@@ -2226,10 +2393,23 @@ All monitoring checks are passing normally.`;
         const botWasAdded = membersAdded.some((member) => {
             return member["id"] === recipientId;
         });
+        const botWasRemoved = membersRemoved.some((member) => {
+            return member["id"] === recipientId;
+        });
         if (botWasAdded) {
             logger.debug("OneUptime bot was added to a Teams conversation");
+            await this.captureChatFromBotActivity({
+                activity: data.activity,
+                turnContext: data.turnContext,
+            });
             await this.sendWelcomeAdaptiveCard(data.turnContext);
         }
+        if (botWasRemoved) {
+            logger.debug("OneUptime bot was removed from a Teams conversation");
+            await this.removeChatFromBotActivity({
+                activity: data.activity,
+            });
+        }
     }
     static async handleInstallationUpdateActivity(data) {
         // Handle bot installation/uninstallation
@@ -2237,13 +2417,302 @@ All monitoring checks are passing normally.`;
         const conversation = data.activity["conversation"] || {};
         logger.debug(`Installation update - Action: ${action}`);
         logger.debug(`Conversation: ${JSON.stringify(conversation)}`);
-        if (action === "add") {
+        /*
+         * Teams sends "add-upgrade" / "remove-upgrade" when an app upgrade adds
+         * or removes the bot in the manifest (per Microsoft docs, a plain
+         * version bump fires no installationUpdate at all). Treat them the same
+         * as add/remove. Chats installed before chat capture shipped are
+         * backfilled from inbound messages in handleBotMessageActivity instead.
+         */
+        if (action === "add" || action === "add-upgrade") {
             logger.debug("OneUptime bot was installed");
+            await this.captureChatFromBotActivity({
+                activity: data.activity,
+                turnContext: data.turnContext,
+            });
         }
-        else if (action === "remove") {
+        else if (action === "remove" || action === "remove-upgrade") {
             logger.debug("OneUptime bot was uninstalled");
+            await this.removeChatFromBotActivity({
+                activity: data.activity,
+            });
+        }
+    }
+    /*
+     * Chats (group chats and personal 1:1 chats) cannot be listed with the
+     * app-only Graph token, so the only way OneUptime learns about them is by
+     * capturing the conversation details when the OneUptime app is added to a
+     * chat. These captured chats power the "post to chat" notification rules.
+     */
+    static getChatTypeFromConversation(conversation) {
+        const conversationType = conversation["conversationType"] || "";
+        if (conversationType === "personal" || conversationType === "groupChat") {
+            return conversationType;
+        }
+        return null; // channels and meetings are not chats.
+    }
+    static getChatDisplayName(data) {
+        /*
+         * Keep well under the 100-char ShortText columns that store the chat
+         * name in notification logs — Teams chat topics can be much longer.
+         */
+        const maxNameLength = 80;
+        const truncate = (name) => {
+            return name.length > maxNameLength
+                ? `${name.substring(0, maxNameLength - 1)}…`
+                : name;
+        };
+        if (data.topic && data.topic.trim()) {
+            return truncate(data.topic.trim());
+        }
+        const memberNames = data.memberNames.filter((name) => {
+            return Boolean(name && name.trim());
+        });
+        if (data.chatType === "personal") {
+            return memberNames[0] ? truncate(`${memberNames[0]}`) : "Personal chat";
+        }
+        if (memberNames.length === 0) {
+            return "Group chat";
+        }
+        const maxNamesToShow = 3;
+        const shownNames = memberNames.slice(0, maxNamesToShow);
+        const remainingCount = memberNames.length - shownNames.length;
+        if (remainingCount > 0) {
+            return truncate(`${shownNames.join(", ")} + ${remainingCount} more`);
+        }
+        return truncate(shownNames.join(", "));
+    }
+    /*
+     * Returns true when every connected project of this tenant already has
+     * this chat stored with the same service URL — i.e. there is nothing to
+     * capture or refresh.
+     */
+    static async isChatCapturedForTenant(data) {
+        var _a, _b;
+        const projectAuths = await WorkspaceProjectAuthTokenService.findBy({
+            query: {
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                workspaceProjectId: data.tenantId,
+            },
+            select: {
+                _id: true,
+                miscData: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        if (projectAuths.length === 0) {
+            return true; // no connected projects — nothing to capture into.
+        }
+        for (const projectAuth of projectAuths) {
+            const chat = (_b = (_a = projectAuth.miscData) === null || _a === void 0 ? void 0 : _a.availableChats) === null || _b === void 0 ? void 0 : _b[data.chatId];
+            if (!chat) {
+                return false;
+            }
+            if (data.serviceUrl && chat.serviceUrl !== data.serviceUrl) {
+                return false; // stored serviceUrl is stale.
+            }
+        }
+        return true;
+    }
+    static async captureChatFromBotActivity(data) {
+        var _a, _b;
+        try {
+            const conversation = data.activity["conversation"] || {};
+            const chatType = this.getChatTypeFromConversation(conversation);
+            if (!chatType) {
+                return; // bot was added to a team channel, not a chat.
+            }
+            const chatId = conversation["id"] || "";
+            if (!chatId) {
+                logger.debug("No conversation id found on chat activity. Skipping.");
+                return;
+            }
+            const channelData = data.activity["channelData"] || {};
+            const tenantId = ((_a = channelData["tenant"]) === null || _a === void 0 ? void 0 : _a["id"]) ||
+                conversation["tenantId"] ||
+                "";
+            if (!tenantId) {
+                logger.debug("No tenant id found on chat activity. Skipping.");
+                return;
+            }
+            const activityServiceUrl = data.activity["serviceUrl"] ||
+                data.turnContext.activity.serviceUrl ||
+                undefined;
+            /*
+             * On the message-backfill path, skip the roster fetch and DB writes
+             * when the chat is already captured with a fresh serviceUrl.
+             */
+            if (data.onlyIfMissingOrStale) {
+                const alreadyCaptured = await this.isChatCapturedForTenant({
+                    tenantId: tenantId,
+                    chatId: chatId,
+                    serviceUrl: activityServiceUrl,
+                });
+                if (alreadyCaptured) {
+                    return;
+                }
+            }
+            // Resolve a human friendly name for the chat.
+            const topic = conversation["name"];
+            let memberNames = [];
+            try {
+                const botId = (_b = data.turnContext.activity.recipient) === null || _b === void 0 ? void 0 : _b.id;
+                /*
+                 * TeamsInfo.getMembers is deprecated — page through the roster
+                 * instead. Chats return the full roster in one page in practice.
+                 */
+                const members = [];
+                let continuationToken = undefined;
+                do {
+                    const page = await TeamsInfo.getPagedMembers(data.turnContext, 500, continuationToken);
+                    members.push(...(page.members || []));
+                    continuationToken = page.continuationToken;
+                } while (continuationToken);
+                memberNames = members
+                    .filter((member) => {
+                    return member.id !== botId;
+                })
+                    .map((member) => {
+                    return member.name || "";
+                });
+            }
+            catch (err) {
+                logger.debug("Could not fetch chat members for chat name resolution");
+                logger.debug(err);
+            }
+            const chat = {
+                id: chatId,
+                name: this.getChatDisplayName({
+                    chatType: chatType,
+                    topic: topic,
+                    memberNames: memberNames,
+                }),
+                chatType: chatType,
+                serviceUrl: activityServiceUrl,
+                addedAt: OneUptimeDate.getCurrentDate().toISOString(),
+            };
+            await this.saveChatToProjectAuthTokens({
+                tenantId: tenantId,
+                chat: chat,
+            });
+            logger.debug(`Captured Microsoft Teams chat ${chatId} (${chat.name}) for tenant ${tenantId}`);
+        }
+        catch (err) {
+            logger.error("Error capturing Microsoft Teams chat from bot activity:");
+            logger.error(err);
+        }
+    }
+    static async removeChatFromBotActivity(data) {
+        var _a;
+        try {
+            const conversation = data.activity["conversation"] || {};
+            const chatType = this.getChatTypeFromConversation(conversation);
+            if (!chatType) {
+                return;
+            }
+            const chatId = conversation["id"] || "";
+            const channelData = data.activity["channelData"] || {};
+            const tenantId = ((_a = channelData["tenant"]) === null || _a === void 0 ? void 0 : _a["id"]) ||
+                conversation["tenantId"] ||
+                "";
+            if (!chatId || !tenantId) {
+                return;
+            }
+            await this.removeChatFromProjectAuthTokens({
+                tenantId: tenantId,
+                chatId: chatId,
+            });
+            logger.debug(`Removed Microsoft Teams chat ${chatId} for tenant ${tenantId}`);
+        }
+        catch (err) {
+            logger.error("Error removing Microsoft Teams chat from bot activity:");
+            logger.error(err);
+        }
+    }
+    static async saveChatToProjectAuthTokens(data) {
+        /*
+         * A tenant can be connected to more than one OneUptime project, and the
+         * install event does not say which project it belongs to — so save the
+         * chat on every project connected to this tenant.
+         */
+        const projectAuths = await WorkspaceProjectAuthTokenService.findBy({
+            query: {
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                workspaceProjectId: data.tenantId,
+            },
+            select: {
+                _id: true,
+                miscData: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const projectAuth of projectAuths) {
+            const miscData = Object.assign({}, (projectAuth.miscData || {}));
+            miscData.availableChats = Object.assign(Object.assign({}, (miscData.availableChats || {})), { [data.chat.id]: data.chat });
+            await WorkspaceProjectAuthTokenService.updateOneById({
+                id: projectAuth.id,
+                data: {
+                    miscData: miscData,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
+        }
+    }
+    static async removeChatFromProjectAuthTokens(data) {
+        const projectAuths = await WorkspaceProjectAuthTokenService.findBy({
+            query: {
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                workspaceProjectId: data.tenantId,
+            },
+            select: {
+                _id: true,
+                miscData: true,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+                isRoot: true,
+            },
+        });
+        for (const projectAuth of projectAuths) {
+            const miscData = Object.assign({}, (projectAuth.miscData || {}));
+            if (!miscData.availableChats || !miscData.availableChats[data.chatId]) {
+                continue;
+            }
+            const availableChats = Object.assign({}, miscData.availableChats);
+            delete availableChats[data.chatId];
+            miscData.availableChats = availableChats;
+            await WorkspaceProjectAuthTokenService.updateOneById({
+                id: projectAuth.id,
+                data: {
+                    miscData: miscData,
+                },
+                props: {
+                    isRoot: true,
+                },
+            });
         }
     }
+    static async getChatsForProject(data) {
+        const projectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+            projectId: data.projectId,
+            workspaceType: WorkspaceType.MicrosoftTeams,
+        });
+        if (!projectAuth || !projectAuth.miscData) {
+            return {};
+        }
+        return (projectAuth.miscData.availableChats || {});
+    }
     /**
      * Process Bot Framework activity using the botbuilder SDK adapter.processActivity
      * This replaces the manual JWT validation and activity handling with proper SDK methods
@@ -2290,6 +2759,15 @@ All monitoring checks are passing normally.`;
                         });
                         await next();
                     });
+                    this.onMembersRemoved(async (context, next) => {
+                        logger.debug("Handling members removed activity: " +
+                            JSON.stringify(context.activity));
+                        await MicrosoftTeamsUtil.handleConversationUpdateActivity({
+                            activity: context.activity,
+                            turnContext: context,
+                        });
+                        await next();
+                    });
                     this.onInstallationUpdateAdd(async (context, next) => {
                         logger.debug("Handling installation update add activity: " +
                             JSON.stringify(context.activity));
@@ -2299,6 +2777,15 @@ All monitoring checks are passing normally.`;
                         });
                         await next();
                     });
+                    this.onInstallationUpdateRemove(async (context, next) => {
+                        logger.debug("Handling installation update remove activity: " +
+                            JSON.stringify(context.activity));
+                        await MicrosoftTeamsUtil.handleInstallationUpdateActivity({
+                            activity: context.activity,
+                            turnContext: context,
+                        });
+                        await next();
+                    });
                 }
                 async onInvokeActivity(context) {
                     logger.debug("Handling invoke activity: " + JSON.stringify(context.activity));
@@ -2562,8 +3049,27 @@ All monitoring checks are passing normally.`;
                 return acc;
             }, {});
             logger.debug(`Processed ${Object.keys(availableTeams).length} teams`);
-            // Update project auth token with new teams
-            const miscData = projectAuth.miscData || {};
+            /*
+             * Update project auth token with new teams. Re-read miscData first —
+             * the snapshot from the start of this method is stale by the length
+             * of the paginated Graph fetch, and writing it back verbatim would
+             * erase concurrent updates (e.g. chats captured into availableChats
+             * by bot install events, which cannot be re-derived).
+             */
+            let miscData = projectAuth.miscData || {};
+            try {
+                const latestProjectAuth = await WorkspaceProjectAuthTokenService.getProjectAuth({
+                    projectId: data.projectId,
+                    workspaceType: WorkspaceType.MicrosoftTeams,
+                });
+                if (latestProjectAuth === null || latestProjectAuth === void 0 ? void 0 : latestProjectAuth.miscData) {
+                    miscData = latestProjectAuth.miscData;
+                }
+            }
+            catch (err) {
+                logger.debug("Could not re-read miscData before teams refresh write");
+                logger.debug(err);
+            }
             miscData.availableTeams = availableTeams;
             miscData.tenantId = tenantId;
             await WorkspaceProjectAuthTokenService.updateOneById({
@@ -2818,6 +3324,12 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], MicrosoftTeamsUtil, "sendAdaptiveCardToChannel", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "sendAdaptiveCardToChat", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),
@@ -2998,6 +3510,36 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], MicrosoftTeamsUtil, "handleInstallationUpdateActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "captureChatFromBotActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "removeChatFromBotActivity", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "saveChatToProjectAuthTokens", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "removeChatFromProjectAuthTokens", null);
+__decorate([
+    CaptureSpan(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MicrosoftTeamsUtil, "getChatsForProject", null);
 __decorate([
     CaptureSpan(),
     __metadata("design:type", Function),