Sync Slack workspace on mention (#70)

* sync workspace on mention for unseen channels

* allow slack mentions from any channel

---------

Co-authored-by: Joshua Chittick <josh@smqx.org>

Author: LIU9293

.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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ode",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "description": "Ode - OpenCode chat controller for Slack",
   "module": "packages/core/index.ts",
   "type": "module",

packages/ims/slack/client.ts

@@ -352,35 +352,46 @@ async function postGitHubLauncher(
   });
 }
 
-function syncWorkspaceInBackground(workspace: WorkspaceAuth, channelId: string): void {
+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;
+    return false;
   }
 
   backgroundWorkspaceSyncInFlight.add(workspace.workspaceId);
-  void syncSlackWorkspace(workspace.workspaceId)
-    .then((updatedWorkspace) => {
-      invalidateOdeConfigCache();
-      log.info("Slack workspace synced after bot joined channel", {
-        workspaceId: workspace.workspaceId,
-        workspaceName: updatedWorkspace.name,
-        channelId,
-      });
-    })
-    .catch((error) => {
-      log.warn("Slack workspace sync failed after bot joined channel", {
-        workspaceId: workspace.workspaceId,
-        channelId,
-        error: String(error),
-      });
-    })
-    .finally(() => {
-      backgroundWorkspaceSyncInFlight.delete(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(
@@ -583,6 +594,7 @@ export function setupMessageHandlers(): void {
       app: slackApp,
       isAuthorizedChannel,
       resolveWorkspaceAuth,
+      syncWorkspaceForChannel: syncWorkspaceAfterMention,
       getChannelWorkspaceName: (channelId) => channelWorkspaceMap.get(channelId),
       setChannelWorkspaceName: (channelId, workspaceName) => {
         channelWorkspaceMap.set(channelId, workspaceName);
@@ -607,37 +619,6 @@ export function setupMessageHandlers(): void {
       handleIncomingMessage: (context, text) => coreRuntime.handleIncomingMessage(context, text),
     });
 
-    slackApp.event("member_joined_channel", async ({ event, context }: any) => {
-      const channelId = event?.channel as string | undefined;
-      const memberId = event?.user as string | undefined;
-      if (!channelId || !memberId) return;
-
-      const workspaceAuth = resolveWorkspaceAuth(
-        event?.team as string | undefined,
-        (event?.enterprise_id as string | undefined) ?? (context?.enterpriseId as string | undefined)
-      );
-      if (!workspaceAuth || memberId !== workspaceAuth.botUserId) return;
-
-      channelWorkspaceAuthMap.set(channelId, workspaceAuth);
-      if (workspaceAuth.workspaceName) {
-        channelWorkspaceMap.set(channelId, workspaceAuth.workspaceName);
-      }
-
-      if (!workspaceAuth.workspaceId) {
-        log.warn("Bot added to channel but workspace id is missing; skipping sync", {
-          workspaceName: workspaceAuth.workspaceName,
-          channelId,
-        });
-        return;
-      }
-
-      log.info("Bot added to channel; syncing Slack workspace", {
-        workspaceId: workspaceAuth.workspaceId,
-        workspaceName: workspaceAuth.workspaceName,
-        channelId,
-      });
-      syncWorkspaceInBackground(workspaceAuth, channelId);
-    });
   }
 
 }

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,17 @@ export function registerSlackMessageRouter(deps: RouterDeps): void {
       return;
     }
 
+    const isMention = currentBotUserId ? text.includes(`<@${currentBotUserId}>`) : false;
+    await maybeRefreshWorkspaceForMention({
+      deps,
+      channelId,
+      isMention,
+      workspaceAuth,
+    });
+
     if (await maybeHandleStopCommand(deps, text, channelId, threadId, say)) {
       return;
     }
-
-    const isMention = currentBotUserId ? text.includes(`<@${currentBotUserId}>`) : false;
     const threadActive = deps.isThreadActive(channelId, threadId);
 
     if (shouldDropForThreadContext(isMention, threadActive)) {