crewly 1.20.248 → 1.20.249

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

@@ -373,6 +373,8 @@ export class SlackTeamChannelService {
     humanNames = new Map();
     /** Whether the owner's names were looked up yet. */
     ownerNamesLoaded = false;
+    /** The owner's display name for posts made on their behalf. */
+    ownerName = null;
     /** channelId → members, with fetch time; decides between same-named agents. */
     channelMembers = new Map();
     /**
@@ -440,7 +442,10 @@ export class SlackTeamChannelService {
         // 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) }));
+            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) }))
+                .then(() => this.syncRoomsFromSlack())
+                .catch((err) => this.logger.warn('Room sync from Slack 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?.();
@@ -652,6 +657,14 @@ export class SlackTeamChannelService {
         }
         return result;
     }
+    /**
+     * Whether Slack is connected right now (creating a channel needs it).
+     *
+     * @returns True when connected
+     */
+    isConnected() {
+        return this.deps.slack.isConnected();
+    }
     /** Undo {@link start}. */
     stop() {
         if (!this.started)
@@ -952,12 +965,13 @@ export class SlackTeamChannelService {
      */
     async ensureAgentChannel(input) {
         const store = await this.load();
-        const derived = slackChannelNameFor(input.name, store.channelPrefix);
+        const derived = slackChannelNameFor(input.name, input.applyPrefix === false ? '' : store.channelPrefix);
         return this.serialised(`agent-channel:${derived}`, async () => {
             if (!this.deps.slack.isConnected())
                 throw new Error('Slack is not connected');
             const current = await this.load();
             let mapping = (input.existingChannelId ? current.mappings.find((m) => m.slackChannelId === input.existingChannelId) : undefined) ??
+                (input.chatChannelId ? current.mappings.find((m) => m.chatChannelId === input.chatChannelId) : undefined) ??
                 current.mappings.find((m) => isAdhocMapping(m) && m.autoCreated && (m.derivedName ?? m.slackChannelName) === derived);
             const sessions = [...new Set(input.memberSessions.filter((s) => !!s))];
             if (mapping) {
@@ -971,18 +985,32 @@ export class SlackTeamChannelService {
             }
             else {
                 const 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);
                 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) });
                     });
                 }
-                const huddle = this.deps.chat.createHuddle({
-                    name: `#${channel.name}`,
-                    purpose: input.purpose.trim() || `Slack channel #${channel.name}`,
-                    memberSessions: sessions.length > 0 ? sessions : [`channel:${channel.id}`],
-                    principal: { userId: 'system', source: 'oss' },
-                });
+                let huddle;
+                if (input.chatChannelId) {
+                    huddle = { id: input.chatChannelId };
+                    if (sessions.length > 0)
+                        this.deps.chat.setHuddleMembers(input.chatChannelId, sessions);
+                    this.deps.chat.renameChannelForBridge?.(input.chatChannelId, `#${channel.name}`);
+                }
+                else {
+                    huddle = this.deps.chat.createHuddle({
+                        name: `#${channel.name}`,
+                        purpose: input.purpose.trim() || `Slack channel #${channel.name}`,
+                        memberSessions: sessions.length > 0 ? sessions : [`channel:${channel.id}`],
+                        principal: { userId: 'system', source: 'oss' },
+                    });
+                }
                 mapping = {
                     teamId: `${SLACK_TEAM_CHANNEL_CONSTANTS.ADHOC_TEAM_PREFIX}${channel.id}`,
                     slackChannelId: channel.id,
@@ -1275,7 +1303,7 @@ export class SlackTeamChannelService {
         // owner had added to a private channel out of it until someone happened
         // to address it by name.
         const receiving = await this.localReceivingAgent(message);
-        if (receiving && isAdhocMapping(mapping) && !(mapping.members ?? []).includes(receiving)) {
+        if (receiving && isAdhocMapping(mapping) && !(mapping.members ?? []).includes(receiving) && !(mapping.excluded ?? []).includes(receiving)) {
             mapping.members = [...(mapping.members ?? []), receiving];
             this.deps.chat.setHuddleMembers(mapping.chatChannelId, mapping.members);
             await this.save();
@@ -1492,6 +1520,12 @@ export class SlackTeamChannelService {
                 const next = [...new Set([...(mapping.members ?? []), ...resolved.mentions])];
                 if (next.length !== (mapping.members ?? []).length) {
                     mapping.members = next;
+                    // An explicit @ brings back an agent the owner had removed.
+                    if (mapping.excluded) {
+                        mapping.excluded = mapping.excluded.filter((sess) => !next.includes(sess));
+                        if (mapping.excluded.length === 0)
+                            delete mapping.excluded;
+                    }
                     this.deps.chat.setHuddleMembers(mapping.chatChannelId, next);
                     await this.save();
                     this.deps.onRoomsChanged?.();
@@ -2999,6 +3033,12 @@ export class SlackTeamChannelService {
                 });
                 return false;
             };
+            if (dto.senderType === 'user' && isOwnerTypedInCrewly(dto)) {
+                await this.load();
+                const room = this.findByChatChannelId(dto.channelId);
+                if (room && isAdhocMapping(room))
+                    return await this.mirrorOwnerPost(room, dto);
+            }
             if (dto.senderType !== 'agent')
                 return skip(`senderType=${dto.senderType}`);
             if (dto.metadata?.source === 'slack')
@@ -3073,6 +3113,90 @@ export class SlackTeamChannelService {
             return false;
         }
     }
+    /**
+     * Post a message the owner typed in Crewly into the room's Slack channel,
+     * so people and agents on other machines see it. Posted by the workspace
+     * (Crewly) bot as `*<owner>* (from Crewly): …`; in a private room the
+     * workspace bot is not in, a member's bot posts it instead. Threads follow
+     * the chat thread's Slack root. The Slack copy is remembered as already
+     * routed, so its echo is never dispatched a second time (the chat-v2
+     * dispatcher already delivered the original).
+     *
+     * @param mapping - The room (ad-hoc mapping)
+     * @param dto - The owner's chat row
+     * @returns True when Slack took it
+     */
+    async mirrorOwnerPost(mapping, dto) {
+        if (!this.deps.slack.isConnected())
+            return false;
+        const pendingRoot = dto.threadId ? this.rootPosts.get(dto.threadId) : undefined;
+        if (pendingRoot)
+            await pendingRoot;
+        const threadTs = this.resolveOutboundThreadTs(mapping, dto);
+        if (threadTs === null)
+            return false;
+        let done = () => undefined;
+        if (!threadTs)
+            this.rootPosts.set(dto.id, new Promise((resolve) => (done = resolve)));
+        try {
+            const owner = await this.ownerDisplayName();
+            const body = await this.linkAgentMentions(toSlackMrkdwn(dto.content), mapping.slackChannelId);
+            const text = `*${owner}* (from Crewly): ${body}`;
+            const send = (botToken) => this.deps.slack.sendMessage({
+                channelId: mapping.slackChannelId,
+                text,
+                ...(threadTs ? { threadTs } : {}),
+                skipChatV2Mirror: true,
+                notAnAnswer: true,
+                ...(botToken ? { botToken } : {}),
+            });
+            let ts = '';
+            let lastError = '';
+            if (this.deps.identities)
+                await this.deps.identities.load();
+            for (const token of [undefined, ...this.memberTokens(mapping)]) {
+                try {
+                    ts = await send(token);
+                    break;
+                }
+                catch (err) {
+                    lastError = describeSlackError(err).code;
+                    if (lastError !== 'not_in_channel' && lastError !== 'channel_not_found')
+                        break;
+                }
+            }
+            if (!ts) {
+                this.logger.warn('Owner message from Crewly not posted to Slack', { slackChannel: mapping.slackChannelName, error: lastError });
+                return false;
+            }
+            // The echo of this post (through any app in the room) is a repeat.
+            this.seenInbound.set(`${mapping.slackChannelId}:${ts}`, dto);
+            if (!threadTs)
+                this.recordSlackRoot(dto, mapping, ts);
+            this.logger.info('Owner message from Crewly posted to Slack', { slackChannel: mapping.slackChannelName, threaded: Boolean(threadTs) });
+            return true;
+        }
+        finally {
+            done();
+            this.rootPosts.delete(dto.id);
+        }
+    }
+    /** The owner's Slack name (cached), or "Owner". */
+    async ownerDisplayName() {
+        if (this.ownerName)
+            return this.ownerName;
+        const owner = this.deps.getOwnerUserId?.() ?? null;
+        if (owner && this.deps.slack.getUserInfo) {
+            try {
+                const info = await this.deps.slack.getUserInfo(owner);
+                this.ownerName = info.realName || info.name || null;
+            }
+            catch {
+                /* fall through */
+            }
+        }
+        return this.ownerName ?? 'Owner';
+    }
     /**
      * Post an agent message that belongs to no thread as a new top-level
      * Slack post.
@@ -3813,9 +3937,11 @@ export class SlackTeamChannelService {
                 continue;
             await this.inviteBot(mapping, agentSession, record.botUserId);
         }
-        // Channels Crewly created for a set of agents (ensureAgentChannel).
+        // Rooms the agent is a member of: channels Crewly created for a set of
+        // agents (ensureAgentChannel), and Slack channels the owner added it to
+        // from Crewly before its bot existed.
         for (const mapping of this.store?.mappings ?? []) {
-            if (!isAdhocMapping(mapping) || !mapping.autoCreated)
+            if (!isAdhocMapping(mapping))
                 continue;
             if (!(mapping.members ?? []).includes(agentSession) || record.invitedTo.includes(mapping.slackChannelId))
                 continue;
@@ -3829,7 +3955,11 @@ export class SlackTeamChannelService {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            if (!/already_in_channel/.test(message)) {
+            const code = describeSlackError(err).code;
+            const alreadyIn = /already_in_channel/.test(message) || code === 'already_in_channel';
+            // The workspace bot is usually not in a private room the owner made;
+            // another member's own bot can invite instead.
+            if (!alreadyIn && !(await this.inviteViaMemberBot(mapping, agentSession, botUserId))) {
                 this.logger.warn('Could not invite agent bot into channel', { agentSession, channel: mapping.slackChannelName, error: message });
                 return false;
             }
@@ -3838,6 +3968,272 @@ export class SlackTeamChannelService {
         this.logger.info('Agent bot invited into team channel', { agentSession, channel: `#${mapping.slackChannelName}` });
         return true;
     }
+    /**
+     * Invite a bot with another room member's own bot token (the workspace bot
+     * is not in the room). Tries each member that has a bot until one works.
+     *
+     * @returns True when the bot is now in the channel
+     */
+    async inviteViaMemberBot(mapping, agentSession, botUserId) {
+        const ops = this.deps.channelOps;
+        if (!ops || !isAdhocMapping(mapping))
+            return false;
+        for (const token of this.memberTokens(mapping, [agentSession])) {
+            const res = await ops.invite(mapping.slackChannelId, botUserId, token);
+            if (res.ok || res.error === 'already_in_channel')
+                return true;
+        }
+        return false;
+    }
+    /** Installed bot tokens of an ad-hoc room's members, minus `except`. */
+    memberTokens(mapping, except = []) {
+        return [
+            ...new Set((mapping.members ?? [])
+                .filter((s) => !except.includes(s))
+                .map((s) => this.deps.identities?.getInstalled(s)?.botToken)
+                .filter((t) => !!t)),
+        ];
+    }
+    /**
+     * Take an agent's bot out of a room's Slack channel: the workspace bot
+     * removes it (`conversations.kick`), else the agent's own bot leaves.
+     *
+     * @returns True when the bot is out (or was never in)
+     */
+    async removeBot(mapping, agentSession) {
+        const installed = this.deps.identities?.getInstalled(agentSession) ?? null;
+        if (!installed)
+            return false;
+        if (this.deps.slack.kickFromChannel && this.deps.slack.isConnected()) {
+            try {
+                await this.deps.slack.kickFromChannel(mapping.slackChannelId, installed.botUserId);
+                return true;
+            }
+            catch (err) {
+                if (describeSlackError(err).code === 'not_in_channel')
+                    return true;
+            }
+        }
+        const ops = this.deps.channelOps;
+        if (!ops)
+            return false;
+        const res = await ops.leave(mapping.slackChannelId, installed.botToken);
+        return res.ok || res.error === 'not_in_channel' || res.error === 'channel_not_found';
+    }
+    // -------------------------------------------------------------------------
+    // Crewly channels (specs/2026-10-07-crewly-channels.md): ad-hoc rooms
+    // managed from Crewly — members, name, archive — and kept in step with Slack.
+    // -------------------------------------------------------------------------
+    /**
+     * Set an ad-hoc room's members from Crewly. Added agents' bots are invited
+     * into the Slack channel; removed agents' bots are taken out. Removed
+     * agents are remembered (`excluded`) so they are not added back
+     * automatically if Slack refused to take their bot out.
+     *
+     * @param slackChannelId - The room's Slack channel
+     * @param sessions - The complete desired roster
+     * @returns The diff and what Slack did with it
+     * @throws Error when the channel is not an ad-hoc room
+     */
+    async setRoomMembers(slackChannelId, sessions) {
+        return this.serialised(`room:${slackChannelId}`, async () => {
+            await this.load();
+            const mapping = this.findBySlackChannelId(slackChannelId);
+            if (!mapping || !isAdhocMapping(mapping))
+                throw new Error(`Not a Crewly channel: ${slackChannelId}`);
+            const wanted = [...new Set(sessions.map((x) => x.trim()).filter(Boolean))];
+            const before = mapping.members ?? [];
+            const added = wanted.filter((x) => !before.includes(x));
+            const removed = before.filter((x) => !wanted.includes(x));
+            const change = { added, removed, invited: [], notInvited: [], removedFromSlack: [], stillInSlack: [] };
+            if (added.length === 0 && removed.length === 0)
+                return change;
+            if (this.deps.identities)
+                await this.deps.identities.load();
+            // Remove first, with the roster as it was: a leaving bot's token can
+            // still help, and the remaining members' tokens can invite.
+            for (const session of removed) {
+                (await this.removeBot(mapping, session) ? change.removedFromSlack : change.stillInSlack).push(session);
+            }
+            mapping.members = wanted;
+            const excluded = new Set([...(mapping.excluded ?? []).filter((x) => !added.includes(x)), ...removed]);
+            if (excluded.size > 0)
+                mapping.excluded = [...excluded];
+            else
+                delete mapping.excluded;
+            this.deps.chat.setHuddleMembers(mapping.chatChannelId, wanted);
+            await this.save();
+            for (const session of added) {
+                const record = this.deps.identities?.get(session);
+                const ok = record?.status === 'installed' && record.botUserId ? await this.inviteBot(mapping, session, record.botUserId) : false;
+                (ok ? change.invited : change.notInvited).push(session);
+            }
+            this.deps.onRoomsChanged?.();
+            this.logger.info('Channel members changed from Crewly', { slackChannel: `#${mapping.slackChannelName}`, ...change });
+            return change;
+        });
+    }
+    /**
+     * Rename an ad-hoc room's Slack channel from Crewly. The name is
+     * normalised the way Slack wants it (lower case, no spaces, at most 80
+     * characters); the name Slack applied is stored and returned, so Crewly
+     * shows exactly what Slack shows.
+     *
+     * @param slackChannelId - The room's Slack channel
+     * @param name - The name the owner typed
+     * @returns The applied channel name (without `#`)
+     * @throws Error when the room is unknown or Slack refused (name taken, no permission)
+     */
+    async renameRoom(slackChannelId, name) {
+        return this.serialised(`room:${slackChannelId}`, async () => {
+            await this.load();
+            const mapping = this.findBySlackChannelId(slackChannelId);
+            if (!mapping || !isAdhocMapping(mapping))
+                throw new Error(`Not a Crewly channel: ${slackChannelId}`);
+            const desired = slackChannelNameFor(name);
+            if (desired === mapping.slackChannelName)
+                return desired;
+            let applied = null;
+            let lastError = 'rename_failed';
+            if (this.deps.slack.isConnected())
+                applied = await this.deps.slack.renameChannel(slackChannelId, desired).catch(() => null);
+            if (!applied && this.deps.channelOps) {
+                if (this.deps.identities)
+                    await this.deps.identities.load();
+                for (const token of this.memberTokens(mapping)) {
+                    const res = await this.deps.channelOps.rename(slackChannelId, desired, token);
+                    if (res.ok) {
+                        applied = res.name;
+                        break;
+                    }
+                    lastError = res.error;
+                    if (res.error === 'name_taken' || res.error === 'invalid_name')
+                        break;
+                }
+            }
+            if (!applied)
+                throw new Error(`Slack did not rename #${mapping.slackChannelName}: ${lastError}`);
+            this.applyRoomName(mapping, applied);
+            await this.save();
+            this.logger.info('Channel renamed from Crewly', { slackChannelId, to: applied });
+            return applied;
+        });
+    }
+    /**
+     * Archive an ad-hoc room from Crewly: the mapping and huddle go; the Slack
+     * channel is archived when `archiveSlackChannel`, otherwise the members'
+     * bots leave it (so it is not found again as a room).
+     *
+     * @param slackChannelId - The room's Slack channel
+     * @param options - `archiveSlackChannel` for a channel Crewly created
+     * @returns True when a room existed
+     */
+    async archiveRoom(slackChannelId, options = {}) {
+        const mapping = this.findBySlackChannelId(slackChannelId);
+        if (!mapping || !isAdhocMapping(mapping))
+            return false;
+        if (!options.archiveSlackChannel) {
+            if (this.deps.identities)
+                await this.deps.identities.load();
+            for (const session of mapping.members ?? [])
+                await this.removeBot(mapping, session);
+        }
+        const done = await this.unlinkTeam(mapping.teamId, { archiveSlackChannel: !!options.archiveSlackChannel });
+        if (done)
+            this.deps.onRoomsChanged?.();
+        return done;
+    }
+    /**
+     * Bring names and ad-hoc rosters in from Slack.
+     *
+     * - Every mapped channel (team and ad-hoc): a rename in Slack is shown in
+     *   Crewly (mapping name and huddle name). A team channel's `derivedName`
+     *   is left alone, so the owner's Slack name is not renamed back on the
+     *   next team save.
+     * - Ad-hoc rooms: local agents whose bot is in the Slack channel join the
+     *   roster, unless the owner removed them in Crewly. (Leaving is handled by
+     *   {@link pruneAdhocMembers}.)
+     *
+     * Reads with the room members' own bots first (the workspace bot is
+     * usually not in a private room), then the workspace bot. Nothing changes
+     * on a read that fails.
+     *
+     * @returns What changed
+     */
+    async syncRoomsFromSlack() {
+        await this.load();
+        const result = { renamed: [], joined: [] };
+        if (this.deps.identities)
+            await this.deps.identities.load();
+        const teams = await this.deps.storage.getTeams();
+        const local = teams
+            .flatMap((t) => teamChannelMembers(t))
+            .filter((m) => this.deps.isLocalAgent?.(m.sessionName) ?? true);
+        let changed = false;
+        let roomsChanged = false;
+        for (const mapping of this.store?.mappings ?? []) {
+            let liveName = null;
+            let inChannel = null;
+            if (isAdhocMapping(mapping)) {
+                for (const token of this.memberTokens(mapping)) {
+                    if (!liveName && this.deps.channelOps) {
+                        const info = await this.deps.channelOps.info(mapping.slackChannelId, token);
+                        if (info.ok && info.name)
+                            liveName = info.name;
+                    }
+                    if (!inChannel && this.deps.listChannelMembers) {
+                        const list = await this.deps.listChannelMembers(mapping.slackChannelId, token);
+                        if (list.ok)
+                            inChannel = new Set(list.members);
+                    }
+                    if (liveName && (inChannel || !this.deps.listChannelMembers))
+                        break;
+                }
+            }
+            if (!liveName && this.deps.slack.isConnected()) {
+                const info = await this.deps.slack.getChannelInfo(mapping.slackChannelId).catch(() => null);
+                if (info?.name)
+                    liveName = info.name;
+            }
+            if (liveName && liveName !== mapping.slackChannelName) {
+                result.renamed.push({ slackChannelId: mapping.slackChannelId, from: mapping.slackChannelName, to: liveName });
+                this.applyRoomName(mapping, liveName);
+                changed = true;
+            }
+            if (inChannel && isAdhocMapping(mapping)) {
+                const members = mapping.members ?? [];
+                const excluded = mapping.excluded ?? [];
+                const joined = local
+                    .filter((m) => !members.includes(m.sessionName) && !excluded.includes(m.sessionName))
+                    .filter((m) => {
+                    const botUserId = this.deps.identities?.getInstalled(m.sessionName)?.botUserId;
+                    return !!botUserId && inChannel.has(botUserId);
+                })
+                    .map((m) => m.sessionName);
+                if (joined.length > 0) {
+                    mapping.members = [...members, ...joined];
+                    this.deps.chat.setHuddleMembers(mapping.chatChannelId, mapping.members);
+                    result.joined.push({ slackChannelId: mapping.slackChannelId, added: joined });
+                    changed = true;
+                    roomsChanged = true;
+                }
+            }
+        }
+        if (changed)
+            await this.save();
+        if (roomsChanged)
+            this.deps.onRoomsChanged?.();
+        if (result.renamed.length || result.joined.length)
+            this.logger.info('Rooms synced from Slack', { ...result });
+        return result;
+    }
+    /** Record a channel's Slack name on its mapping and huddle (`#name`). */
+    applyRoomName(mapping, name) {
+        mapping.slackChannelName = name;
+        if (isAdhocMapping(mapping) && mapping.autoCreated)
+            mapping.derivedName = name;
+        this.deps.chat.renameChannelForBridge?.(mapping.chatChannelId, `#${name}`);
+    }
     // -------------------------------------------------------------------------
     // Slack-side messages
     // -------------------------------------------------------------------------
@@ -3897,6 +4293,21 @@ export class SlackTeamChannelService {
         return next;
     }
 }
+/**
+ * A row the owner typed in Crewly (dashboard, phone, Talk) — not a Slack
+ * message recorded here and not an agent writing as a user turn.
+ *
+ * @param dto - A `user` chat row
+ * @returns True when it should be mirrored to the room's Slack channel
+ */
+export function isOwnerTypedInCrewly(dto) {
+    const md = dto.metadata ?? {};
+    if (md.source !== undefined && md.source !== 'cloud-talk')
+        return false;
+    if (md[OWNER_EVIDENCE_METADATA.AUTHOR_AGENT_SESSION] || md[OWNER_EVIDENCE_METADATA.REMOTE_AGENT_SESSION])
+        return false;
+    return typeof md.slackTs !== 'string' && typeof md.slackChannelId !== 'string';
+}
 /** Type guard for persisted mapping rows. */
 /**
  * A promise's value, or `fallback` when it takes longer than `ms`.