crewly 1.20.334 → 1.20.336

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

@@ -54,6 +54,7 @@ import { withTopicLine } from '../orc/work-item-destination.js';
 import { resolveSlackMentions, extractNativeMentionIds, leadingNameMention } from './slack-mention-resolver.js';
 import { toSlackMrkdwn } from './slack-mrkdwn.js';
 import { renderSlackThreadContext } from './slack-thread-context.service.js';
+import { trackSlackDelivery, SLACK_DELIVERY_METADATA_KEY } from './slack-outbound-delivery.js';
 const EMPTY_STORE = {
     version: 1,
     autoCreate: true,
@@ -426,7 +427,10 @@ export class SlackTeamChannelService {
     onChatMessage = (dto) => {
         if (dto.senderType === 'agent')
             this.noteAgentActivity(dto.channelId, dto.threadId ?? null, 'here');
-        void this.mirrorOutbound(dto);
+        if (dto.senderType === 'agent')
+            trackSlackDelivery(dto.id, this.mirrorOutboundDetailed(dto).then((r) => r.delivery));
+        else
+            void this.mirrorOutbound(dto);
     };
     started = false;
     /** Per-team serialisation so two team-saved events cannot create two channels. */
@@ -3320,6 +3324,17 @@ export class SlackTeamChannelService {
      * @returns True when a Slack post was attempted
      */
     async mirrorOutbound(dto) {
+        return (await this.mirrorOutboundDetailed(dto)).attempted;
+    }
+    /**
+     * {@link mirrorOutbound} with the outcome: the Slack channel + ts the reply
+     * landed at (also stored on the chat message), or Slack's error.
+     *
+     * @param dto - The chat-v2 message
+     * @returns Whether a post was attempted, and its delivery (null when not meant for Slack)
+     */
+    async mirrorOutboundDetailed(dto) {
+        const skipped = { attempted: false, delivery: null };
         try {
             // Every reason a reply does not reach Slack is logged. Until now all
             // four were silent `return false`, so an agent could answer, be told
@@ -3331,13 +3346,13 @@ export class SlackTeamChannelService {
                     channelId: dto.channelId,
                     sender: dto.senderId,
                 });
-                return false;
+                return skipped;
             };
             if (dto.senderType === 'user' && isOwnerTypedInCrewly(dto) && !isDriveModeRow(dto)) {
                 await this.load();
                 const room = this.findByChatChannelId(dto.channelId);
                 if (room && isAdhocMapping(room))
-                    return await this.mirrorOwnerPost(room, dto);
+                    return { attempted: await this.mirrorOwnerPost(room, dto), delivery: null };
             }
             // A colleague agent on another machine: its post was made in Slack by
             // that machine and reached this one from Slack, stored as a user turn on
@@ -3393,40 +3408,84 @@ export class SlackTeamChannelService {
                 // same step as the resolve: as two steps, a final answer landing in
                 // between found nothing to replace and the re-opened placeholder then
                 // stayed under it (2026-09-28).
+                let postedTs = '';
+                const onMessageTs = (ts) => { postedTs = ts; };
                 if (isInterim(dto))
-                    await this.deps.typing.resolve(typingKey, text, typingIdentity, { reopen: 'typing' });
+                    await this.deps.typing.resolve(typingKey, text, typingIdentity, { reopen: 'typing', onMessageTs });
                 else
-                    await this.deps.typing.resolve(typingKey, text, typingIdentity);
+                    await this.deps.typing.resolve(typingKey, text, typingIdentity, { onMessageTs });
+                const delivery = this.recordDelivery(dto, mapping.slackChannelId, postedTs, threadTs);
                 this.logger.info('Agent reply mirrored to Slack', {
                     slackChannel: mapping.slackChannelName,
                     sender: dto.senderId,
                     threaded: Boolean(threadTs),
                     via: 'typing-placeholder',
+                    ts: postedTs || undefined,
                 });
-                return true;
+                return { attempted: true, delivery };
             }
-            await this.deps.slack.sendMessage({
+            const sentTs = await this.deps.slack.sendMessage({
                 channelId: mapping.slackChannelId,
                 text,
                 threadTs,
                 skipChatV2Mirror: true,
+                senderSession: dto.senderId,
                 ...identity,
             });
+            const delivery = this.recordDelivery(dto, mapping.slackChannelId, sentTs, threadTs);
             this.logger.info('Agent reply mirrored to Slack', {
                 slackChannel: mapping.slackChannelName,
                 sender: dto.senderId,
                 threaded: Boolean(threadTs),
+                ts: sentTs || undefined,
             });
-            return true;
+            return { attempted: true, delivery };
         }
         catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
             this.logger.warn('Outbound mirror to Slack failed', {
                 channelId: dto.channelId,
                 sender: dto.senderId,
+                error,
+            });
+            // The post was attempted for a Slack-mapped room and failed: the
+            // reply call tells the agent instead of reporting success.
+            const mapped = this.findByChatChannelId(dto.channelId);
+            return {
+                attempted: true,
+                delivery: mapped ? { delivered: false, slackChannelId: mapped.slackChannelId, error } : null,
+            };
+        }
+    }
+    /**
+     * Store where a mirrored reply landed on its chat message, in the shape
+     * inbound messages use, so the Slack side can be audited from our store.
+     *
+     * @param dto - The mirrored message
+     * @param slackChannelId - Slack channel posted to
+     * @param ts - Slack ts of the message that carries the reply ('' when unknown)
+     * @param threadTs - Thread the reply is in
+     * @returns The delivery
+     */
+    recordDelivery(dto, slackChannelId, ts, threadTs) {
+        const delivery = {
+            delivered: true,
+            slackChannelId,
+            ...(ts ? { ts } : {}),
+            ...(threadTs ? { threadTs } : {}),
+        };
+        try {
+            this.deps.chat.updateMessageMetadata?.(dto.id, {
+                [SLACK_DELIVERY_METADATA_KEY]: { slackChannelId, ts: ts || null, threadTs: threadTs ?? null },
+            });
+        }
+        catch (err) {
+            this.logger.warn('Could not store the Slack ts on the mirrored message', {
+                messageId: dto.id,
                 error: err instanceof Error ? err.message : String(err),
             });
-            return false;
         }
+        return delivery;
     }
     /**
      * Post a message the owner typed in Crewly into the room's Slack channel,
@@ -3530,7 +3589,7 @@ export class SlackTeamChannelService {
      *
      * @param mapping - Channel mapping
      * @param dto - The agent message (no thread)
-     * @returns True when the post was attempted
+     * @returns The attempt and its delivery (Slack's ts is stored on the chat row)
      */
     async postTopLevel(mapping, dto) {
         let done = () => undefined;
@@ -3544,10 +3603,12 @@ export class SlackTeamChannelService {
                 channelId: mapping.slackChannelId,
                 text,
                 skipChatV2Mirror: true,
+                senderSession: dto.senderId,
                 ...identity,
             });
             if (ts)
                 this.recordSlackRoot(dto, mapping, ts);
+            const delivery = this.recordDelivery(dto, mapping.slackChannelId, ts);
             this.logger.info('Agent reply mirrored to Slack', {
                 slackChannel: mapping.slackChannelName,
                 sender: dto.senderId,
@@ -3555,7 +3616,7 @@ export class SlackTeamChannelService {
                 via: 'top-level',
                 messageId: dto.id,
             });
-            return true;
+            return { attempted: true, delivery };
         }
         finally {
             done();