crewly 1.20.211 → 1.20.213

package/dist/backend/backend/src/services/slack/slack-team-channel.service.js

@@ -24,6 +24,8 @@
  *
  * @module services/slack/slack-team-channel.service
  */
+import { isSessionPaused, pausedTeamOfSession } from '../team/team-pause.registry.js';
+import { pausedSlackNotice, pausedThreadNotices } from '../team/team-pause-notice.js';
 import { notePerson } from '../people/people-directory.service.js';
 import { dedicatedDecisionFor } from '../people/dedicated-agent.js';
 import { getTicketIntakeService } from '../v3/ticket-intake.service.js';
@@ -88,6 +90,7 @@ export function slackChannelNameFor(teamName, prefix = '') {
  * awake room member. Null when nobody is awake (Cloud's fallback decides).
  *
  * Cloud's delivery facts come first (specs/2026-10-04-room-delivery-audit.md):
+ * with `nobody-awake`, Cloud's fallback machine is the owner; otherwise
  * the responder Cloud names (`delivery.owner`) is the owner — Cloud pushes it
  * first and names another if it cannot be reached. Without one, the owner is
  * computed among the machines Cloud delivered to (`delivery.targets`) only,
@@ -102,6 +105,11 @@ export function roomOwnerInstance(room) {
     const delivery = room.delivery;
     if (delivery?.owner)
         return delivery.owner;
+    // Nobody awake anywhere: Cloud's one fallback machine wakes its lead and
+    // every other machine defers — never dispatching to agents that are awake
+    // only by its own count (review of crewly-services#34: two machines acted).
+    if (delivery?.rule === 'nobody-awake' && room.fallback?.instanceId)
+        return room.fallback.instanceId;
     const targets = delivery && Array.isArray(delivery.targets) && delivery.targets.length > 0 ? delivery.targets : null;
     const awakeMembers = room.members.filter((m) => m.awake && (!targets || targets.includes(m.instanceId)));
     const awake = [...new Set(awakeMembers.map((m) => m.instanceId))].sort();
@@ -351,6 +359,8 @@ export class SlackTeamChannelService {
     deps;
     storePath;
     store = null;
+    pruneTimer = null;
+    pruneInterval = null;
     loading = null;
     unsubscribeStorage = null;
     unsubscribeIdentity = null;
@@ -423,6 +433,94 @@ export class SlackTeamChannelService {
             this.logger.warn('Team channel reconcile failed (non-fatal)', { error: err instanceof Error ? err.message : String(err) });
         });
         void this.rejoinMappedChannels();
+        // Ad-hoc rosters only ever grew: an agent stayed a "member" of a room its
+        // bot had left (or was never in), and Cloud counted that machine as being
+        // in the room (2026-10-03 / 2026-10-04, #content-team). Check against
+        // Slack now and periodically.
+        if (this.deps.listChannelMembers) {
+            const run = () => void this.pruneAdhocMembers().catch((err) => this.logger.warn('Ad-hoc room prune failed (non-fatal)', { error: err instanceof Error ? err.message : String(err) }));
+            this.pruneTimer = setTimeout(run, SLACK_TEAM_CHANNEL_CONSTANTS.ADHOC_PRUNE_FIRST_DELAY_MS);
+            this.pruneInterval = setInterval(run, SLACK_TEAM_CHANNEL_CONSTANTS.ADHOC_PRUNE_INTERVAL_MS);
+            this.pruneTimer.unref?.();
+            this.pruneInterval.unref?.();
+        }
+    }
+    /**
+     * Drop ad-hoc room members whose bot is not in the Slack channel.
+     *
+     * Each room is read with its members' own bot tokens, one after another,
+     * until one can read it (`conversations.members`): members whose bot user
+     * is not in that list are dropped. A bot that gets `not_in_channel` /
+     * `channel_not_found` is itself not in the room and is dropped. A member
+     * with no bot of its own, or a read that fails otherwise (rate limit,
+     * network), is kept — nothing is dropped on a guess. A dropped agent comes
+     * back on its own the next time a copy arrives through its app.
+     *
+     * @returns Per room changed: the channel and the sessions dropped
+     */
+    async pruneAdhocMembers() {
+        const list = this.deps.listChannelMembers;
+        const identities = this.deps.identities;
+        if (!list || !identities)
+            return [];
+        await this.load();
+        await identities.load();
+        const changed = [];
+        // Who of a room's members is not in the Slack channel, by the bot ids
+        // and tokens the identity store holds right now.
+        const absent = async (mapping) => {
+            const bots = (mapping.members ?? []).map((session) => {
+                const installed = identities.getInstalled(session);
+                return { session, token: installed?.botToken ?? null, botUserId: installed?.botUserId ?? identities.get(session)?.botUserId ?? null };
+            });
+            const notInChannel = new Set();
+            let inChannel = null;
+            for (const bot of bots) {
+                if (!bot.token)
+                    continue;
+                const res = await list(mapping.slackChannelId, bot.token);
+                if (res.ok) {
+                    inChannel = new Set(res.members);
+                    break;
+                }
+                if (res.error === 'not_in_channel' || res.error === 'channel_not_found')
+                    notInChannel.add(bot.session);
+            }
+            const seen = inChannel;
+            return bots.filter((b) => notInChannel.has(b.session) || (seen !== null && !!b.botUserId && !seen.has(b.botUserId))).map((b) => b.session);
+        };
+        let refreshed = false;
+        for (const mapping of this.store?.mappings ?? []) {
+            if (!isAdhocMapping(mapping) || (mapping.members ?? []).length === 0)
+                continue;
+            let removed = await absent(mapping);
+            if (removed.length > 0 && this.deps.refreshIdentities) {
+                // A reinstalled app has a new bot user id and token: re-read them and
+                // check again before dropping anyone, so a reinstall does not flap
+                // the roster (review of crewly#1067).
+                if (!refreshed) {
+                    refreshed = true;
+                    await this.deps.refreshIdentities().catch((err) => this.logger.warn('Could not refresh agent identities before pruning', { error: err instanceof Error ? err.message : String(err) }));
+                }
+                const again = new Set(await absent(mapping));
+                removed = removed.filter((s) => again.has(s));
+            }
+            if (removed.length === 0)
+                continue;
+            mapping.members = (mapping.members ?? []).filter((m) => !removed.includes(m));
+            this.deps.chat.setHuddleMembers(mapping.chatChannelId, mapping.members);
+            changed.push({ slackChannelId: mapping.slackChannelId, removed });
+            this.logger.info('Ad-hoc room members dropped — their bots are not in the Slack channel', {
+                slackChannel: `#${mapping.slackChannelName}`,
+                removed,
+                remaining: mapping.members,
+            });
+        }
+        if (changed.length > 0) {
+            await this.save();
+            this.deps.onRoomsChanged?.();
+        }
+        return changed;
     }
     /**
      * Make sure the master bot is still a member of every channel we map.
@@ -565,6 +663,12 @@ export class SlackTeamChannelService {
         for (const pending of this.unanswered.values())
             clearTimeout(pending.timer);
         this.unanswered.clear();
+        if (this.pruneTimer)
+            clearTimeout(this.pruneTimer);
+        if (this.pruneInterval)
+            clearInterval(this.pruneInterval);
+        this.pruneTimer = null;
+        this.pruneInterval = null;
     }
     // -------------------------------------------------------------------------
     // Store
@@ -1098,6 +1202,40 @@ export class SlackTeamChannelService {
         }
         return declined;
     }
+    /**
+     * Take every @'d agent of a paused team off the list
+     * (specs/2026-10-04-team-pause.md): it is not woken; the thread gets one
+     * short auto-reply from that agent's bot, at most once per thread.
+     *
+     * @param message - Inbound channel message
+     * @param mentions - Sessions it addressed
+     * @param nameOf - Display name of a session
+     * @returns The sessions taken off
+     */
+    async declinePausedMentions(message, mentions, nameOf) {
+        const declined = [];
+        for (const sessionName of mentions) {
+            const paused = pausedTeamOfSession(sessionName);
+            if (!paused)
+                continue;
+            declined.push(sessionName);
+            const threadTs = message.threadTs || message.ts;
+            if (!pausedThreadNotices.claim(message.channelId, threadTs, paused.teamId))
+                continue;
+            const botToken = this.deps.identities?.getInstalled(sessionName)?.botToken;
+            await this.deps.slack
+                .sendMessage({
+                channelId: message.channelId,
+                text: pausedSlackNotice(paused, nameOf(sessionName), { toAgent: !!message.authorAgentSession }),
+                threadTs,
+                ...(botToken ? { botToken } : {}),
+                skipChatV2Mirror: true,
+            })
+                .catch((err) => this.logger.warn('Could not post the paused-team notice', { sessionName, error: err instanceof Error ? err.message : String(err) }));
+            this.logger.info('Paused agent @-mentioned in Slack — not woken, thread told', { sessionName, team: paused.teamName });
+        }
+        return declined;
+    }
     /**
      * Route an inbound Slack message that arrived in a mapped channel.
      *
@@ -1218,8 +1356,14 @@ export class SlackTeamChannelService {
         // posts a polite decline from its own bot and is taken off the list —
         // nothing is dispatched to it and it is not woken.
         const declinedDedicated = !message.authorAgentSession && message.userId && resolved.mentions.length > 0 ? await this.declineDedicatedMentions(message, resolved.mentions) : [];
-        const declinedOnly = declinedDedicated.length > 0 && resolved.mentions.every((sess) => declinedDedicated.includes(sess));
-        for (const sess of declinedDedicated)
+        // Agents of a paused team (specs/2026-10-04-team-pause.md) are taken off
+        // too: not woken, and the thread is told once.
+        const declinedPaused = resolved.mentions.length > 0
+            ? await this.declinePausedMentions(message, resolved.mentions.filter((sess) => !declinedDedicated.includes(sess)), (sess) => candidates.find((c) => c.sessionName === sess)?.name ?? sess)
+            : [];
+        const declinedAll = [...declinedDedicated, ...declinedPaused];
+        const declinedOnly = declinedAll.length > 0 && resolved.mentions.every((sess) => declinedAll.includes(sess));
+        for (const sess of declinedAll)
             resolved.mentions.splice(resolved.mentions.indexOf(sess), 1);
         const agentsMentionedViaCloud = [...new Set([...(message.mentionedAgentSessions ?? []), ...namedElsewhere])];
         const mentionedElsewhere = agentsMentionedViaCloud.filter((sess) => !isLocal(sess));
@@ -2191,7 +2335,8 @@ export class SlackTeamChannelService {
         const team = teams.find((t) => t.id === mapping.teamId) ?? null;
         const isLocal = (s) => this.deps.isLocalAgent?.(s) ?? true;
         const roster = team ? teamChannelMembers(team) : null;
-        const local = (roster ? roster.map((m) => m.sessionName) : (mapping.members ?? [])).filter(isLocal);
+        // Never a paused team's agent (specs/2026-10-04-team-pause.md).
+        const local = (roster ? roster.map((m) => m.sessionName) : (mapping.members ?? [])).filter((s) => isLocal(s) && !isSessionPaused(s));
         if (local.length === 0)
             return null;
         const turns = this.deps.chat.queryRecentTurnsForDispatch?.(mapping.chatChannelId, undefined, SLACK_TEAM_CHANNEL_CONSTANTS.ROOM_LAST_SPEAKER_SCAN) ?? [];
@@ -2388,7 +2533,13 @@ export class SlackTeamChannelService {
         const me = this.deps.resolveInstanceId ? await this.deps.resolveInstanceId().catch(() => null) : null;
         const isHere = (m) => me ? m.instanceId === me : (this.deps.isLocalAgent?.(localAgentSession(m.agentSession)) ?? false);
         const owner = me ? roomOwnerInstance(room) : null;
-        return !!owner && owner !== me && room.members.some((m) => !isHere(m) && m.awake);
+        if (!owner || owner === me)
+            return false;
+        // Cloud named the machine (its responder, or its fallback when nobody is
+        // awake): that machine has the message and acts; this one defers.
+        if (room.delivery?.owner || room.delivery?.rule === 'nobody-awake')
+            return true;
+        return room.members.some((m) => !isHere(m) && m.awake);
     }
     /**
      * Hand a room message to one agent, wherever it runs.