crewly 1.20.324 → 1.20.326

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

@@ -405,6 +405,8 @@ export class SlackTeamChannelService {
     unsubscribeIdentity = null;
     /** Slack `channel:ts` of messages already routed → the persisted turn. */
     seenInbound = new Map();
+    /** Room messages already handed back to the orchestrator. */
+    orcHandedBack = new Set();
     /** The last room presence Cloud sent per Slack channel — names for a hand-off. */
     lastRooms = new Map();
     /** People (not agents) by lower-cased name → Slack user id, for `@Name` in agent replies. */
@@ -1022,13 +1024,26 @@ export class SlackTeamChannelService {
                 }
             }
             else {
-                const channel = await this.deps.slack.createChannel(derived);
+                // 2026-10-13: a room another machine created (room-join request): link
+                // THAT Slack channel. Asking Slack to create by name could make a
+                // second channel when Slack normalised the name differently.
+                let channel;
+                if (input.existingChannelId) {
+                    const found = await this.deps.slack.getChannelInfo(input.existingChannelId);
+                    if (!found)
+                        throw new Error(`Slack channel ${input.existingChannelId} was not found`);
+                    await this.deps.slack.joinChannel(found.id).catch(() => undefined);
+                    channel = found;
+                }
+                else {
+                    channel = await this.deps.slack.createChannel(derived);
+                }
                 // createChannel hands back an existing channel when the name is taken;
                 // a team's channel must not be turned into a second room.
                 const clash = current.mappings.find((m) => m.slackChannelId === channel.id);
                 if (clash)
                     throw new Error(`#${channel.name} is already linked to ${isAdhocMapping(clash) ? 'another channel' : 'a team'}`);
-                const ownerInvited = await this.inviteOwner(channel.id, channel.name);
+                const ownerInvited = input.existingChannelId ? false : await this.inviteOwner(channel.id, channel.name);
                 if (input.purpose.trim()) {
                     await this.deps.slack.setChannelPurpose(channel.id, input.purpose.trim()).catch((err) => {
                         this.logger.debug('setPurpose failed (non-critical)', { error: err instanceof Error ? err.message : String(err) });
@@ -1458,8 +1473,43 @@ export class SlackTeamChannelService {
         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])];
+        // This machine's orchestrator @'d in a room (2026-10-13, #pro-crewly-marketing:
+        // Ella's "<@orc> Steve approved a new team on your machine…" reached the
+        // Air, Cloud routed it by `agent-author`, and nobody acted). The orc is
+        // deliberately not a room member (leads, rosters and wake-when-all-asleep
+        // rely on that), so the resolver never saw it, and the message counted as
+        // addressed to nobody here. It is either Cloud's mention list (mapped to
+        // the local session name) or the orc's own bot id in the text. The orc is
+        // taken out of the agent lists below: it is neither "elsewhere" nor a
+        // dispatch target of the huddle.
+        const orcSession = CREWLY_CONSTANTS.SESSIONS.ORCHESTRATOR_NAME;
+        const orcBotId = this.deps.identities?.getInstalled(orcSession)?.botUserId;
+        const orcAddressed = !handoffTo &&
+            (!!message.mentionedAgentSessions?.some((sess) => localAgentSession(sess) === orcSession) ||
+                (!!orcBotId && (message.text ?? '').includes(`<@${orcBotId}>`)));
+        const agentsMentionedViaCloud = [...new Set([...(message.mentionedAgentSessions ?? []), ...namedElsewhere])].filter((sess) => localAgentSession(sess) !== orcSession);
         const mentionedElsewhere = agentsMentionedViaCloud.filter((sess) => !isLocal(sess));
+        // Nobody else here is addressed: the orchestrator's own pipeline takes it
+        // (it replies in the same Slack thread). Returning null hands the message
+        // back to the bridge, the way an unmapped channel message is. Members
+        // @'d alongside the orc keep the room path (they answer in the thread).
+        if (orcAddressed && resolved.mentions.length === 0 && declinedAll.length === 0 && mentionedElsewhere.length === 0) {
+            const orcKey = `${message.channelId}:${message.ts}`;
+            // The same message can arrive as two event types; hand it back once.
+            if (this.orcHandedBack.has(orcKey))
+                return { mapping, message: seen ?? {}, mentions: [], dispatch: null, duplicate: true };
+            this.orcHandedBack.add(orcKey);
+            if (this.orcHandedBack.size > SLACK_TEAM_CHANNEL_CONSTANTS.SEEN_INBOUND_MAX) {
+                const oldest = this.orcHandedBack.values().next().value;
+                if (oldest !== undefined)
+                    this.orcHandedBack.delete(oldest);
+            }
+            this.logger.info("Room message @'s this machine's orchestrator - handed to it", {
+                slackChannel: `#${mapping.slackChannelName}`,
+                ts: message.ts,
+            });
+            return null;
+        }
         const addressedElsewhereOnly = !handoffTo && resolved.mentions.length === 0 && mentionedElsewhere.length > 0;
         // @-mentions of people: the owner asking a
         // colleague is not a question for the agents (2026-10-01,
@@ -3015,6 +3065,53 @@ export class SlackTeamChannelService {
         this.logger.info('Room message handed to an agent on another machine', { agentSession: hit.session, slackChannel: mapping.slackChannelName });
         return { ok: true, agentSession: hit.session, displayName: hit.name, via: 'cloud' };
     }
+    /**
+     * A room-join request from another machine (via Cloud): link the existing
+     * Slack channel here with the given LOCAL agents as members, so they are in
+     * the room and show up in this machine's heartbeat `rooms`.
+     *
+     * Sessions that are not agents of this machine are rejected and reported,
+     * never silently dropped. A channel that is a team's channel is refused.
+     *
+     * @param input - Slack channel and the sessions Cloud addressed to this machine
+     * @returns Which sessions joined and which were rejected
+     */
+    async joinRoomFromCloud(input) {
+        await this.load();
+        const local = new Set();
+        for (const team of await this.deps.storage.getTeams()) {
+            for (const m of teamChannelMembers(team))
+                local.add(m.sessionName);
+        }
+        const wanted = [...new Set((input.sessions ?? []).map((s) => localAgentSession(String(s))).filter(Boolean))];
+        const joined = wanted.filter((s) => local.has(s));
+        const rejected = wanted.filter((s) => !local.has(s));
+        if (rejected.length > 0) {
+            this.logger.warn('Room join: sessions are not agents of this machine', { slackChannel: input.slackChannelId, rejected });
+        }
+        if (joined.length === 0)
+            return { ok: false, joined, rejected, error: 'no_local_members' };
+        const existing = (this.store?.mappings ?? []).find((m) => m.slackChannelId === input.slackChannelId);
+        if (existing && !isAdhocMapping(existing)) {
+            return { ok: false, joined: [], rejected: wanted, error: 'channel_belongs_to_a_team' };
+        }
+        try {
+            await this.ensureAgentChannel({
+                name: input.slackChannelName,
+                purpose: '',
+                memberSessions: joined,
+                existingChannelId: input.slackChannelId,
+                applyPrefix: false,
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            this.logger.warn('Room join failed', { slackChannel: input.slackChannelId, error });
+            return { ok: false, joined: [], rejected: wanted, error };
+        }
+        this.logger.info('Joined a room created on another machine', { slackChannel: input.slackChannelId, name: input.slackChannelName, agents: joined });
+        return { ok: true, joined, rejected };
+    }
     /**
      * Every Slack channel this machine maps — team channels and ad-hoc rooms —
      * with the local agents in it. What the delivery audit reads Slack for.