sync workspace on mention for unseen channels

Author: Joshua Chittick

.agents/skills/slack-developer-researcher/SKILL.md

@@ -13,4 +13,5 @@ Ask clarifying questions if you need to focus on specific endpoints, scopes, or
 
 ## Sources
 - https://docs.slack.dev/apis/
+- https://docs.slack.dev/reference/events
 - https://docs.slack.dev/ai/developing-ai-apps

packages/ims/slack/client.ts

@@ -365,14 +365,14 @@ function syncWorkspaceInBackground(workspace: WorkspaceAuth, channelId: string):
   void syncSlackWorkspace(workspace.workspaceId)
     .then((updatedWorkspace) => {
       invalidateOdeConfigCache();
-      log.info("Slack workspace synced after bot joined channel", {
+      log.info("Slack workspace synced after channel event", {
         workspaceId: workspace.workspaceId,
         workspaceName: updatedWorkspace.name,
         channelId,
       });
     })
     .catch((error) => {
-      log.warn("Slack workspace sync failed after bot joined channel", {
+      log.warn("Slack workspace sync failed after channel event", {
         workspaceId: workspace.workspaceId,
         channelId,
         error: String(error),
@@ -383,6 +383,48 @@ function syncWorkspaceInBackground(workspace: WorkspaceAuth, channelId: string):
     });
 }
 
+async function syncWorkspaceAfterMention(
+  channelId: string,
+  workspace: { workspaceId?: string; workspaceName?: string } | undefined
+): Promise<boolean> {
+  if (!workspace?.workspaceId) {
+    log.warn("Skipping Slack workspace sync; workspace id missing", {
+      channelId,
+      workspaceName: workspace?.workspaceName,
+    });
+    return false;
+  }
+
+  if (backgroundWorkspaceSyncInFlight.has(workspace.workspaceId)) {
+    log.debug("Skipping Slack workspace sync; already in flight", {
+      workspaceId: workspace.workspaceId,
+      channelId,
+    });
+    return false;
+  }
+
+  backgroundWorkspaceSyncInFlight.add(workspace.workspaceId);
+  try {
+    const updatedWorkspace = await syncSlackWorkspace(workspace.workspaceId);
+    invalidateOdeConfigCache();
+    log.info("Slack workspace synced after mention in unseen channel", {
+      workspaceId: workspace.workspaceId,
+      workspaceName: updatedWorkspace.name,
+      channelId,
+    });
+    return true;
+  } catch (error) {
+    log.warn("Slack workspace sync failed after mention in unseen channel", {
+      workspaceId: workspace.workspaceId,
+      channelId,
+      error: String(error),
+    });
+    return false;
+  } finally {
+    backgroundWorkspaceSyncInFlight.delete(workspace.workspaceId);
+  }
+}
+
 async function fetchWorkspaceAuth(
   appToken: string,
   botToken: string,
@@ -583,6 +625,7 @@ export function setupMessageHandlers(): void {
       app: slackApp,
       isAuthorizedChannel,
       resolveWorkspaceAuth,
+      syncWorkspaceForChannel: syncWorkspaceAfterMention,
       getChannelWorkspaceName: (channelId) => channelWorkspaceMap.get(channelId),
       setChannelWorkspaceName: (channelId, workspaceName) => {
         channelWorkspaceMap.set(channelId, workspaceName);

packages/ims/slack/message-router.ts

@@ -6,12 +6,16 @@ type RouterDeps = {
   resolveWorkspaceAuth: (
     teamId?: string,
     enterpriseId?: string
-  ) => { workspaceName?: string; botToken?: string; [key: string]: unknown } | undefined;
+  ) => { workspaceId?: string; workspaceName?: string; botToken?: string; [key: string]: unknown } | undefined;
+  syncWorkspaceForChannel: (
+    channelId: string,
+    workspaceAuth: { workspaceId?: string; workspaceName?: string; botToken?: string; [key: string]: unknown } | undefined
+  ) => Promise<boolean>;
   getChannelWorkspaceName: (channelId: string) => string | undefined;
   setChannelWorkspaceName: (channelId: string, workspaceName: string) => void;
   setChannelWorkspaceAuth: (
     channelId: string,
-    auth: { workspaceName?: string; botToken?: string; [key: string]: unknown } | undefined
+    auth: { workspaceId?: string; workspaceName?: string; botToken?: string; [key: string]: unknown } | undefined
   ) => void;
   isThreadActive: (channelId: string, threadId: string) => boolean;
   markThreadActive: (channelId: string, threadId: string) => void;
@@ -100,6 +104,18 @@ async function maybeHandleStopCommand(
   return true;
 }
 
+async function maybeRefreshWorkspaceForMention(params: {
+  deps: RouterDeps;
+  channelId: string;
+  isMention: boolean;
+  workspaceAuth: WorkspaceAuth;
+}): Promise<void> {
+  const { deps, channelId, isMention, workspaceAuth } = params;
+  if (!isMention) return;
+  if (deps.isAuthorizedChannel(channelId)) return;
+  await deps.syncWorkspaceForChannel(channelId, workspaceAuth);
+}
+
 async function maybeNotifySettingsIssues(
   deps: RouterDeps,
   channelId: string,
@@ -155,14 +171,9 @@ export function registerSlackMessageRouter(deps: RouterDeps): void {
 
     const { channelId, userId, text, threadId, messageId } = incoming;
 
-    if (!deps.isAuthorizedChannel(channelId)) {
-      log.info("[DROP] Unauthorized channel", { channelId });
-      return;
-    }
-
     const authResult = await client.auth.test();
     const currentBotUserId = authResult.user_id as string;
-    syncWorkspaceAuth(
+    const workspaceAuth = syncWorkspaceAuth(
       deps,
       channelId,
       authResult.team_id,
@@ -174,11 +185,22 @@ export function registerSlackMessageRouter(deps: RouterDeps): void {
       return;
     }
 
-    if (await maybeHandleStopCommand(deps, text, channelId, threadId, say)) {
+    const isMention = currentBotUserId ? text.includes(`<@${currentBotUserId}>`) : false;
+    await maybeRefreshWorkspaceForMention({
+      deps,
+      channelId,
+      isMention,
+      workspaceAuth,
+    });
+
+    if (!deps.isAuthorizedChannel(channelId)) {
+      log.info("[DROP] Unauthorized channel", { channelId, isMention });
       return;
     }
 
-    const isMention = currentBotUserId ? text.includes(`<@${currentBotUserId}>`) : false;
+    if (await maybeHandleStopCommand(deps, text, channelId, threadId, say)) {
+      return;
+    }
     const threadActive = deps.isThreadActive(channelId, threadId);
 
     if (shouldDropForThreadContext(isMention, threadActive)) {